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

comparison website/src/manual.html.luan @ 1812:f44dcb3fedf7

docs - add code block

author	Franklin Schmidt <fschmidt@gmail.com>
date	Mon, 10 Jun 2024 14:41:48 -0600
parents	ba43135bb98d
children	fa0e73119b7c

comparison

equal deleted inserted replaced

-:55d89a183c82
+:f44dcb3fedf7
 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>
+<code block>
 raw_get(get_metatable(obj) or {}, "__" .. event_name)
-</pre>
+</code>
 <p>
 Here are the events:
 </p>
 <p>
 The following <em>keywords</em> are reserved
 and cannot be used as names:
 </p>
-<p keywords>
+<p list=keywords>
 	<span>and</span>
 	<span>break</span>
 	<span>catch</span>
 	<span>continue</span>
 	<span>do</span>
 <p>
 The following strings denote other tokens:
 </p>
-<pre>
+<p list=tokens>
-+     -     *     /     %     ^     #
+	<span>+</span>
-&amp;     ~     |     &lt;&lt;    &gt;&gt;    //
+	<span>-</span>
-==    ~=    &lt;=    &gt;=    &lt;     &gt;     =
+	<span>*</span>
-(     )     {     }     [     ]     ::
+	<span>/</span>
-;     :     ,     .     ..    ...
+	<span>//</span>
-</pre>
+	<span>%</span>
+	<span>^</span>
+	<span>#</span>
+	<span>&amp;</span>
+	<span>~</span>
+	<span>|</span>
+	<span>==</span>
+	<span>~=</span>
+	<span>&lt;=</span>
+	<span>&gt;=</span>
+	<span>&lt;</span>
+	<span>&gt;</span>
+	<span>=</span>
+	<span>(</span>
+	<span>)</span>
+	<span>{</span>
+	<span>}</span>
+	<span>[</span>
+	<span>]</span>
+	<span>;</span>
+	<span>,</span>
+	<span>.</span>
+	<span>..</span>
+	<span>...</span>
+	<span>%&gt;</span>
+	<span>&lt;%</span>
+	<span>&lt;%=</span>
+</p>
 <p>
 <em>Literal strings</em>
 can be delimited by matching single or double quotes,
 and can contain the following C-like escape sequences:
 the newline is not included in the string.
 As an example
 the five literal strings below denote the same string:
 </p>
-<pre>
+<code block>
 a = 'alo\n123"'
 a = "alo\n123\""
 a = '\97lo\10\04923"'
 a = [[alo
 123"]]
 a = [==[
 alo
 123"]==]
-</pre>
+</code>
 <p>
 A <em>numerical constant</em> (or <em>numeral</em>)
 can be written with an optional fractional part
 and an optional decimal exponent,
 The assignment statement first evaluates all its expressions
 and only then the assignments are performed.
 Thus the code
 </p>
-<pre>
+<code block>
 i = 3
 i, a[i] = i+1, 20
-</pre>
+</code>
 <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&nbsp;4.
 Similarly, the line
 </p>
-<pre>
+<code block>
 x, y = y, x
-</pre>
+</code>
 <p>
 exchanges the values of <code>x</code> and <code>y</code>,
 and
 </p>
-<pre>
+<code block>
 x, y, z = y, z, x
-</pre>
+</code>
 <p>
 cyclically permutes the values of <code>x</code>, <code>y</code>, and <code>z</code>.
 </p>
 <p>
 A <b>for</b> statement like
 </p>
-<pre>
+<code block>
 for <em>var_1</em>, &middot;&middot;&middot;, <em>var_n</em> in <em>exp</em> do <em>block</em> end
-</pre>
+</code>
 <p>
 is equivalent to the code:
 </p>
-<pre>
+<code block>
 do
 local <em>f</em> = <em>exp</em>
 while true do
 local <em>var_1</em>, &middot;&middot;&middot;, <em>var_n</em> = <em>f</em>()
 if <em>var_1</em> == nil then break end
 <em>block</em>
 end
 end
-</pre>
+</code>
 <p>
 Note the following:
 </p>
 <p>
 <a href="#logical_ops">Logical expressions</a> can be statements.
 This is useful in cases like this:
 </p>
-<pre>
+<code block>
-	x==5 or error "x should be 5"
+x==5 or error "x should be 5"
-</pre>
+</code>
 <%
 						end
 					}
 					local_stmt = {
 						title = "Local Declarations"
 						content = function()
 %>
 <p>Template statements provide the full equivalent of <a href="http://en.wikipedia.org/wiki/JavaServer_Pages">JSP</a> but in a general way.  Template statements write to standard output.  For example:</p>
 </p>
-<pre>
+<code block>
-	local name = "Bob"
+local name = "Bob"
-	%&gt;
+%&gt;
-	Hello &lt;%= name %&gt;!
+Hello &lt;%= name %&gt;!
-	Bye &lt;%= name %&gt;.
+Bye &lt;%= name %&gt;.
-	&lt;%
+&lt;%
-</pre>
+</code>
 <p>
 is equivalent to the code:
 </p>
-<pre>
+<code block>
-	local name = "Bob"
+local name = "Bob"
-	require("luan:Io.luan").stdout.write( "Hello ", name , "!\nBye ", name , ".\n" )
+require("luan:Io.luan").stdout.write( "Hello ", name , "!\nBye ", name , ".\n" )
-</pre>
+</code>
 <%
 						end
 					}
 				}
 			}
 starting with 1.
 Fields in the other formats do not affect this counting.
 For example,
 </p>
-<pre>
+<code block>
 a = { [f(1)] = g; "x", "y"; x = 1, f(x), [30] = 23; 45 }
-</pre>
+</code>
 <p>
 is equivalent to
 </p>
-<pre>
+<code block>
 do
 local t = {}
 t[f(1)] = g
 t[1] = "x"         -- 1st exp
 t[2] = "y"         -- 2nd exp
 t.x = 1            -- t["x"] = 1
 t[3] = f(x)        -- 3rd exp
 t[30] = 23
 t[4] = 45          -- 4th exp
 a = t
 end
-</pre>
+</code>
 <p>
 The order of the assignments in a constructor is undefined.
 (This order would be relevant only when there are repeated keys.)
 </p>
 <p>
 Then, we have the following mapping from arguments to parameters and
 to the vararg expression:
 </p>
 <pre>
-CALL            PARAMETERS
+CALL             PARAMETERS
 f(3)             a=3, b=nil
 f(3, 4)          a=3, b=4
 f(3, 4, 5)       runtime error
 f(r(), 10)       runtime error
 						content = function()
 %>
 <p>
 A block between backticks is run and then whatever was sent to standard output is returned as a string.  Examples:
 </p>
-<pre>
+<code block>
-	local s = `%&gt;1 + 1 = &lt;%=1+1%&gt;&lt;%`
+local s = `%&gt;1 + 1 = &lt;%=1+1%&gt;&lt;%`
-	local s = ` fn(whatever) `
+local s = ` fn(whatever) `
-	local s = `%&gt;
+local s = `%&gt;
-	...
+...
-	&lt;%`
+&lt;%`
-</pre>
+</code>
 <p>
 Backticks complement <a href="#template_stmt">template statements</a>.
 </p>
 <%
 						end
 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:
 </p>
-<pre>
+<code block>
-x = 10                -- global variable
+local x = 10          -- global to module
 do                    -- new block
 local x = x         -- new 'x', with value 10
 print(x)            --&gt; 10
 x = x+1
 do                  -- another block
 local x = x+1     -- another 'x'
 print(x)          --&gt; 12
 end
 print(x)            --&gt; 11
 end
 print(x)              --&gt; 10  (the global one)
-</pre>
+</code>
 <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.
 <p>
 Notice that each execution of a <b>local</b> statement
 defines new local variables.
 Consider the following example:
 </p>
-<pre>
-a = {}
+<code block>
-local x = 20
+local a = {}
-for i=1,10 do
+local x = 20
-local y = 0
+for i=1,10 do
-a[i] = function () y=y+1; return x+y end
+local y = 0
-end
+a[i] = function () y=y+1; return x+y end
-</pre>
+end
+</code>
 <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,
 </p>
 <%
 				end
 				subs = {
 					require = {
-						title = "<code>require (mod_uri)</code>"
+						title = "require (mod_uri)"
 						content = function()
 %>
 <p>
 Example use:
 </p>
-<pre>
+<code block>
-	local Table = require "luan:Table.luan"
+local Table = require "luan:Table.luan"
-</pre>
+</code>
 <p>
 Could be defined as:
 </p>
-<pre>
+<code block>
-	local function require(mod_name)
+local function require(mod_name)
-		return <a href="#Package.load">Package.load</a>(mod_name) or <a href="#Luan.error">Luan.error</a>("module '"..mod_name.."' not found")
+	return <a href="#Package.load">Package.load</a>(mod_name) or <a href="#Luan.error">Luan.error</a>("module '"..mod_name.."' not found")
-	end
+end
-</pre>
+</code>
 <p>
 A special case is:
 </p>
-<pre>
+<code block>
-	require "java"
+require "java"
-</pre>
+</code>
 <p>
 This enables Java in the current chunk if that chunk has permission to use Java.  If the chunk doesn't have permission to use Java, then an error is thrown.
 </p>
 <%
 				content = function()
 %>
 <p>
 Include this library by:
 </p>
-<pre>
-	local Luan = require "luan:Luan.luan"
+<code block>
-</pre>
+local Luan = require "luan:Luan.luan"
+</code>
 <p>
 The basic library provides basic functions to Luan that don't depend on other libaries.
 </p>
 <%
 				end
 				subs = {
 					["Luan.do_file"] = {
-						title = "<code>Luan.do_file ([uri])</code>"
+						title = "Luan.do_file ([uri])"
 						content = function()
 %>
 <p>
 Could be defined as:
 </p>
-<pre>
+<code block>
-	function Luan.do_file(uri)
+function Luan.do_file(uri)
-		local fn = <a href="#Luan.load_file">Luan.load_file</a>(uri) or <a href="#Luan.error">Luan.error</a>("file '"..uri.."' not found")
+	local fn = <a href="#Luan.load_file">Luan.load_file</a>(uri) or <a href="#Luan.error">Luan.error</a>("file '"..uri.."' not found")
-		return fn()
+	return fn()
-	end
+end
-</pre>
+</code>
 <%
 						end
 					}
 					["Luan.error"] = {
-						title = "<code>Luan.error (message)</code>"
+						title = "Luan.error (message)"
 						content = function()
 %>
 <p>
 Throws an error containing the message.
 </p>
 <p>
 Could be defined as:
 </p>
-<pre>
+<code block>
-	function Luan.error(message)
+function Luan.error(message)
-		<a href="#Luan.new_error">Luan.new_error</a>(message).throw()
+	<a href="#Luan.new_error">Luan.new_error</a>(message).throw()
-	end
+end
-</pre>
+</code>
 <%
 						end
 					}
 					["Luan.eval"] = {
-						title = "<code>Luan.eval (text [, source_name [, env]])</code>"
+						title = "Luan.eval (text [, source_name [, env]])"
 						content = function()
 %>
 <p>
 Evaluates <code>text</code> as a Luan expression.
 </p>
 <p>
 Could be defined as:
 </p>
-<pre>
+<code block>
-	function Luan.eval(text,source_name, env)
+function Luan.eval(text,source_name, env)
-		return <a href="#Luan.load">Luan.load</a>( "return "..text, source_name or "eval", env )()
+	return <a href="#Luan.load">Luan.load</a>( "return "..text, source_name or "eval", env )()
-	end
+end
-</pre>
+</code>
 <%
 						end
 					}
 					["Luan.get_metatable"] = {
-						title = "<code>Luan.get_metatable (table)</code>"
+						title = "Luan.get_metatable (table)"
 						content = function()
 %>
 <p>
 If <code>table</code> does not have a metatable, returns <b>nil</b>.
 Otherwise,
 </p>
 <%
 						end
 					}
 					["Luan.hash_code"] = {
-						title = "<code>Luan.hash_code (v)</code>"
+						title = "Luan.hash_code (v)"
 						content = function()
 %>
 <p>
 Returns the hash code of <code>v</code>.
 </p>
 <%
 						end
 					}
 					["Luan.ipairs"] = {
-						title = "<code>Luan.ipairs (t)</code>"
+						title = "Luan.ipairs (t)"
 						content = function()
 %>
 <p>
 Returns an iterator function
 so that the construction
 </p>
 <p>
 Could be defined as:
 </p>
-<pre>
+<code block>
-	function Luan.ipairs(t)
+function Luan.ipairs(t)
-		local i = 0
+	local i = 0
-		return function()
+	return function()
-			if i < #t then
+		if i < #t then
-				i = i + 1
+			i = i + 1
-				return i, t[i]
+			return i, t[i]
-			end
 		end
 	end
-</pre>
+end
+</code>
 <%
 						end
 					}
 					["Luan.load"] = {
-						title = "<code>Luan.load (text, [source_name [, env [, persist]]])</code>"
+						title = "Luan.load (text, [source_name [, env [, persist]]])"
 						content = function()
 %>
 <p>
 Loads a chunk.
 </p>
 </p>
 <%
 						end
 					}
 					["Luan.load_file"] = {
-						title = "<code>Luan.load_file (file_uri)</code>"
+						title = "Luan.load_file (file_uri)"
 						content = function()
 %>
 <p>
 Similar to <a href="#Luan.load"><code>load</code></a>,
 but gets the chunk from file <code>file_uri</code>.
 </p>
 <%
 						end
 					}
 					["Luan.new_error"] = {
-						title = "<code>Luan.new_error (message)</code>"
+						title = "Luan.new_error (message)"
 						content = function()
 %>
 <p>
 Creates a new error table containing the message assigned to "<code>message</code>".  The error table also contains a <code>throw</code> function which throws the error.  The table also contains a list of stack trace elements where each stack trace element is a table containing "<code>source</code>", "<code>line</code>", and possible "<code>call_to</code>".  The table also has a metatable containing "<code>__to_string</code>" to render the error.
 </p>
 <p>
 To print the current stack trace, you could do:
 </p>
-<pre>
+<code block>
-	Io.print( Luan.new_error "stack" )
+Io.print( Luan.new_error "stack" )
-</pre>
+</code>
 <%
 						end
 					}
 					["Luan.pairs"] = {
-						title = "<code>Luan.pairs (t)</code>"
+						title = "Luan.pairs (t)"
 						content = function()
 %>
 <p>
 If <code>t</code> has a metamethod <code>__pairs</code>,
 calls it with <code>t</code> as argument and returns the
 </p>
 <%
 						end
 					}
 					["Luan.range"] = {
-						title = "<code>Luan.range (start, stop [, step])</code>"
+						title = "Luan.range (start, stop [, step])"
 						content = function()
 %>
 <p>
 Based on <a href="https://docs.python.org/2/library/functions.html#range">the Python range() function</a>, this lets one iterate through a sequence of numbers.
 </p>
 <p>
 Example use:
 </p>
-<pre>
+<code block>
-	for i in range(1,10) do
+for i in range(1,10) do
-		Io.print("count up:",i)
+	Io.print("count up:",i)
-	end
+end
-	for i in range(10,0,-1) do
+for i in range(10,0,-1) do
-		Io.print("count down:",i)
+	Io.print("count down:",i)
-	end
+end
-</pre>
+</code>
 <p>
 Could be defined as:
 </p>
-<pre>
+<code block>
-	function Luan.range(start, stop, step)
+function Luan.range(start, stop, step)
-		step = step or 1
+	step = step or 1
-		step == 0 and <a href="#Luan.error">Luan.error</a> "bad argument #3 (step may not be zero)"
+	step == 0 and <a href="#Luan.error">Luan.error</a> "bad argument #3 (step may not be zero)"
-		local i = start
+	local i = start
-		return function()
+	return function()
-			if step > 0 and i <= stop or step < 0 and i >= stop then
+		if step > 0 and i <= stop or step < 0 and i >= stop then
-				local rtn = i
+			local rtn = i
-				i = i + step
+			i = i + step
-				return rtn
+			return rtn
-			end
 		end
 	end
-</pre>
+end
+</code>
 <%
 						end
 					}
 					["Luan.raw_equal"] = {
-						title = "<code>Luan.raw_equal (v1, v2)</code>"
+						title = "Luan.raw_equal (v1, v2)"
 						content = function()
 %>
 <p>
 Checks whether <code>v1</code> is equal to <code>v2</code>,
 without invoking any metamethod.
 </p>
 <%
 						end
 					}
 					["Luan.raw_get"] = {
-						title = "<code>Luan.raw_get (table, index)</code>"
+						title = "Luan.raw_get (table, index)"
 						content = function()
 %>
 <p>
 Gets the real value of <code>table[index]</code>,
 without invoking any metamethod.
 </p>
 <%
 						end
 					}
 					["Luan.raw_len"] = {
-						title = "<code>Luan.raw_len (v)</code>"
+						title = "Luan.raw_len (v)"
 						content = function()
 %>
 <p>
 Returns the length of the object <code>v</code>,
 which must be a table or a string,
 </p>
 <%
 						end
 					}
 					["Luan.raw_set"] = {
-						title = "<code>Luan.raw_set (table, index, value)</code>"
+						title = "Luan.raw_set (table, index, value)"
 						content = function()
 %>
 <p>
 Sets the real value of <code>table[index]</code> to <code>value</code>,
 without invoking any metamethod.
 </p>
 <%
 						end
 					}
 					["Luan.set_metatable"] = {
-						title = "<code>Luan.set_metatable (table, metatable)</code>"
+						title = "Luan.set_metatable (table, metatable)"
 						content = function()
 %>
 <p>
 Sets the metatable for the given table.
 If <code>metatable</code> is <b>nil</b>,
 </p>
 <%
 						end
 					}
 					["Luan.stringify"] = {
-						title = "<code>Luan.stringify (v [,options])</code>"
+						title = "Luan.stringify (v [,options])"
 						content = function()
 %>
 <p>
 Receives a value of any type and converts it to a string that is a Luan expression.  <code>options</code> is a table.  If <code>options.strict==true</code> then invalid types throw an error.  Otherwise invalid types are represented but the resulting expression is invalid.  If <code>options.number_types==true</code> then numbers will be wrapped in functions for their type.
 </p>
 <%
 						end
 					}
 					["Luan.to_string"] = {
-						title = "<code>Luan.to_string (v)</code>"
+						title = "Luan.to_string (v)"
 						content = function()
 %>
 <p>
 Receives a value of any type and
 converts it to a string in a human-readable format.
 </p>
 <%
 						end
 					}
 					["Luan.type"] = {
-						title = "<code>Luan.type (v)</code>"
+						title = "Luan.type (v)"
 						content = function()
 %>
 <p>
 Returns the type of its only argument, coded as a string.
 The possible results of this function are
 </p>
 <%
 						end
 					}
 					["Luan.values"] = {
-						title = "<code>Luan.values (&middot;&middot;&middot;)</code>"
+						title = "Luan.values (&middot;&middot;&middot;)"
 						content = function()
 %>
 <p>
 Returns a function so that the construction
 </p>
 </p>
 <%
 						end
 					}
 					["Luan.VERSION"] = {
-						title = "<code>Luan.VERSION</code>"
+						title = "Luan.VERSION"
 						content = function()
 %>
 <p>
 A global variable (not a function) that
 holds a string containing the current Luan version.
 				content = function()
 %>
 <p>
 Include this library by:
 </p>
-<pre>
+<code block>
-	local Package = require "luan:Package.luan"
+local Package = require "luan:Package.luan"
-</pre>
+</code>
 <p>
 The package library provides basic
 facilities for loading modules in Luan.
 </p>
 <%
 				end
 				subs = {
 					["Package.load"] = {
-						title = "<code>Package.load (mod_uri)</code>"
+						title = "Package.load (mod_uri)"
 						content = function()
 %>
 <p>
 Loads the given module.
 The function starts by looking into the <a href="#Package.loaded"><code>Package.loaded</code></a> table
 </p>
 <%
 						end
 					}
 					["Package.loaded"] = {
-						title = "<code>Package.loaded</code>"
+						title = "Package.loaded"
 						content = function()
 %>
 <p>
 A table used by <a href="#Package.load"><code>Package.load</code></a> to control which
 modules are already loaded.
 				content = function()
 %>
 <p>
 Include this library by:
 </p>
-<pre>
+<code block>
-	local String = require "luan:String.luan"
+local String = require "luan:String.luan"
-</pre>
+</code>
 <p>
 This library provides generic functions for string manipulation,
 such as finding and extracting substrings, and pattern matching.
 When indexing a string in Luan, the first character is at position&nbsp;1
 </p>
 <%
 				end
 				subs = {
 					["String.char"] = {
-						title = "<code>String.char (&middot;&middot;&middot;)</code>"
+						title = "String.char (&middot;&middot;&middot;)"
 						content = function()
 %>
 <p>
 Receives zero or more integers.
 Returns a string with length equal to the number of arguments,
 </p>
 <%
 						end
 					}
 					["String.contains"] = {
-						title = "<code>String.contains (s, s2)</code>"
+						title = "String.contains (s, s2)"
 						content = function()
 %>
 <p>
 Returns a boolean indicating whether the <code>s</code> contains <code>s2</code>.
 </p>
 <%
 						end
 					}
 					["String.encode"] = {
-						title = "<code>String.encode (s)</code>"
+						title = "String.encode (s)"
 						content = function()
 %>
 <p>
 Encodes argument <code>s</code> into a string that can be placed in quotes so as to return the original value of the string.
 </p>
 <%
 						end
 					}
 					["String.ends_with"] = {
-						title = "<code>String.ends_with (s, s2)</code>"
+						title = "String.ends_with (s, s2)"
 						content = function()
 %>
 <p>
 Returns a boolean indicating whether the <code>s</code> ends with <code>s2</code>.
 </p>
 <%
 						end
 					}
 					["String.find"] = {
-						title = "<code>String.find (s, s2 [, init])</code>"
+						title = "String.find (s, s2 [, init])"
 						content = function()
 %>
 <p>
 Looks for the first substring
 <code>s2</code> in the string <code>s</code>.
 </p>
 <%
 						end
 					}
 					["String.format"] = {
-						title = "<code>String.format (formatstring, &middot;&middot;&middot;)</code>"
+						title = "String.format (formatstring, &middot;&middot;&middot;)"
 						content = function()
 %>
 <p>
 Returns a formatted version of its variable number of arguments
 following the description given in its first argument (which must be a string).
 </p>
 <%
 						end
 					}
 					["String.lower"] = {
-						title = "<code>String.lower (s)</code>"
+						title = "String.lower (s)"
 						content = function()
 %>
 <p>
 Receives a string and returns a copy of this string with all
 uppercase letters changed to lowercase.
 </p>
 <%
 						end
 					}
 					["String.regex"] = {
-						title = "<code>String.regex (s)</code>"
+						title = "String.regex (s)"
 						content = function()
 %>
 <p>
 Returns a <a href="#regex_table">regex</a> table for the pattern <code>s</code>.
 </p>
 <%
 						end
 					}
 					["String.regex_quote"] = {
-						title = "<code>String.regex_quote (s)</code>"
+						title = "String.regex_quote (s)"
 						content = function()
 %>
 <p>
 Returns a string which matches the literal string <code>s</code> in a regular expression.  This function is simply the Java method <a href="http://docs.oracle.com/javase/7/docs/api/java/util/regex/Pattern.html#quote(java.lang.String)"><code>Pattern.quote</code></a>.
 </p>
 <%
 						end
 					}
 					["String.repeated"] = {
-						title = "<code>String.repeated (s, n [, sep])</code>"
+						title = "String.repeated (s, n [, sep])"
 						content = function()
 %>
 <p>
 Returns a string that is the concatenation of <code>n</code> copies of
 the string <code>s</code> separated by the string <code>sep</code>.
 </p>
 <%
 						end
 					}
 					["String.replace"] = {
-						title = "<code>String.replace (s, target, replacement)</code>"
+						title = "String.replace (s, target, replacement)"
 						content = function()
 %>
 <p>
 Returns a string where each substring <code>target</code> in <code>s</code> is replaced by <code>replacement</code>.
 </p>
 <%
 						end
 					}
 					["String.reverse"] = {
-						title = "<code>String.reverse (s)</code>"
+						title = "String.reverse (s)"
 						content = function()
 %>
 <p>
 Returns a string that is the string <code>s</code> reversed.
 </p>
 <%
 						end
 					}
 					["String.split"] = {
-						title = "<code>String.split (s, s2 [, limit])</code>"
+						title = "String.split (s, s2 [, limit])"
 						content = function()
 %>
 <p>
 Splits <code>s</code> using substring <code>s2</code> and returns the results.  If <code>limit</code> is positive, then only returns at most that many results.  If <code>limit</code> is zero, then remove trailing empty results.
 </p>
 <%
 						end
 					}
 					["String.starts_with"] = {
-						title = "<code>String.starts_with (s, s2)</code>"
+						title = "String.starts_with (s, s2)"
 						content = function()
 %>
 <p>
 Returns a boolean indicating whether the <code>s</code> starts with <code>s2</code>.
 </p>
 <%
 						end
 					}
 					["String.sub"] = {
-						title = "<code>String.sub (s, i [, j])</code>"
+						title = "String.sub (s, i [, j])"
 						content = function()
 %>
 <p>
 Returns the substring of <code>s</code> that
 starts at <code>i</code>  and continues until <code>j</code>;
 </p>
 <%
 						end
 					}
 					["String.to_binary"] = {
-						title = "<code>String.to_binary (s)</code>"
+						title = "String.to_binary (s)"
 						content = function()
 %>
 <p>
 Converts a string to a binary by calling the Java method <a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html#getBytes()"><code>String.getBytes</code></a>.
 </p>
 <%
 						end
 					}
 					["String.to_number"] = {
-						title = "<code>String.to_number (s [, base])</code>"
+						title = "String.to_number (s [, base])"
 						content = function()
 %>
 <p>
 When called with no <code>base</code>,
 <code>to_number</code> tries to convert its argument to a number.
 </p>
 <%
 						end
 					}
 					["String.trim"] = {
-						title = "<code>String.trim (s)</code>"
+						title = "String.trim (s)"
 						content = function()
 %>
 <p>
 Removes the leading and trailing whitespace by calling the Java method <a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html#trim()"><code>String.trim</code></a>.
 </p>
 <%
 						end
 					}
 					["String.unicode"] = {
-						title = "<code>String.unicode (s [, i [, j]])</code>"
+						title = "String.unicode (s [, i [, j]])"
 						content = function()
 %>
 <p>
 Returns the internal numerical codes of the characters <code>s[i]</code>,
 <code>s[i+1]</code>, ..., <code>s[j]</code>.
 </p>
 <%
 						end
 					}
 					["String.upper"] = {
-						title = "<code>String.upper (s)</code>"
+						title = "String.upper (s)"
 						content = function()
 %>
 <p>
 Receives a string and returns a copy of this string with all
 lowercase letters changed to uppercase.
 </p>
 <%
 				end
 				subs = {
 					["regex.find"] = {
-						title = "<code>regex.find (s [, init])</code>"
+						title = "regex.find (s [, init])"
 						content = function()
 %>
 <p>
 Looks for the first match of
 the regex in the string <code>s</code>.
 </p>
 <%
 						end
 					}
 					["regex.gmatch"] = {
-						title = "<code>regex.gmatch (s)</code>"
+						title = "regex.gmatch (s)"
 						content = function()
 %>
 <p>
 Returns an iterator function that,
 each time it is called,
 <p>
 As an example, the following loop
 will iterate over all the words from string <code>s</code>,
 printing one per line:
 </p>
-<pre>
+<code block>
-	local r = String.regex[[\w+]]
+local r = String.regex[[\w+]]
-	local s = "hello world from Lua"
+local s = "hello world from Lua"
-	for w in r.gmatch(s) do
+for w in r.gmatch(s) do
-		print(w)
+	print(w)
-	end
+end
-</pre>
+</code>
 <p>
 The next example collects all pairs <code>key=value</code> from the
 given string into a table:
 </p>
-<pre>
+<code block>
-	local t = {}
+local t = {}
-	local r = String.regex[[(\w+)=(\w+)]]
+local r = String.regex[[(\w+)=(\w+)]]
-	local s = "from=world, to=Lua"
+local s = "from=world, to=Lua"
-	for k, v in r.gmatch(s) do
+for k, v in r.gmatch(s) do
-		t[k] = v
+	t[k] = v
-	end
+end
-</pre>
+</code>
 <p>
 For this function, a caret '<code>^</code>' at the start of a pattern does not
 work as an anchor, as this would prevent the iteration.
 </p>
 <%
 						end
 					}
 					["regex.gsub"] = {
-						title = "<code>regex.gsub (s, repl [, n])</code>"
+						title = "regex.gsub (s, repl [, n])"
 						content = function()
 %>
 <p>
 Returns a copy of <code>s</code>
 in which all (or the first <code>n</code>, if given)
 </p>
 <p>
 Here are some examples:
 </p>
-<pre>
-	local r = String.regex[[(\w+)]]
+<code block>
-	local x = r.gsub("hello world", "$1 $1")
+local r = String.regex[[(\w+)]]
-	--&gt; x="hello hello world world"
+local x = r.gsub("hello world", "$1 $1")
+--&gt; x="hello hello world world"
-	local r = String.regex[[(\w+)]]
-	local x = r.gsub("hello world", "$0 $0", 1)
+local r = String.regex[[(\w+)]]
-	--&gt; x="hello hello world"
+local x = r.gsub("hello world", "$0 $0", 1)
+--&gt; x="hello hello world"
-	local r = String.regex[[(\w+)\s*(\w+)]]
-	local x = r.gsub("hello world from Luan", "$2 $1")
+local r = String.regex[[(\w+)\s*(\w+)]]
-	--&gt; x="world hello Luan from"
+local x = r.gsub("hello world from Luan", "$2 $1")
+--&gt; x="world hello Luan from"
-	local r = String.regex[[\$(.*?)\$]]
-	local x = r.gsub("4+5 = $return 4+5$", function(s)
+local r = String.regex[[\$(.*?)\$]]
-		return load(s)()
+local x = r.gsub("4+5 = $return 4+5$", function(s)
-	end)
+	return load(s)()
-	--&gt; x="4+5 = 9"
+end)
+--&gt; x="4+5 = 9"
-	local r = String.regex[[\$(\w+)]]
-	local t = {name="lua", version="5.3"}
+local r = String.regex[[\$(\w+)]]
-	local x = r.gsub("$name-$version.tar.gz", t)
+local t = {name="lua", version="5.3"}
-	--&gt; x="lua-5.3.tar.gz"
+local x = r.gsub("$name-$version.tar.gz", t)
-</pre>
+--&gt; x="lua-5.3.tar.gz"
+</code>
 <%
 						end
 					}
 					["regex.match"] = {
-						title = "<code>regex.match (s [, init])</code>"
+						title = "regex.match (s [, init])"
 						content = function()
 %>
 <p>
 Looks for the first <em>match</em> of
 the regex in the string <code>s</code>.
 </p>
 <%
 						end
 					}
 					["regex.matches"] = {
-						title = "<code>regex.matches (s)</code>"
+						title = "regex.matches (s)"
 						content = function()
 %>
 <p>
 Returns a boolean indicating whether the regex can be found in string <code>s</code>.
 This function is equivalent to
 </p>
-<pre>
+<code block>
 return regex.match(s) ~= nil
-</pre>
+</code>
 <%
 						end
 					}
 					["regex.set"] = {
-						title = "<code>regex.set (pattern)</code>"
+						title = "regex.set (pattern)"
 						content = function()
 %>
 <p>
 Changes the regex pattern to <code>pattern</code>.
 </p>
 <%
 						end
 					}
 					["regex.split"] = {
-						title = "<code>regex.split (s [, limit])</code>"
+						title = "regex.split (s [, limit])"
 						content = function()
 %>
 <p>
 Splits <code>s</code> using the regex and returns the results.  If <code>limit</code> is positive, then only returns at most that many results.  If <code>limit</code> is zero, then remove trailing empty results.
 </p>
 				content = function()
 %>
 <p>
 Include this library by:
 </p>
-<pre>
+<code block>
-	local Binary = require "luan:Binary.luan"
+local Binary = require "luan:Binary.luan"
-</pre>
+</code>
 <%
 				end
 				subs = {
 					["Binary.binary"] = {
-						title = "<code>Binary.binary (&middot;&middot;&middot;)</code>"
+						title = "Binary.binary (&middot;&middot;&middot;)"
 						content = function()
 %>
 <p>
 Receives zero or more bytes (as integers).
 Returns a binary with length equal to the number of arguments,
 </p>
 <%
 						end
 					}
 					["Binary.byte"] = {
-						title = "<code>Binary.byte (b [, i [, j]])</code>"
+						title = "Binary.byte (b [, i [, j]])"
 						content = function()
 %>
 <p>
 Returns the internal numerical codes of the bytes <code>b[i]</code>,
 <code>b[i+1]</code>, ..., <code>b[j]</code>.
 </p>
 <%
 						end
 					}
 					["Binary.to_string"] = {
-						title = "<code>Binary.to_string (b [,charset])</code>"
+						title = "Binary.to_string (b [,charset])"
 						content = function()
 %>
 <p>
 If <code>charset</code> is not nil then converts the binary <code>b</code> to a string using the Java <a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html#String(byte[],%20java.lang.String)">String constructor</a>, else makes each byte a char.
 </p>
 				content = function()
 %>
 <p>
 Include this library by:
 </p>
-<pre>
+<code block>
-	local Table = require "luan:Table.luan"
+local Table = require "luan:Table.luan"
-</pre>
+</code>
 <p>
 This library provides generic functions for table manipulation.
 It provides all its functions inside the table <code>Table</code>.
 </p>
 <%
 				end
 				subs = {
 					["Table.clear"] = {
-						title = "<code>Table.clear (tbl)</code>"
+						title = "Table.clear (tbl)"
 						content = function()
 %>
 <p>
 Clears the table.
 </p>
 <%
 						end
 					}
 					["Table.concat"] = {
-						title = "<code>Table.concat (list [, sep [, i [, j]]])</code>"
+						title = "Table.concat (list [, sep [, i [, j]]])"
 						content = function()
 %>
 <p>
 Given a list,
 returns the string <code>list[i]..sep..list[i+1] &middot;&middot;&middot; sep..list[j]</code>.
 </p>
 <%
 						end
 					}
 					["Table.copy"] = {
-						title = "<code>Table.copy (tbl [, i [, j]])</code>"
+						title = "Table.copy (tbl [, i [, j]])"
 						content = function()
 %>
 <p>
 If <code>i</code> is <code>nil</code>, returns a shallow copy of <code>tbl</code>.
 Otherwise returns a new table which is a list of the elements <code>tbl[i] &middot;&middot;&middot; tbl[j]</code>.
 </p>
 <%
 						end
 					}
 					["Table.insert"] = {
-						title = "<code>Table.insert (list, pos, value)</code>"
+						title = "Table.insert (list, pos, value)"
 						content = function()
 %>
 <p>
 Inserts element <code>value</code> at position <code>pos</code> in <code>list</code>,
 shifting up the elements
 </p>
 <%
 						end
 					}
 					["Table.is_empty"] = {
-						title = "<code>Table.is_empty (tbl)</code>"
+						title = "Table.is_empty (tbl)"
 						content = function()
 %>
 <%
 						end
 					}
 					["Table.is_list"] = {
-						title = "<code>Table.is_list (tbl)</code>"
+						title = "Table.is_list (tbl)"
 						content = function()
 %>
 <%
 						end
 					}
 					["Table.pack"] = {
-						title = "<code>Table.pack (&middot;&middot;&middot;)</code>"
+						title = "Table.pack (&middot;&middot;&middot;)"
 						content = function()
 %>
 <p>
 Returns a new table with all parameters stored into keys 1, 2, etc.
 and with a field "<code>n</code>" with the total number of parameters.
 </p>
 <%
 						end
 					}
 					["Table.remove"] = {
-						title = "<code>Table.remove (list, pos)</code>"
+						title = "Table.remove (list, pos)"
 						content = function()
 %>
 <p>
 Removes from <code>list</code> the element at position <code>pos</code>,
 returning the value of the removed element.
 </p>
 <%
 						end
 					}
 					["Table.size"] = {
-						title = "<code>Table.size (tbl)</code>"
+						title = "Table.size (tbl)"
 						content = function()
 %>
 <%
 						end
 					}
 					["Table.sort"] = {
-						title = "<code>Table.sort (list [, comp])</code>"
+						title = "Table.sort (list [, comp])"
 						content = function()
 %>
 <p>
 Sorts list elements in a given order, <em>in-place</em>,
 from <code>list[1]</code> to <code>list[#list]</code>.
 </p>
 <%
 						end
 					}
 					["Table.unpack"] = {
-						title = "<code>Table.unpack (list [, i [, j]])</code>"
+						title = "Table.unpack (list [, i [, j]])"
 						content = function()
 %>
 <p>
 Returns the elements from the given list.
 This function is equivalent to
 </p>
-<pre>
+<code block>
 return list[i], list[i+1], &middot;&middot;&middot;, list[j]
-</pre>
+</code>
 <p>
 By default, <code>i</code> is 1 and <code>j</code> is <code>list.n or #list</code>.
 </p>
 <%
 				content = function()
 %>
 <p>
 Include this library by:
 </p>
-<pre>
+<code block>
-	local Number = require "luan:Number.luan"
+local Number = require "luan:Number.luan"
-</pre>
+</code>
 <%
 				end
 				subs = {
 					["Number.double"] = {
-						title = "<code>Number.double (x)</code>"
+						title = "Number.double (x)"
 						content = function()
 %>
 <p>
 Returns <code>x</code> as a double.
 </p>
 <%
 						end
 					}
 					["Number.float"] = {
-						title = "<code>Number.float (x)</code>"
+						title = "Number.float (x)"
 						content = function()
 %>
 <p>
 Returns <code>x</code> as a float.
 </p>
 <%
 						end
 					}
 					["Number.integer"] = {
-						title = "<code>Number.integer (x)</code>"
+						title = "Number.integer (x)"
 						content = function()
 %>
 <p>
 If the value <code>x</code> is convertible to an integer,
 returns that integer.
 </p>
 <%
 						end
 					}
 					["Number.long"] = {
-						title = "<code>Number.long (x)</code>"
+						title = "Number.long (x)"
 						content = function()
 %>
 <p>
 If the value <code>x</code> is convertible to an long,
 returns that long.
 </p>
 <%
 						end
 					}
 					["Number.long_to_string"] = {
-						title = "<code>Number.long_to_string (i, radix)</code>"
+						title = "Number.long_to_string (i, radix)"
 						content = function()
 %>
 <p>
 Converts long value <code>i</code> to a string by calling <code><a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Long.html#toString(long,%20int)">Long.toString</a></code>.
 </p>
 <%
 						end
 					}
 					["Number.type"] = {
-						title = "<code>Number.type (x)</code>"
+						title = "Number.type (x)"
 						content = function()
 %>
 <p>
 Returns a string for the numeric type of <code>x</code>.  Possible return values include "<code>integer</code>", "<code>long</code>", "<code>double</code>", and "<code>float</code>".
 </p>
 				content = function()
 %>
 <p>
 Include this library by:
 </p>
-<pre>
+<code block>
-	local Math = require "luan:Math.luan"
+local Math = require "luan:Math.luan"
-</pre>
+</code>
 <p>
 This library provides basic mathematical functions.
 It provides all its functions and constants inside the table <code>Math</code>.
 </p>
 <%
 				end
 				subs = {
 					["Math.abs"] = {
-						title = "<code>Math.abs (x)</code>"
+						title = "Math.abs (x)"
 						content = function()
 %>
 <p>
 Returns the absolute value of <code>x</code>.
 </p>
 <%
 						end
 					}
 					["Math.acos"] = {
-						title = "<code>Math.acos (x)</code>"
+						title = "Math.acos (x)"
 						content = function()
 %>
 <p>
 Returns the arc cosine of <code>x</code> (in radians).
 </p>
 <%
 						end
 					}
 					["Math.asin"] = {
-						title = "<code>Math.asin (x)</code>"
+						title = "Math.asin (x)"
 						content = function()
 %>
 <p>
 Returns the arc sine of <code>x</code> (in radians).
 </p>
 <%
 						end
 					}
 					["Math.atan"] = {
-						title = "<code>Math.atan (y, x)</code>"
+						title = "Math.atan (y, x)"
 						content = function()
 %>
 <p>
 Returns the arc tangent of <code>y/x</code> (in radians),
 but uses the signs of both parameters to find the
 </p>
 <%
 						end
 					}
 					["Math.ceil"] = {
-						title = "<code>Math.ceil (x)</code>"
+						title = "Math.ceil (x)"
 						content = function()
 %>
 <p>
 Returns the smallest integral value larger than or equal to <code>x</code>.
 </p>
 <%
 						end
 					}
 					["Math.cos"] = {
-						title = "<code>Math.cos (x)</code>"
+						title = "Math.cos (x)"
 						content = function()
 %>
 <p>
 Returns the cosine of <code>x</code> (assumed to be in radians).
 </p>
 <%
 						end
 					}
 					["Math.deg"] = {
-						title = "<code>Math.deg (x)</code>"
+						title = "Math.deg (x)"
 						content = function()
 %>
 <p>
 Converts the angle <code>x</code> from radians to degrees.
 </p>
 <%
 						end
 					}
 					["Math.exp"] = {
-						title = "<code>Math.exp (x)</code>"
+						title = "Math.exp (x)"
 						content = function()
 %>
 <p>
 Returns the value <em>e<sup>x</sup></em>
 (where <code>e</code> is the base of natural logarithms).
 </p>
 <%
 						end
 					}
 					["Math.floor"] = {
-						title = "<code>Math.floor (x)</code>"
+						title = "Math.floor (x)"
 						content = function()
 %>
 <p>
 Returns the largest integral value smaller than or equal to <code>x</code>.
 </p>
 <%
 						end
 					}
 					["Math.fmod"] = {
-						title = "<code>Math.fmod (x, y)</code>"
+						title = "Math.fmod (x, y)"
 						content = function()
 %>
 <p>
 Returns the remainder of the division of <code>x</code> by <code>y</code>
 that rounds the quotient towards zero.
 </p>
 <%
 						end
 					}
 					["Math.huge"] = {
-						title = "<code>Math.huge</code>"
+						title = "Math.huge"
 						content = function()
 %>
 <p>
 A value larger than any other numerical value.
 </p>
 <%
 						end
 					}
 					["Math.log"] = {
-						title = "<code>Math.log (x [, base])</code>"
+						title = "Math.log (x [, base])"
 						content = function()
 %>
 <p>
 Returns the logarithm of <code>x</code> in the given base.
 The default for <code>base</code> is <em>e</em>
 </p>
 <%
 						end
 					}
 					["Math.max"] = {
-						title = "<code>Math.max (x, &middot;&middot;&middot;)</code>"
+						title = "Math.max (x, &middot;&middot;&middot;)"
 						content = function()
 %>
 <p>
 Returns the argument with the maximum value,
 according to the Lua operator <code>&lt;</code>.
 </p>
 <%
 						end
 					}
 					["Math.max_integer"] = {
-						title = "<code>Math.max_integer</code>"
+						title = "Math.max_integer"
 						content = function()
 %>
 <p>
 An integer with the maximum value for an integer.
 </p>
 <%
 						end
 					}
 					["Math.min"] = {
-						title = "<code>Math.min (x, &middot;&middot;&middot;)</code>"
+						title = "Math.min (x, &middot;&middot;&middot;)"
 						content = function()
 %>
 <p>
 Returns the argument with the minimum value,
 according to the Lua operator <code>&lt;</code>.
 </p>
 <%
 						end
 					}
 					["Math.min_integer"] = {
-						title = "<code>Math.min_integer</code>"
+						title = "Math.min_integer"
 						content = function()
 %>
 <p>
 An integer with the minimum value for an integer.
 </p>
 <%
 						end
 					}
 					["Math.modf"] = {
-						title = "<code>Math.modf (x)</code>"
+						title = "Math.modf (x)"
 						content = function()
 %>
 <p>
 Returns the integral part of <code>x</code> and the fractional part of <code>x</code>.
 </p>
 <%
 						end
 					}
 					["Math.pi"] = {
-						title = "<code>Math.pi</code>"
+						title = "Math.pi"
 						content = function()
 %>
 <p>
 The value of <em>&pi;</em>.
 </p>
 <%
 						end
 					}
 					["Math.rad"] = {
-						title = "<code>Math.rad (x)</code>"
+						title = "Math.rad (x)"
 						content = function()
 %>
 <p>
 Converts the angle <code>x</code> from degrees to radians.
 </p>
 <%
 						end
 					}
 					["Math.random"] = {
-						title = "<code>Math.random ([m [, n])</code>"
+						title = "Math.random ([m [, n])"
 						content = function()
 %>
 <p>
 When called without arguments,
 returns a pseudo-random float with uniform distribution
 </p>
 <%
 						end
 					}
 					["Math.sin"] = {
-						title = "<code>Math.sin (x)</code>"
+						title = "Math.sin (x)"
 						content = function()
 %>
 <p>
 Returns the sine of <code>x</code> (assumed to be in radians).
 </p>
 <%
 						end
 					}
 					["Math.sqrt"] = {
-						title = "<code>Math.sqrt (x)</code>"
+						title = "Math.sqrt (x)"
 						content = function()
 %>
 <p>
 Returns the square root of <code>x</code>.
 (You can also use the expression <code>x^0.5</code> to compute this value.)
 </p>
 <%
 						end
 					}
 					["Math.tan"] = {
-						title = "<code>Math.tan (x)</code>"
+						title = "Math.tan (x)"
 						content = function()
 %>
 <p>
 Returns the tangent of <code>x</code> (assumed to be in radians).
 </p>
 <html>
 	<head>
 <%		head() %>
 		<title>Luan Reference Manual</title>
 		<style>
-			p[keywords] {
+			p[list] {
 				font-family: monospace;
 				margin-left: 40px;
+			}
+			p[list] span {
+				display: inline-block;
+			}
+			p[list=keywords] {
 				max-width: 700px;
 			}
-			p[keywords] span {
+			p[list=keywords] span {
-				display: inline-block;
 				width: 100px;
 			}
-			code {
+			p[list=tokens] {
-				font-size: 16px;
+				max-width: 400px;
-				font-weight: bold;
 			}
-			div[toc] code {
+			p[list=tokens] span {
-				font-size: inherit;
+				width: 50px;
-				font-weight: inherit;
+			}
+			li[c_libs] li li > a {
+				font-family: monospace;
 			}
 		</style>
 	</head>
 	<body>
 <%		docs_header() %>

Mercurial Hosting > luan

comparison website/src/manual.html.luan @ 1812:f44dcb3fedf7