Mercurial Hosting > luan
annotate website/src/manual.html.luan @ 1813:fa0e73119b7c
docs work
| author | Franklin Schmidt <fschmidt@gmail.com> |
|---|---|
| date | Mon, 10 Jun 2024 23:19:40 -0600 |
| parents | f44dcb3fedf7 |
| children | e62c88b2883b |
| rev | line source |
|---|---|
| 1656 | 1 local Luan = require "luan:Luan.luan" |
| 2 local error = Luan.error | |
| 3 local Io = require "luan:Io.luan" | |
| 4 local Http = require "luan:http/Http.luan" | |
| 5 local Shared = require "site:/lib/Shared.luan" | |
| 6 local head = Shared.head or error() | |
| 7 local docs_header = Shared.docs_header or error() | |
| 8 local show_toc = Shared.show_toc or error() | |
| 9 local show_content = Shared.show_content or error() | |
| 10 | |
| 11 | |
| 12 local content = { | |
| 13 intro = { | |
| 14 title = "Introduction" | |
| 15 content = function() | |
| 16 %> | |
| 17 <p> | |
| 18 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. | |
| 19 </p> | |
| 20 | |
| 21 <p> | |
| 22 Luan is implemented in Java and is tightly coupled with Java. So it makes a great scripting language for Java programmers. | |
| 23 </p> | |
| 24 | |
| 25 <p> | |
| 26 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. | |
| 27 </p> | |
| 28 <% | |
| 29 end | |
| 30 } | |
| 31 basic = { | |
| 32 title = "Basic Concepts" | |
| 33 content = function() | |
| 34 %> | |
| 35 <p> | |
| 36 This section describes the basic concepts of the language. | |
| 37 </p> | |
| 38 <% | |
| 39 end | |
| 40 subs = { | |
| 41 types = { | |
| 42 title = "Values and Types" | |
| 43 content = function() | |
| 44 %> | |
| 45 <p> | |
| 46 Luan is a <em>dynamically typed language</em>. | |
| 47 This means that | |
| 48 variables do not have types; only values do. | |
| 49 There are no type definitions in the language. | |
| 50 All values carry their own type. | |
| 51 </p> | |
| 52 | |
| 53 <p> | |
| 54 All values in Luan are <em>first-class values</em>. | |
| 55 This means that all values can be stored in variables, | |
| 56 passed as arguments to other functions, and returned as results. | |
| 57 </p> | |
| 58 | |
| 59 <p> | |
| 60 There are eight basic types in Luan: | |
| 61 <em>nil</em>, <em>boolean</em>, <em>number</em>, | |
| 62 <em>string</em>, <em>binary</em>, <em>function</em>, <em>java</em>, | |
| 63 and <em>table</em>. | |
| 64 <em>Nil</em> is the type of the value <b>nil</b>, | |
| 65 whose main property is to be different from any other value; | |
| 66 it usually represents the absence of a useful value. | |
| 67 <em>Nil</em> is implemented as the Java value <em>null</em>. | |
| 68 <em>Boolean</em> is the type of the values <b>false</b> and <b>true</b>. | |
| 69 <em>Boolean</em> is implemented as the Java class <em>Boolean</em>. | |
| 70 <em>Number</em> represents both | |
| 71 integer numbers and real (floating-point) numbers. | |
| 72 <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 | |
| 73 the underlying Java implementation. | |
| 74 <em>String</em> is implemented as the Java class <em>String</em>. | |
| 75 <em>Binary</em> is implemented as the Java type <em>byte[]</em>. | |
| 76 </p> | |
| 77 | |
| 78 <p> | |
| 79 Luan can call (and manipulate) functions written in Luan and | |
| 80 functions written in Java (see <a href="#fn_calls">Function Calls</a>). | |
| 81 Both are represented by the type <em>function</em>. | |
| 82 </p> | |
| 83 | |
| 84 <p> | |
| 85 The type <em>java</em> is provided to allow arbitrary Java objects to | |
| 86 be stored in Luan variables. | |
| 87 A <em>java</em> value is a Java object that isn't one of the standard Luan types. | |
| 88 Java values have no predefined operations in Luan, | |
| 89 except assignment and identity test. | |
| 90 Java values are useful when Java access is enabled in Luan. | |
| 91 </p> | |
| 92 | |
| 93 <p> | |
| 94 The type <em>table</em> implements associative arrays, | |
| 95 that is, arrays that can be indexed not only with numbers, | |
| 96 but with any Luan value except <b>nil</b>. | |
| 97 Tables can be <em>heterogeneous</em>; | |
| 98 that is, they can contain values of all types (except <b>nil</b>). | |
| 99 Any key with value <b>nil</b> is not considered part of the table. | |
| 100 Conversely, any key that is not part of a table has | |
| 101 an associated value <b>nil</b>. | |
| 102 </p> | |
| 103 | |
| 104 <p> | |
| 105 Tables are the sole data-structuring mechanism in Luan; | |
| 106 they can be used to represent ordinary arrays, sequences, | |
| 107 symbol tables, sets, records, graphs, trees, etc. | |
| 108 To represent records, Luan uses the field name as an index. | |
| 109 The language supports this representation by | |
| 110 providing <code>a.name</code> as syntactic sugar for <code>a["name"]</code>. | |
| 111 There are several convenient ways to create tables in Luan | |
| 112 (see <a href="#constructors">Table Constructors</a>). | |
| 113 </p> | |
| 114 | |
| 115 <p> | |
| 116 We use the term <em>sequence</em> to denote a table where | |
| 117 the set of all positive numeric keys is equal to {1..<em>n</em>} | |
| 118 for some non-negative integer <em>n</em>, | |
| 119 which is called the length of the sequence (see <a href="#length">The Length Operator</a>). | |
| 120 </p> | |
| 121 | |
| 122 <p> | |
| 123 Like indices, | |
| 124 the values of table fields can be of any type. | |
| 125 In particular, | |
| 126 because functions are first-class values, | |
| 127 table fields can contain functions. | |
| 128 Thus tables can also carry <em>methods</em> (see <a href="#fn_def">Function Definitions</a>). | |
| 129 </p> | |
| 130 | |
| 131 <p> | |
| 132 The indexing of tables follows | |
| 133 the definition of raw equality in the language. | |
| 134 The expressions <code>a[i]</code> and <code>a[j]</code> | |
| 135 denote the same table element | |
| 136 if and only if <code>i</code> and <code>j</code> are raw equal | |
| 137 (that is, equal without metamethods). | |
| 138 In particular, floats with integral values | |
| 139 are equal to their respective integers | |
| 140 (e.g., <code>1.0 == 1</code>). | |
| 141 </p> | |
| 142 | |
| 143 <p> | |
| 144 Luan values are <em>objects</em>: | |
| 145 variables do not actually <em>contain</em> values, | |
| 146 only <em>references</em> to them. | |
| 147 Assignment, parameter passing, and function returns | |
| 148 always manipulate references to values; | |
| 149 these operations do not imply any kind of copy. | |
| 150 </p> | |
| 151 | |
| 152 <p> | |
| 153 The library function <a href="#Luan.type"><code>Luan.type</code></a> returns a string describing the type | |
| 154 of a given value. | |
| 155 </p> | |
| 156 <% | |
| 157 end | |
| 158 } | |
| 159 env = { | |
| 160 title = "Environments" | |
| 161 content = function() | |
| 162 %> | |
| 163 <p> | |
| 164 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>. | |
| 165 </p> | |
| 166 | |
| 167 <p> | |
| 168 As will be discussed in <a href="#vars">Variables</a> and <a href=#assignment">Assignment</a>, | |
| 169 any reference to a free name | |
| 170 (that is, a name not bound to any declaration) <code>var</code> | |
| 171 can be syntactically translated to <code>_ENV.var</code> if <code>_ENV</code> is defined. | |
| 172 </p> | |
| 173 <% | |
| 174 end | |
| 175 } | |
| 176 error = { | |
| 177 title = "Error Handling" | |
| 178 content = function() | |
| 179 %> | |
| 180 <p> | |
| 181 Luan code can explicitly generate an error by calling the | |
| 182 <a href="#Luan.error"><code>error</code></a> function. | |
| 183 If you need to catch errors in Luan, | |
| 184 you can use the <a href="#try">Try Statement</code></a>. | |
| 185 </p> | |
| 186 | |
| 187 <p> | |
| 188 Whenever there is an error, | |
| 189 an <em>error table</em> | |
| 190 is propagated with information about the error. | |
| 191 See <a href="#Luan.new_error"><code>Luan.new_error</code></a>. | |
| 192 </p> | |
| 193 <% | |
| 194 end | |
| 195 } | |
| 196 meta = { | |
| 197 title = "Metatables and Metamethods" | |
| 198 content = function() | |
| 199 %> | |
| 200 <p> | |
| 201 Every table in Luan can have a <em>metatable</em>. | |
| 202 This <em>metatable</em> is an ordinary Luan table | |
| 203 that defines the behavior of the original value | |
| 204 under certain special operations. | |
| 205 You can change several aspects of the behavior | |
| 206 of operations over a value by setting specific fields in its metatable. | |
| 207 For instance, when a table is the operand of an addition, | |
| 208 Luan checks for a function in the field "<code>__add</code>" of the table's metatable. | |
| 209 If it finds one, | |
| 210 Luan calls this function to perform the addition. | |
| 211 </p> | |
| 212 | |
| 213 <p> | |
| 214 The keys in a metatable are derived from the <em>event</em> names; | |
| 215 the corresponding values are called <ii>metamethods</em>. | |
| 216 In the previous example, the event is <code>"add"</code> | |
| 217 and the metamethod is the function that performs the addition. | |
| 218 </p> | |
| 219 | |
| 220 <p> | |
| 221 You can query the metatable of any table | |
| 222 using the <a href="#Luan.get_metatable"><code>get_metatable</code></a> function. | |
| 223 </p> | |
| 224 | |
| 225 <p> | |
| 226 You can replace the metatable of tables | |
| 227 using the <a href="#Luan.set_metatable"><code>set_metatable</code></a> function. | |
| 228 </p> | |
| 229 | |
| 230 <p> | |
| 231 A metatable controls how a table behaves in | |
| 232 arithmetic operations, bitwise operations, | |
| 233 order comparisons, concatenation, length operation, calls, and indexing. | |
| 234 </p> | |
| 235 | |
| 236 <p> | |
| 237 A detailed list of events controlled by metatables is given next. | |
| 238 Each operation is identified by its corresponding event name. | |
| 239 The key for each event is a string with its name prefixed by | |
| 240 two underscores, '<code>__</code>'; | |
| 241 for instance, the key for operation "add" is the | |
| 242 string "<code>__add</code>". | |
| 243 Note that queries for metamethods are always raw; | |
| 244 the access to a metamethod does not invoke other metamethods. | |
| 245 You can emulate how Luan queries a metamethod for an object <code>obj</code> | |
| 246 with the following code: | |
| 247 </p> | |
| 248 | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
249 <code block> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
250 raw_get(get_metatable(obj) or {}, "__" .. event_name) |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
251 </code> |
| 1656 | 252 |
| 253 <p> | |
| 254 Here are the events: | |
| 255 </p> | |
| 256 | |
| 257 <ul> | |
| 258 | |
| 259 <li><p> | |
| 260 <b>"add": </b> | |
| 261 the <code>+</code> operation. | |
| 262 | |
| 263 If any operand for an addition is a table, | |
| 264 Luan will try to call a metamethod. | |
| 265 First, Luan will check the first operand (even if it is valid). | |
| 266 If that operand does not define a metamethod for the "<code>__add</code>" event, | |
| 267 then Luan will check the second operand. | |
| 268 If Luan can find a metamethod, | |
| 269 it calls the metamethod with the two operands as arguments, | |
| 270 and the result of the call | |
| 271 (adjusted to one value) | |
| 272 is the result of the operation. | |
| 273 Otherwise, | |
| 274 it raises an error. | |
| 275 </p></li> | |
| 276 | |
| 277 <li><p> | |
| 278 <b>"sub": </b> | |
| 279 the <code>-</code> operation. | |
| 280 Behavior similar to the "add" operation. | |
| 281 </li> | |
| 282 | |
| 283 <li><p><b>"mul": </b> | |
| 284 the <code>*</code> operation. | |
| 285 Behavior similar to the "add" operation. | |
| 286 </p></li> | |
| 287 | |
| 288 <li><p> | |
| 289 <b>"div": </b> | |
| 290 the <code>/</code> operation. | |
| 291 Behavior similar to the "add" operation. | |
| 292 </p></li> | |
| 293 | |
| 294 <li><p> | |
| 1680 | 295 <b>"idiv": </b> |
| 296 the <code>//</code> operation. | |
| 297 Behavior similar to the "add" operation. | |
| 298 </p></li> | |
| 299 | |
| 300 <li><p> | |
| 1656 | 301 <b>"mod": </b> |
| 302 the <code>%</code> operation. | |
| 303 Behavior similar to the "add" operation. | |
| 304 </p></li> | |
| 305 | |
| 306 <li><p> | |
| 307 <b>"pow": </b> | |
| 308 the <code>^</code> (exponentiation) operation. | |
| 309 Behavior similar to the "add" operation. | |
| 310 </p></li> | |
| 311 | |
| 312 <li><p> | |
| 313 <b>"unm": </b> | |
| 314 the <code>-</code> (unary minus) operation. | |
| 315 Behavior similar to the "add" operation. | |
| 316 </p></li> | |
| 317 | |
| 318 <li><p> | |
| 319 <b>"concat": </b> | |
| 320 the <code>..</code> (concatenation) operation. | |
| 321 Behavior similar to the "add" operation. | |
| 322 </p></li> | |
| 323 | |
| 324 <li><p> | |
| 325 <b>"len": </b> | |
| 326 the <code>#</code> (length) operation. | |
| 327 If there is a metamethod, | |
| 328 Luan calls it with the object as argument, | |
| 329 and the result of the call | |
| 330 (always adjusted to one value) | |
| 331 is the result of the operation. | |
| 332 If there is no metamethod but the object is a table, | |
| 333 then Luan uses the table length operation (see <a href="#length">The Length Operator</a>). | |
| 334 Otherwise, Luan raises an error. | |
| 335 </p></li> | |
| 336 | |
| 337 <li><p> | |
| 338 <b>"eq": </b> | |
| 339 the <code>==</code> (equal) operation. | |
| 340 Behavior similar to the "add" operation, | |
| 341 except that Luan will try a metamethod only when the values | |
| 342 being compared are both tables | |
| 343 and they are not primitively equal. | |
| 344 The result of the call is always converted to a boolean. | |
| 345 </p></li> | |
| 346 | |
| 347 <li><p> | |
| 348 <b>"lt": </b> | |
| 349 the <code><</code> (less than) operation. | |
| 350 Behavior similar to the "add" operation. | |
| 351 The result of the call is always converted to a boolean. | |
| 352 </p></li> | |
| 353 | |
| 354 <li><p> | |
| 355 <b>"le": </b> | |
| 356 the <code><=</code> (less equal) operation. | |
| 357 Unlike other operations, | |
| 358 The less-equal operation can use two different events. | |
| 359 First, Luan looks for the "<code>__le</code>" metamethod in both operands, | |
| 360 like in the "lt" operation. | |
| 361 If it cannot find such a metamethod, | |
| 362 then it will try the "<code>__lt</code>" event, | |
| 363 assuming that <code>a <= b</code> is equivalent to <code>not (b < a)</code>. | |
| 364 As with the other comparison operators, | |
| 365 the result is always a boolean. | |
| 366 </p></li> | |
| 367 | |
| 368 <li> | |
| 369 <p> | |
| 370 <b>"index": </b> | |
| 371 The indexing access <code>table[key]</code>. | |
| 372 This event happens | |
| 373 when <code>key</code> is not present in <code>table</code>. | |
| 374 The metamethod is looked up in <code>table</code>. | |
| 375 </p> | |
| 376 | |
| 377 <p> | |
| 378 Despite the name, | |
| 379 the metamethod for this event can be any type. | |
| 380 If it is a function, | |
| 381 it is called with <code>table</code> and <code>key</code> as arguments. | |
| 382 Otherwise | |
| 383 the final result is the result of indexing this metamethod object with <code>key</code>. | |
| 384 (This indexing is regular, not raw, | |
| 385 and therefore can trigger another metamethod if the metamethod object is a table.) | |
| 386 </p> | |
| 387 </li> | |
| 388 | |
| 389 <li> | |
| 390 <p> | |
| 391 <b>"new_index": </b> | |
| 392 The indexing assignment <code>table[key] = value</code>. | |
| 393 Like the index event, | |
| 394 this event happens when | |
| 395 when <code>key</code> is not present in <code>table</code>. | |
| 396 The metamethod is looked up in <code>table</code>. | |
| 397 </p> | |
| 398 | |
| 399 <p> | |
| 400 Like with indexing, | |
| 401 the metamethod for this event can be either a function or a table. | |
| 402 If it is a function, | |
| 403 it is called with <code>table</code>, <code>key</code>, and <code>value</code> as arguments. | |
| 404 If it is a table, | |
| 405 Luan does an indexing assignment to this table with the same key and value. | |
| 406 (This assignment is regular, not raw, | |
| 407 and therefore can trigger another metamethod.) | |
| 408 </p> | |
| 409 | |
| 410 <p> | |
| 411 Whenever there is a "new_index" metamethod, | |
| 412 Luan does not perform the primitive assignment. | |
| 413 (If necessary, | |
| 414 the metamethod itself can call <a href="#Luan.raw_set"><code>raw_set</code></a> | |
| 415 to do the assignment.) | |
| 416 </p> | |
| 417 </li> | |
| 418 | |
| 419 <li><p> | |
| 420 <b>"gc":</b> | |
| 421 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. | |
| 422 </p></li> | |
| 423 | |
| 424 </ul> | |
| 425 <% | |
| 426 end | |
| 427 } | |
| 428 gc = { | |
| 429 title = "Garbage Collection" | |
| 430 content = function() | |
| 431 %> | |
| 432 <p> | |
| 433 Luan uses Java's garbage collection. | |
| 434 </p> | |
| 435 <% | |
| 436 end | |
| 437 } | |
| 438 } | |
| 439 } | |
| 440 lang = { | |
| 441 title = "The Language" | |
| 442 content = function() | |
| 443 %> | |
| 444 <p> | |
| 445 This section describes the lexis, the syntax, and the semantics of Luan. | |
| 446 In other words, | |
| 447 this section describes | |
| 448 which tokens are valid, | |
| 449 how they can be combined, | |
| 450 and what their combinations mean. | |
| 451 </p> | |
| 452 | |
| 453 <p> | |
| 454 Language constructs will be explained using the usual extended BNF notation, | |
| 455 in which | |
| 456 {<em>a</em>} means 0 or more <em>a</em>'s, and | |
| 457 [<em>a</em>] means an optional <em>a</em>. | |
| 458 Non-terminals are shown like non-terminal, | |
| 459 keywords are shown like <b>kword</b>, | |
| 460 and other terminal symbols are shown like ‘<b>=</b>’. | |
| 461 The complete syntax of Luan can be found in <a href="#9">§9</a> | |
| 462 at the end of this manual. | |
| 463 </p> | |
| 464 <% | |
| 465 end | |
| 466 subs = { | |
| 467 lex = { | |
| 468 title = "Lexical Conventions" | |
| 469 content = function() | |
| 470 %> | |
| 471 <p> | |
| 472 Luan ignores spaces and comments | |
| 473 between lexical elements (tokens), | |
| 474 except as delimiters between names and keywords. | |
| 475 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. | |
| 476 </p> | |
| 477 | |
| 478 <p> | |
| 479 <em>Names</em> | |
| 480 (also called <em>identifiers</em>) | |
| 481 in Luan can be any string of letters, | |
| 482 digits, and underscores, | |
| 483 not beginning with a digit. | |
| 484 Identifiers are used to name variables, table fields, and labels. | |
| 485 </p> | |
| 486 | |
| 487 <p> | |
| 488 The following <em>keywords</em> are reserved | |
| 489 and cannot be used as names: | |
| 490 </p> | |
| 491 | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
492 <p list=keywords> |
| 1656 | 493 <span>and</span> |
| 494 <span>break</span> | |
| 495 <span>catch</span> | |
| 496 <span>continue</span> | |
| 497 <span>do</span> | |
| 498 <span>else</span> | |
| 499 <span>elseif</span> | |
| 500 <span>end_do</span> | |
| 501 <span>end_for</span> | |
| 502 <span>end_function</span> | |
| 503 <span>end_if</span> | |
| 504 <span>end_try</span> | |
| 505 <span>end_while</span> | |
| 506 <span>false</span> | |
| 507 <span>finally</span> | |
| 508 <span>for</span> | |
| 509 <span>function</span> | |
| 510 <span>if</span> | |
| 511 <span>in</span> | |
| 512 <span>local</span> | |
| 513 <span>nil</span> | |
| 514 <span>not</span> | |
| 515 <span>or</span> | |
| 516 <span>repeat</span> | |
| 517 <span>return</span> | |
| 518 <span>then</span> | |
| 519 <span>true</span> | |
| 520 <span>try</span> | |
| 521 <span>until</span> | |
| 522 <span>while</span> | |
| 523 </p> | |
| 524 | |
| 525 <p> | |
| 526 Luan is a case-sensitive language: | |
| 527 <code>and</code> is a reserved word, but <code>And</code> and <code>AND</code> | |
| 528 are two different, valid names. | |
| 529 </p> | |
| 530 | |
| 531 <p> | |
| 532 The following strings denote other tokens: | |
| 533 </p> | |
| 534 | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
535 <p list=tokens> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
536 <span>+</span> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
537 <span>-</span> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
538 <span>*</span> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
539 <span>/</span> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
540 <span>//</span> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
541 <span>%</span> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
542 <span>^</span> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
543 <span>#</span> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
544 <span>&</span> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
545 <span>~</span> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
546 <span>|</span> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
547 <span>==</span> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
548 <span>~=</span> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
549 <span><=</span> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
550 <span>>=</span> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
551 <span><</span> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
552 <span>></span> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
553 <span>=</span> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
554 <span>(</span> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
555 <span>)</span> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
556 <span>{</span> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
557 <span>}</span> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
558 <span>[</span> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
559 <span>]</span> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
560 <span>;</span> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
561 <span>,</span> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
562 <span>.</span> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
563 <span>..</span> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
564 <span>...</span> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
565 <span>%></span> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
566 <span><%</span> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
567 <span><%=</span> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
568 </p> |
| 1656 | 569 |
| 570 <p> | |
| 571 <em>Literal strings</em> | |
| 572 can be delimited by matching single or double quotes, | |
| 573 and can contain the following C-like escape sequences: | |
| 574 '<code>\a</code>' (bell), | |
| 575 '<code>\b</code>' (backspace), | |
| 576 '<code>\f</code>' (form feed), | |
| 577 '<code>\n</code>' (newline), | |
| 578 '<code>\r</code>' (carriage return), | |
| 579 '<code>\t</code>' (horizontal tab), | |
| 580 '<code>\v</code>' (vertical tab), | |
| 581 '<code>\\</code>' (backslash), | |
| 582 '<code>\"</code>' (quotation mark [double quote]), | |
| 583 and '<code>\'</code>' (apostrophe [single quote]). | |
| 584 A backslash followed by a real newline | |
| 585 results in a newline in the string. | |
| 586 The escape sequence '<code>\z</code>' skips the following span | |
| 587 of white-space characters, | |
| 588 including line breaks; | |
| 589 it is particularly useful to break and indent a long literal string | |
| 590 into multiple lines without adding the newlines and spaces | |
| 591 into the string contents. | |
| 592 </p> | |
| 593 | |
| 594 <p> | |
| 595 Luan can specify any character in a literal string by its numerical value. | |
| 596 This can be done | |
| 597 with the escape sequence <code>\x<em>XX</em></code>, | |
| 598 where <em>XX</em> is a sequence of exactly two hexadecimal digits, | |
| 599 or with the escape sequence <code>\u<em>XXXX</em></code>, | |
| 600 where <em>XXXX</em> is a sequence of exactly four hexadecimal digits, | |
| 601 or with the escape sequence <code>\<em>ddd</em></code>, | |
| 602 where <em>ddd</em> is a sequence of up to three decimal digits. | |
| 603 (Note that if a decimal escape sequence is to be followed by a digit, | |
| 604 it must be expressed using exactly three digits.) | |
| 605 </p> | |
| 606 | |
| 607 <p> | |
| 608 Literal strings can also be defined using a long format | |
| 609 enclosed by <em>long brackets</em>. | |
| 610 We define an <em>opening long bracket of level <em>n</em></em> as an opening | |
| 611 square bracket followed by <em>n</em> equal signs followed by another | |
| 612 opening square bracket. | |
| 613 So, an opening long bracket of level 0 is written as <code>[[</code>, | |
| 614 an opening long bracket of level 1 is written as <code>[=[</code>, | |
| 615 and so on. | |
| 616 A <em>closing long bracket</em> is defined similarly; | |
| 617 for instance, | |
| 618 a closing long bracket of level 4 is written as <code>]====]</code>. | |
| 619 A <em>long literal</em> starts with an opening long bracket of any level and | |
| 620 ends at the first closing long bracket of the same level. | |
| 621 It can contain any text except a closing bracket of the same level. | |
| 622 Literals in this bracketed form can run for several lines, | |
| 623 do not interpret any escape sequences, | |
| 624 and ignore long brackets of any other level. | |
| 625 Any kind of end-of-line sequence | |
| 626 (carriage return, newline, carriage return followed by newline, | |
| 627 or newline followed by carriage return) | |
| 628 is converted to a simple newline. | |
| 629 </p> | |
| 630 | |
| 631 <p> | |
| 632 Any character in a literal string not | |
| 633 explicitly affected by the previous rules represents itself. | |
| 634 However, Luan opens files for parsing in text mode, | |
| 635 and the system file functions may have problems with | |
| 636 some control characters. | |
| 637 So, it is safer to represent | |
| 638 non-text data as a quoted literal with | |
| 639 explicit escape sequences for non-text characters. | |
| 640 </p> | |
| 641 | |
| 642 <p> | |
| 643 For convenience, | |
| 644 when the opening long bracket is immediately followed by a newline, | |
| 645 the newline is not included in the string. | |
| 646 As an example | |
| 647 the five literal strings below denote the same string: | |
| 648 </p> | |
| 649 | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
650 <code block> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
651 a = 'alo\n123"' |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
652 a = "alo\n123\"" |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
653 a = '\97lo\10\04923"' |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
654 a = [[alo |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
655 123"]] |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
656 a = [==[ |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
657 alo |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
658 123"]==] |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
659 </code> |
| 1656 | 660 |
| 661 <p> | |
| 662 A <em>numerical constant</em> (or <em>numeral</em>) | |
| 663 can be written with an optional fractional part | |
| 664 and an optional decimal exponent, | |
| 665 marked by a letter '<code>e</code>' or '<code>E</code>'. | |
| 666 Luan also accepts hexadecimal constants, | |
| 667 which start with <code>0x</code> or <code>0X</code>. | |
| 668 Hexadecimal constants also accept an optional fractional part | |
| 669 plus an optional binary exponent, | |
| 670 marked by a letter '<code>p</code>' or '<code>P</code>'. | |
| 671 A numeric constant with a fractional dot or an exponent | |
| 672 denotes a float; | |
| 673 otherwise it denotes an integer. | |
| 674 Examples of valid integer constants are | |
| 675 </p> | |
| 676 | |
| 677 <pre> | |
| 678 3 345 0xff 0xBEBADA | |
| 679 </pre> | |
| 680 | |
| 681 <p> | |
| 682 Examples of valid float constants are | |
| 683 </p> | |
| 684 | |
| 685 <pre> | |
| 686 3.0 3.1416 314.16e-2 0.31416E1 34e1 | |
| 687 0x0.1E 0xA23p-4 0X1.921FB54442D18P+1 | |
| 688 </pre> | |
| 689 | |
| 690 <p> | |
| 691 A <em>comment</em> starts with a double hyphen (<code>--</code>) | |
| 692 anywhere outside a string. | |
| 693 If the text immediately after <code>--</code> is not an opening long bracket, | |
| 694 the comment is a <em>short comment</em>, | |
| 695 which runs until the end of the line. | |
| 696 Otherwise, it is a <em>long comment</em>, | |
| 697 which runs until the corresponding closing long bracket. | |
| 698 Long comments are frequently used to disable code temporarily. | |
| 699 </p> | |
| 700 <% | |
| 701 end | |
| 702 } | |
| 703 vars = { | |
| 704 title = "Variables" | |
| 705 content = function() | |
| 706 %> | |
| 707 <p> | |
| 708 Variables are places that store values. | |
| 709 There are three kinds of variables in Luan: | |
| 710 global variables, local variables, and table fields. | |
| 711 </p> | |
| 712 | |
| 713 <p> | |
| 714 A single name can denote a global variable or a local variable | |
| 715 (or a function's formal parameter, | |
| 716 which is a particular kind of local variable): | |
| 717 </p> | |
| 718 | |
| 719 <pre> | |
| 720 var ::= Name | |
| 721 </pre> | |
| 722 | |
| 723 <p> | |
| 724 Name denotes identifiers, as defined in <a href="#lex">Lexical Conventions</a>. | |
| 725 </p> | |
| 726 | |
| 727 <p> | |
| 728 Local variables are <em>lexically scoped</em>: | |
| 729 local variables can be freely accessed by functions | |
| 730 defined inside their scope (see <a href="#visibility">Visibility Rules</a>). | |
| 731 </p> | |
| 732 | |
| 733 <p> | |
| 734 Before the first assignment to a variable, its value is <b>nil</b>. | |
| 735 </p> | |
| 736 | |
| 737 <p> | |
| 738 Square brackets are used to index a table: | |
| 739 </p> | |
| 740 | |
| 741 <pre> | |
| 742 var ::= prefixexp ‘<b>[</b>’ exp ‘<b>]</b>’ | |
| 743 </pre> | |
| 744 | |
| 745 <p> | |
| 746 The meaning of accesses to table fields can be changed via metatables. | |
| 747 An access to an indexed variable <code>t[i]</code> is equivalent to | |
| 748 a call <code>gettable_event(t,i)</code>. | |
| 749 (See <a href="#meta">Metatables and Metamethods</a> for a complete description of the | |
| 750 <code>gettable_event</code> function. | |
| 751 This function is not defined or callable in Luan. | |
| 752 We use it here only for explanatory purposes.) | |
| 753 </p> | |
| 754 | |
| 755 <p> | |
| 756 The syntax <code>var.Name</code> is just syntactic sugar for | |
| 757 <code>var["Name"]</code>: | |
| 758 </p> | |
| 759 | |
| 760 <pre> | |
| 761 var ::= prefixexp ‘<b>.</b>’ Name | |
| 762 </pre> | |
| 763 | |
| 764 <p> | |
| 765 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> | |
| 766 is equivalent to <code>_ENV.x</code>. | |
| 767 Due to the way that chunks are compiled, | |
| 768 <code>_ENV</code> is never a global name (see <a href="#env">Environments</a>). | |
| 769 </p> | |
| 770 <% | |
| 771 end | |
| 772 } | |
| 773 stmt = { | |
| 774 title = "Statements" | |
| 775 content = function() | |
| 776 %> | |
| 777 <p> | |
| 778 Luan supports an almost conventional set of statements, | |
| 779 similar to those in Pascal or C. | |
| 780 This set includes | |
| 781 assignments, control structures, function calls, | |
| 782 and variable declarations. | |
| 783 </p> | |
| 784 <% | |
| 785 end | |
| 786 subs = { | |
| 787 blocks = { | |
| 788 title = "Blocks" | |
| 789 content = function() | |
| 790 %> | |
| 791 <p> | |
| 792 A block is a list of statements, | |
| 793 which are executed sequentially: | |
| 794 </p> | |
| 795 | |
| 796 <pre> | |
| 797 block ::= {stat} | |
| 798 </pre> | |
| 799 | |
| 800 <p> | |
| 801 Luan has <em>empty statements</em> | |
| 802 that allow you to separate statements with semicolons, | |
| 803 start a block with a semicolon | |
| 804 or write two semicolons in sequence: | |
| 805 </p> | |
| 806 | |
| 807 <pre> | |
| 808 stat ::= ‘<b>;</b>’ | |
| 809 </pre> | |
| 810 | |
| 811 <p> | |
| 812 A block can be explicitly delimited to produce a single statement: | |
| 813 </p> | |
| 814 | |
| 815 <pre> | |
| 816 stat ::= <b>do</b> block end_do | |
| 817 end_do ::= <b>end_do</b> | <b>end</b> | |
| 818 </pre> | |
| 819 | |
| 820 <p> | |
| 821 Explicit blocks are useful | |
| 822 to control the scope of variable declarations. | |
| 823 Explicit blocks are also sometimes used to | |
| 824 add a <b>return</b> statement in the middle | |
| 825 of another block (see <a href="#control">Control Structures</a>). | |
| 826 </p> | |
| 827 <% | |
| 828 end | |
| 829 } | |
| 830 chunks = { | |
| 831 title = "Chunks" | |
| 832 content = function() | |
| 833 %> | |
| 834 <p> | |
| 835 The unit of compilation of Luan is called a <em>chunk</em>. | |
| 836 Syntactically, | |
| 837 a chunk is simply a block: | |
| 838 </p> | |
| 839 | |
| 840 <pre> | |
| 841 chunk ::= block | |
| 842 </pre> | |
| 843 | |
| 844 <p> | |
| 845 Luan handles a chunk as the body of an anonymous function | |
| 846 with a variable number of arguments | |
| 847 (see <a href="#fn_def">Function Definitions</a>). | |
| 848 As such, chunks can define local variables, | |
| 849 receive arguments, and return values. | |
| 850 </p> | |
| 851 | |
| 852 <p> | |
| 853 A chunk can be stored in a file or in a string inside the host program. | |
| 854 To execute a chunk, | |
| 855 Luan first <em>loads</em> it, | |
| 856 compiling the chunk's code, | |
| 857 and then Luan executes the compiled code. | |
| 858 </p> | |
| 859 <% | |
| 860 end | |
| 861 } | |
| 862 assignment = { | |
| 863 title = "Assignment" | |
| 864 content = function() | |
| 865 %> | |
| 866 <p> | |
| 867 Luan allows multiple assignments. | |
| 868 Therefore, the syntax for assignment | |
| 869 defines a list of variables on the left side | |
| 870 and a list of expressions on the right side. | |
| 871 The elements in both lists are separated by commas: | |
| 872 </p> | |
| 873 | |
| 874 <pre> | |
| 875 stat ::= varlist ‘<b>=</b>’ explist | |
| 876 varlist ::= var {‘<b>,</b>’ var} | |
| 877 explist ::= exp {‘<b>,</b>’ exp} | |
| 878 </pre> | |
| 879 | |
| 880 <p> | |
| 881 Expressions are discussed in <a href="#expressions">Expressions</a>. | |
| 882 </p> | |
| 883 | |
| 884 <p> | |
| 885 Before the assignment, | |
| 886 the list of values is <em>adjusted</em> to the length of | |
| 887 the list of variables. | |
| 888 If there are more values than needed, | |
| 889 the excess values are thrown away. | |
| 890 If there are fewer values than needed, | |
| 891 the list is extended with as many <b>nil</b>'s as needed. | |
| 892 If the list of expressions ends with a function call, | |
| 893 then all values returned by that call enter the list of values, | |
| 894 before the adjustment | |
| 895 (except when the call is enclosed in parentheses; see <a href="#expressions">Expressions</a>). | |
| 896 </p> | |
| 897 | |
| 898 <p> | |
| 899 The assignment statement first evaluates all its expressions | |
| 900 and only then the assignments are performed. | |
| 901 Thus the code | |
| 902 </p> | |
| 903 | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
904 <code block> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
905 i = 3 |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
906 i, a[i] = i+1, 20 |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
907 </code> |
| 1656 | 908 |
| 909 <p> | |
| 910 sets <code>a[3]</code> to 20, without affecting <code>a[4]</code> | |
| 911 because the <code>i</code> in <code>a[i]</code> is evaluated (to 3) | |
| 912 before it is assigned 4. | |
| 913 Similarly, the line | |
| 914 </p> | |
| 915 | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
916 <code block> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
917 x, y = y, x |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
918 </code> |
| 1656 | 919 |
| 920 <p> | |
| 921 exchanges the values of <code>x</code> and <code>y</code>, | |
| 922 and | |
| 923 </p> | |
| 924 | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
925 <code block> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
926 x, y, z = y, z, x |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
927 </code> |
| 1656 | 928 |
| 929 <p> | |
| 930 cyclically permutes the values of <code>x</code>, <code>y</code>, and <code>z</code>. | |
| 931 </p> | |
| 932 | |
| 933 <p> | |
| 934 The meaning of assignments to global variables | |
| 935 and table fields can be changed via metatables. | |
| 936 An assignment to an indexed variable <code>t[i] = val</code> is equivalent to | |
| 937 <code>settable_event(t,i,val)</code>. | |
| 938 (See <a href="#meta">Metatables and Metamethods</a> for a complete description of the | |
| 939 <code>settable_event</code> function. | |
| 940 This function is not defined or callable in Luan. | |
| 941 We use it here only for explanatory purposes.) | |
| 942 </p> | |
| 943 | |
| 944 <p> | |
| 945 An assignment to a global name <code>x = val</code> | |
| 946 is equivalent to the assignment | |
| 947 <code>_ENV.x = val</code> (see <a href="#env">Environments</a>). | |
| 948 Global names are only available when <code>_ENV</code> is defined. | |
| 949 </p> | |
| 950 <% | |
| 951 end | |
| 952 } | |
| 1660 | 953 control = { |
| 954 title = "Control Structures" | |
| 955 content = function() | |
| 956 %> | |
| 957 <p> | |
| 958 The control structures | |
| 959 <b>if</b>, <b>while</b>, and <b>repeat</b> have the usual meaning and | |
| 960 familiar syntax: | |
| 961 </p> | |
| 962 | |
| 963 <pre> | |
| 964 stat ::= <b>while</b> exp <b>do</b> block end_while | |
| 965 stat ::= <b>repeat</b> block <b>until</b> exp | |
| 966 stat ::= <b>if</b> exp <b>then</b> block {<b>elseif</b> exp <b>then</b> block} [<b>else</b> block] end_if | |
| 967 end_while ::= <b>end_while</b> | <b>end</b> | |
| 968 end_if ::= <b>end_if</b> | <b>end</b> | |
| 969 </pre> | |
| 970 | |
| 971 <p> | |
| 972 Luan also has a <b>for</b> statement (see <a href="#for">For Statement</a>). | |
| 973 </p> | |
| 974 | |
| 975 <p> | |
| 976 The condition expression of a | |
| 977 control structure must be a boolean. | |
| 978 Any other value type will produce an error. | |
| 979 This helps catch errors and makes code more readable. | |
| 980 </p> | |
| 981 | |
| 982 <p> | |
| 983 In the <b>repeat</b>–<b>until</b> loop, | |
| 984 the inner block does not end at the <b>until</b> keyword, | |
| 985 but only after the condition. | |
| 986 So, the condition can refer to local variables | |
| 987 declared inside the loop block. | |
| 988 </p> | |
| 989 | |
| 990 <p> | |
| 991 The <b>break</b> statement terminates the execution of a | |
| 992 <b>while</b>, <b>repeat</b>, or <b>for</b> loop, | |
| 993 skipping to the next statement after the loop: | |
| 994 </p> | |
| 995 | |
| 996 <pre> | |
| 997 stat ::= <b>break</b> | |
| 998 </pre> | |
| 999 | |
| 1000 <p> | |
| 1001 A <b>break</b> ends the innermost enclosing loop. | |
| 1002 </p> | |
| 1003 | |
| 1004 <p> | |
| 1005 The <b>continue</b> statement jumps to the beginning of a | |
| 1006 <b>while</b>, <b>repeat</b>, or <b>for</b> loop for next iteration, | |
| 1007 skipping the execution of statements inside the body of loop for the current iteration: | |
| 1008 </p> | |
| 1009 | |
| 1010 <pre> | |
| 1011 stat ::= <b>continue</b> | |
| 1012 </pre> | |
| 1013 | |
| 1014 <p> | |
| 1015 The <b>return</b> statement is used to return values | |
| 1016 from a function or a chunk | |
| 1017 (which is an anonymous function). | |
| 1018 Functions can return more than one value, | |
| 1019 so the syntax for the <b>return</b> statement is | |
| 1020 </p> | |
| 1021 | |
| 1022 <pre> | |
| 1023 stat ::= <b>return</b> [explist] [‘<b>;</b>’] | |
| 1024 </pre> | |
| 1025 <% | |
| 1026 end | |
| 1027 } | |
| 1028 ["for"] = { | |
| 1029 title = "For Statement" | |
| 1030 content = function() | |
| 1031 %> | |
| 1032 <p> | |
| 1033 The <b>for</b> statement works over functions, | |
| 1034 called <em>iterators</em>. | |
| 1035 On each iteration, the iterator function is called to produce a new value, | |
| 1036 stopping when this new value is <b>nil</b>. | |
| 1037 The <b>for</b> loop has the following syntax: | |
| 1038 </p> | |
| 1039 | |
| 1040 <pre> | |
| 1041 stat ::= <b>for</b> namelist <b>in</b> exp <b>do</b> block end_for | |
| 1042 namelist ::= Name {‘<b>,</b>’ Name} | |
| 1043 end_for ::= <b>end_for</b> | <b>end</b> | |
| 1044 </pre> | |
| 1045 | |
| 1046 <p> | |
| 1047 A <b>for</b> statement like | |
| 1048 </p> | |
| 1049 | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1050 <code block> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1051 for <em>var_1</em>, ···, <em>var_n</em> in <em>exp</em> do <em>block</em> end |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1052 </code> |
| 1660 | 1053 |
| 1054 <p> | |
| 1055 is equivalent to the code: | |
| 1056 </p> | |
| 1057 | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1058 <code block> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1059 do |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1060 local <em>f</em> = <em>exp</em> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1061 while true do |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1062 local <em>var_1</em>, ···, <em>var_n</em> = <em>f</em>() |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1063 if <em>var_1</em> == nil then break end |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1064 <em>block</em> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1065 end |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1066 end |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1067 </code> |
| 1660 | 1068 |
| 1069 <p> | |
| 1070 Note the following: | |
| 1071 </p> | |
| 1072 | |
| 1073 <ul> | |
| 1074 <li> | |
| 1075 <code><em>exp</em></code> is evaluated only once. | |
| 1076 Its result is an <em>iterator</em> function. | |
| 1077 </li> | |
| 1078 <li> | |
| 1079 <code><em>f</em></code> is an invisible variable. | |
| 1080 The name is here for explanatory purposes only. | |
| 1081 </li> | |
| 1082 <li> | |
| 1083 You can use <b>break</b> to exit a <b>for</b> loop. | |
| 1084 </li> | |
| 1085 <li> | |
| 1086 The loop variables <code><em>var_i</em></code> are local to the loop; | |
| 1087 you cannot use their values after the <b>for</b> ends. | |
| 1088 If you need these values, | |
| 1089 then assign them to other variables before breaking or exiting the loop. | |
| 1090 </li> | |
| 1091 </ul> | |
| 1092 <% | |
| 1093 end | |
| 1094 } | |
| 1095 ["try"] = { | |
| 1096 title = "Try Statement" | |
| 1097 content = function() | |
| 1098 %> | |
| 1099 <p> | |
| 1100 The <b>try</b> statement has the same semantics as in Java. | |
| 1101 </p> | |
| 1102 | |
| 1103 <pre> | |
| 1104 stat ::= <b>try</b> block [<b>catch</b> Name block] [<b>finally</b> block] end_try | |
| 1105 end_try ::= <b>end_try</b> | <b>end</b> | |
| 1106 </pre> | |
| 1107 <% | |
| 1108 end | |
| 1109 } | |
| 1110 fn_stmt = { | |
| 1111 title = "Function Calls as Statements" | |
| 1112 content = function() | |
| 1113 %> | |
| 1114 <p> | |
| 1115 To allow possible side-effects, | |
| 1116 function calls can be executed as statements: | |
| 1117 </p> | |
| 1118 | |
| 1119 <pre> | |
| 1120 stat ::= functioncall | |
| 1121 </pre> | |
| 1122 | |
| 1123 <p> | |
| 1124 In this case, all returned values are thrown away. | |
| 1125 Function calls are explained in <a href="#fn_calls">Function Calls</a>. | |
| 1126 </p> | |
| 1127 <% | |
| 1128 end | |
| 1129 } | |
| 1130 logical_stmt = { | |
| 1131 title = "Logical Statement" | |
| 1132 content = function() | |
| 1133 %> | |
| 1134 <p> | |
| 1135 <a href="#logical_ops">Logical expressions</a> can be statements. | |
| 1136 This is useful in cases like this: | |
| 1137 </p> | |
| 1138 | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1139 <code block> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1140 x==5 or error "x should be 5" |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1141 </code> |
| 1660 | 1142 <% |
| 1143 end | |
| 1144 } | |
| 1145 local_stmt = { | |
| 1146 title = "Local Declarations" | |
| 1147 content = function() | |
| 1148 %> | |
| 1149 <p> | |
| 1150 Local variables can be declared anywhere inside a block. | |
| 1151 The declaration can include an initial assignment: | |
| 1152 </p> | |
| 1153 | |
| 1154 <pre> | |
| 1155 stat ::= <b>local</b> namelist [‘<b>=</b>’ explist] | |
| 1156 </pre> | |
| 1157 | |
| 1158 <p> | |
| 1159 If present, an initial assignment has the same semantics | |
| 1160 of a multiple assignment (see <a href="#assignment">Assignment</a>). | |
| 1161 Otherwise, all variables are initialized with <b>nil</b>. | |
| 1162 </p> | |
| 1163 | |
| 1164 <p> | |
| 1165 A chunk is also a block (see <a href="#chunks">Chunks</a>), | |
| 1166 and so local variables can be declared in a chunk outside any explicit block. | |
| 1167 </p> | |
| 1168 | |
| 1169 <p> | |
| 1170 The visibility rules for local variables are explained in <a href="#visibility">Visibility Rules</a>. | |
| 1171 </p> | |
| 1172 <% | |
| 1173 end | |
| 1174 } | |
| 1175 template_stmt = { | |
| 1176 title = "Template Statements" | |
| 1177 content = function() | |
| 1178 %> | |
| 1179 <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> | |
| 1180 </p> | |
| 1181 | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1182 <code block> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1183 local name = "Bob" |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1184 %> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1185 Hello <%= name %>! |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1186 Bye <%= name %>. |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1187 <% |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1188 </code> |
| 1660 | 1189 |
| 1190 <p> | |
| 1191 is equivalent to the code: | |
| 1192 </p> | |
| 1193 | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1194 <code block> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1195 local name = "Bob" |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1196 require("luan:Io.luan").stdout.write( "Hello ", name , "!\nBye ", name , ".\n" ) |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1197 </code> |
| 1660 | 1198 <% |
| 1199 end | |
| 1200 } | |
| 1201 } | |
| 1202 } | |
| 1203 expressions = { | |
| 1204 title = "Expressions" | |
| 1205 content = function() | |
| 1206 %> | |
| 1207 <p> | |
| 1208 The basic expressions in Luan are the following: | |
| 1209 </p> | |
| 1210 | |
| 1211 <pre> | |
| 1212 exp ::= prefixexp | |
| 1213 exp ::= <b>nil</b> | <b>false</b> | <b>true</b> | |
| 1214 exp ::= Numeral | |
| 1215 exp ::= LiteralString | |
| 1216 exp ::= functiondef | |
| 1217 exp ::= tableconstructor | |
| 1218 exp ::= ‘<b>...</b>’ | |
| 1219 exp ::= exp binop exp | |
| 1220 exp ::= unop exp | |
| 1221 prefixexp ::= var | functioncall | ‘<b>(</b>’ exp ‘<b>)</b>’ | |
| 1222 </pre> | |
| 1223 | |
| 1224 <p> | |
| 1225 Numerals and literal strings are explained in <a href="#lex">Lexical Conventions</a>; | |
| 1226 variables are explained in <a href="#vars">Variables</a>; | |
| 1227 function definitions are explained in <a href="#fn_def">Function Definitions</a>; | |
| 1228 function calls are explained in <a href="#fn_calls">Function Calls</a>; | |
| 1229 table constructors are explained in <a href="#constructors">Table Constructors</a>. | |
| 1230 Vararg expressions, | |
| 1231 denoted by three dots ('<code>...</code>'), can only be used when | |
| 1232 directly inside a vararg function; | |
| 1233 they are explained in <a href="#fn_def">Function Definitions</a>. | |
| 1234 </p> | |
| 1235 | |
| 1236 <p> | |
| 1237 Binary operators comprise arithmetic operators (see <a href="#arithmetic">Arithmetic Operators</a>), | |
| 1238 relational operators (see <a href="#relational">Relational Operators</a>), logical operators (see <a href="#logical_ops">Logical Operators</a>), | |
| 1239 and the concatenation operator (see <a href="#concatenation">Concatenation</a>). | |
| 1240 Unary operators comprise the unary minus (see <a href="#arithmetic">Arithmetic Operators</a>), | |
| 1241 the unary logical <b>not</b> (see <a href="#logical_ops">Logical Operators</a>), | |
| 1242 and the unary <em>length operator</em> (see <a href="#length">The Length Operator</a>). | |
| 1243 </p> | |
| 1244 | |
| 1245 <p> | |
| 1246 Both function calls and vararg expressions can result in multiple values. | |
| 1247 If a function call is used as a statement (see <a href="#fn_stmt">Function Calls as Statements</a>), | |
| 1248 then its return list is adjusted to zero elements, | |
| 1249 thus discarding all returned values. | |
| 1250 If an expression is used as the last (or the only) element | |
| 1251 of a list of expressions, | |
| 1252 then no adjustment is made | |
| 1253 (unless the expression is enclosed in parentheses). | |
| 1254 In all other contexts, | |
| 1255 Luan adjusts the result list to one element, | |
| 1256 either discarding all values except the first one | |
| 1257 or adding a single <b>nil</b> if there are no values. | |
| 1258 </p> | |
| 1259 | |
| 1260 <p> | |
| 1261 Here are some examples: | |
| 1262 </p> | |
| 1263 | |
| 1264 <pre> | |
| 1265 f() -- adjusted to 0 results | |
| 1266 g(f(), x) -- f() is adjusted to 1 result | |
| 1267 g(x, f()) -- g gets x plus all results from f() | |
| 1268 a,b,c = f(), x -- f() is adjusted to 1 result (c gets nil) | |
| 1269 a,b = ... -- a gets the first vararg parameter, b gets | |
| 1270 -- the second (both a and b can get nil if there | |
| 1271 -- is no corresponding vararg parameter) | |
| 1272 | |
| 1273 a,b,c = x, f() -- f() is adjusted to 2 results | |
| 1274 a,b,c = f() -- f() is adjusted to 3 results | |
| 1275 return f() -- returns all results from f() | |
| 1276 return ... -- returns all received vararg parameters | |
| 1277 return x,y,f() -- returns x, y, and all results from f() | |
| 1278 {f()} -- creates a list with all results from f() | |
| 1279 {...} -- creates a list with all vararg parameters | |
| 1280 {f(), nil} -- f() is adjusted to 1 result | |
| 1281 </pre> | |
| 1282 | |
| 1283 <p> | |
| 1284 Any expression enclosed in parentheses always results in only one value. | |
| 1285 Thus, | |
| 1286 <code>(f(x,y,z))</code> is always a single value, | |
| 1287 even if <code>f</code> returns several values. | |
| 1288 (The value of <code>(f(x,y,z))</code> is the first value returned by <code>f</code> | |
| 1289 or <b>nil</b> if <code>f</code> does not return any values.) | |
| 1290 </p> | |
| 1291 <% | |
| 1292 end | |
| 1293 subs = { | |
| 1294 arithmetic = { | |
| 1295 title = "Arithmetic Operators" | |
| 1296 content = function() | |
| 1297 %> | |
| 1298 <p> | |
| 1299 Luan supports the following arithmetic operators: | |
| 1300 </p> | |
| 1301 | |
| 1302 <ul> | |
| 1303 <li><b><code>+</code>: </b>addition</li> | |
| 1304 <li><b><code>-</code>: </b>subtraction</li> | |
| 1305 <li><b><code>*</code>: </b>multiplication</li> | |
| 1680 | 1306 <li><b><code>/</code>: </b>float division</li> |
| 1307 <li><b><code>//</code>: </b>floor division</li> | |
| 1660 | 1308 <li><b><code>%</code>: </b>modulo</li> |
| 1309 <li><b><code>^</code>: </b>exponentiation</li> | |
| 1310 <li><b><code>-</code>: </b>unary minus</li> | |
| 1311 </ul> | |
| 1312 | |
| 1313 <p> | |
| 1314 Addition, subtraction, multiplication, division, and unary minus are the same as these operators in Java. Exponentiation uses Java's <a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Math.html#pow(double,%20double)">Math.pow</a> function. | |
| 1315 </p> | |
| 1316 | |
| 1317 <p> | |
| 1680 | 1318 Floor division (//) is a division that rounds the quotient towards minus infinity, that is, the floor of the division of its operands. |
| 1319 </p> | |
| 1320 | |
| 1321 <p> | |
| 1660 | 1322 Modulo is defined as the remainder of a division |
| 1323 that rounds the quotient towards minus infinite (floor division). | |
| 1324 (The Java modulo operator is not used.) | |
| 1325 </p> | |
| 1326 <% | |
| 1327 end | |
| 1328 } | |
| 1329 conversions = { | |
| 1330 title = "Coercions and Conversions" | |
| 1331 content = function() | |
| 1332 %> | |
| 1333 <p> | |
| 1334 Luan generally avoids automatic conversions. | |
| 1335 String concatenation automatically converts all of its arguments to strings. | |
| 1336 </p> | |
| 1337 | |
| 1338 <p> | |
| 1339 Luan provides library functions for explicit type conversions. | |
| 1340 </p> | |
| 1341 <% | |
| 1342 end | |
| 1343 } | |
| 1344 relational = { | |
| 1345 title = "Relational Operators" | |
| 1346 content = function() | |
| 1347 %> | |
| 1348 <p> | |
| 1349 Luan supports the following relational operators: | |
| 1350 </p> | |
| 1351 | |
| 1352 <ul> | |
| 1353 <li><b><code>==</code>: </b>equality</li> | |
| 1354 <li><b><code>~=</code>: </b>inequality</li> | |
| 1355 <li><b><code><</code>: </b>less than</li> | |
| 1356 <li><b><code>></code>: </b>greater than</li> | |
| 1357 <li><b><code><=</code>: </b>less or equal</li> | |
| 1358 <li><b><code>>=</code>: </b>greater or equal</li> | |
| 1359 </ul> | |
| 1360 | |
| 1361 <p> | |
| 1362 These operators always result in <b>false</b> or <b>true</b>. | |
| 1363 </p> | |
| 1364 | |
| 1365 <p> | |
| 1366 Equality (<code>==</code>) first compares the type of its operands. | |
| 1367 If the types are different, then the result is <b>false</b>. | |
| 1368 Otherwise, the values of the operands are compared. | |
| 1369 Strings, numbers, and binary values are compared in the obvious way (by value). | |
| 1370 </p> | |
| 1371 | |
| 1372 <p> | |
| 1373 Tables | |
| 1374 are compared by reference: | |
| 1375 two objects are considered equal only if they are the same object. | |
| 1376 Every time you create a new table, | |
| 1377 it is different from any previously existing table. | |
| 1378 Closures are also compared by reference. | |
| 1379 </p> | |
| 1380 | |
| 1381 <p> | |
| 1382 You can change the way that Luan compares tables | |
| 1383 by using the "eq" metamethod (see <a href="#meta">Metatables and Metamethods</a>). | |
| 1384 </p> | |
| 1385 | |
| 1386 <p> | |
| 1387 Java values 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)"><code>equals</code></a> method. | |
| 1388 </p> | |
| 1389 | |
| 1390 <p> | |
| 1391 Equality comparisons do not convert strings to numbers | |
| 1392 or vice versa. | |
| 1393 Thus, <code>"0"==0</code> evaluates to <b>false</b>, | |
| 1394 and <code>t[0]</code> and <code>t["0"]</code> denote different | |
| 1395 entries in a table. | |
| 1396 </p> | |
| 1397 | |
| 1398 <p> | |
| 1399 The operator <code>~=</code> is exactly the negation of equality (<code>==</code>). | |
| 1400 </p> | |
| 1401 | |
| 1402 <p> | |
| 1403 The order operators work as follows. | |
| 1404 If both arguments are numbers, | |
| 1405 then they are compared following | |
| 1406 the usual rule for binary operations. | |
| 1407 Otherwise, if both arguments are strings, | |
| 1408 then their values are compared according to the current locale. | |
| 1409 Otherwise, Luan tries to call the "lt" or the "le" | |
| 1410 metamethod (see <a href="#meta">Metatables and Metamethods</a>). | |
| 1411 A comparison <code>a > b</code> is translated to <code>b < a</code> | |
| 1412 and <code>a >= b</code> is translated to <code>b <= a</code>. | |
| 1413 </p> | |
| 1414 <% | |
| 1415 end | |
| 1416 } | |
| 1667 | 1417 logical_ops = { |
| 1418 title = "Logical Operators" | |
| 1419 content = function() | |
| 1420 %> | |
| 1421 <p> | |
| 1422 The logical operators in Luan are | |
| 1423 <b>and</b>, <b>or</b>, and <b>not</b>. | |
| 1424 The <b>and</b> and <b>or</b> operators consider both <b>false</b> and <b>nil</b> as false | |
| 1425 and anything else as true. | |
| 1426 Like the control structures (see <a href="#control">Control Structures</a>), | |
| 1427 the <b>not</b> operator requires a boolean value. | |
| 1428 </p> | |
| 1429 | |
| 1430 <p> | |
| 1431 The negation operator <b>not</b> always returns <b>false</b> or <b>true</b>. | |
| 1432 The conjunction operator <b>and</b> returns its first argument | |
| 1433 if this value is <b>false</b> or <b>nil</b>; | |
| 1434 otherwise, <b>and</b> returns its second argument. | |
| 1435 The disjunction operator <b>or</b> returns its first argument | |
| 1436 if this value is different from <b>nil</b> and <b>false</b>; | |
| 1437 otherwise, <b>or</b> returns its second argument. | |
| 1438 Both <b>and</b> and <b>or</b> use short-circuit evaluation; | |
| 1439 that is, | |
| 1440 the second operand is evaluated only if necessary. | |
| 1441 Here are some examples: | |
| 1442 </p> | |
| 1443 | |
| 1444 <pre> | |
| 1445 10 or 20 --> 10 | |
| 1446 10 or error() --> 10 | |
| 1447 nil or "a" --> "a" | |
| 1448 nil and 10 --> nil | |
| 1449 false and error() --> false | |
| 1450 false and nil --> false | |
| 1451 false or nil --> nil | |
| 1452 10 and 20 --> 20 | |
| 1453 </pre> | |
| 1454 | |
| 1455 <p> | |
| 1456 (In this manual, | |
| 1457 <code>--></code> indicates the result of the preceding expression.) | |
| 1458 </p> | |
| 1459 <% | |
| 1460 end | |
| 1461 } | |
| 1462 concatenation = { | |
| 1463 title = "Concatenation" | |
| 1464 content = function() | |
| 1465 %> | |
| 1466 <p> | |
| 1467 The string concatenation operator in Luan is | |
| 1468 denoted by two dots ('<code>..</code>'). | |
| 1469 All operands are converted to strings. | |
| 1470 </p> | |
| 1471 <% | |
| 1472 end | |
| 1473 } | |
| 1474 length = { | |
| 1475 title = "The Length Operator" | |
| 1476 content = function() | |
| 1477 %> | |
| 1478 <p> | |
| 1479 The length operator is denoted by the unary prefix operator <code>#</code>. | |
| 1480 The length of a string is its number of characters. | |
| 1481 The length of a binary is its number of bytes. | |
| 1482 </p> | |
| 1483 | |
| 1484 <p> | |
| 1485 A program can modify the behavior of the length operator for | |
| 1486 any table through the <code>__len</code> metamethod (see <a href="#meta">Metatables and Metamethods</a>). | |
| 1487 </p> | |
| 1488 | |
| 1489 <p> | |
| 1490 Unless a <code>__len</code> metamethod is given, | |
| 1491 the length of a table <code>t</code> is defined | |
| 1492 as the number of elements in <em>sequence</em>, | |
| 1493 that is, | |
| 1494 the size of the set of its positive numeric keys is equal to <em>{1..n}</em> | |
| 1495 for some non-negative integer <em>n</em>. | |
| 1496 In that case, <em>n</em> is its length. | |
| 1497 Note that a table like | |
| 1498 </p> | |
| 1499 | |
| 1500 <pre> | |
| 1501 {10, 20, nil, 40} | |
| 1502 </pre> | |
| 1503 | |
| 1504 <p> | |
| 1505 has a length of <code>2</code>, because that is the last key in sequence. | |
| 1506 </p> | |
| 1507 <% | |
| 1508 end | |
| 1509 } | |
| 1510 precedence = { | |
| 1511 title = "Precedence" | |
| 1512 content = function() | |
| 1513 %> | |
| 1514 <p> | |
| 1515 Operator precedence in Luan follows the table below, | |
| 1516 from lower to higher priority: | |
| 1517 </p> | |
| 1518 | |
| 1519 <pre> | |
| 1520 or | |
| 1521 and | |
| 1522 < > <= >= ~= == | |
| 1523 .. | |
| 1524 + - | |
| 1525 * / % | |
| 1526 unary operators (not # -) | |
| 1527 ^ | |
| 1528 </pre> | |
| 1529 | |
| 1530 <p> | |
| 1531 As usual, | |
| 1532 you can use parentheses to change the precedences of an expression. | |
| 1533 The concatenation ('<code>..</code>') and exponentiation ('<code>^</code>') | |
| 1534 operators are right associative. | |
| 1535 All other binary operators are left associative. | |
| 1536 </p> | |
| 1537 <% | |
| 1538 end | |
| 1539 } | |
| 1540 constructors = { | |
| 1541 title = "Table Constructors" | |
| 1542 content = function() | |
| 1543 %> | |
| 1544 <p> | |
| 1545 Table constructors are expressions that create tables. | |
| 1546 Every time a constructor is evaluated, a new table is created. | |
| 1547 A constructor can be used to create an empty table | |
| 1548 or to create a table and initialize some of its fields. | |
| 1549 The general syntax for constructors is | |
| 1550 </p> | |
| 1551 | |
| 1552 <pre> | |
| 1553 tableconstructor ::= ‘<b>{</b>’ fieldlist ‘<b>}</b>’ | |
| 1554 fieldlist ::= [field] {fieldsep [field]} | |
| 1555 field ::= ‘<b>[</b>’ exp ‘<b>]</b>’ ‘<b>=</b>’ exp | Name ‘<b>=</b>’ exp | exp | |
| 1556 fieldsep ::= ‘<b>,</b>’ | ‘<b>;</b>’ | <b>end_of_line</b> | |
| 1557 </pre> | |
| 1558 | |
| 1559 <p> | |
| 1560 Each field of the form <code>[exp1] = exp2</code> adds to the new table an entry | |
| 1561 with key <code>exp1</code> and value <code>exp2</code>. | |
| 1562 A field of the form <code>name = exp</code> is equivalent to | |
| 1563 <code>["name"] = exp</code>. | |
| 1564 Finally, fields of the form <code>exp</code> are equivalent to | |
| 1565 <code>[i] = exp</code>, where <code>i</code> are consecutive integers | |
| 1566 starting with 1. | |
| 1567 Fields in the other formats do not affect this counting. | |
| 1568 For example, | |
| 1569 </p> | |
| 1570 | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1571 <code block> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1572 a = { [f(1)] = g; "x", "y"; x = 1, f(x), [30] = 23; 45 } |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1573 </code> |
| 1667 | 1574 |
| 1575 <p> | |
| 1576 is equivalent to | |
| 1577 </p> | |
| 1578 | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1579 <code block> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1580 do |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1581 local t = {} |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1582 t[f(1)] = g |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1583 t[1] = "x" -- 1st exp |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1584 t[2] = "y" -- 2nd exp |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1585 t.x = 1 -- t["x"] = 1 |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1586 t[3] = f(x) -- 3rd exp |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1587 t[30] = 23 |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1588 t[4] = 45 -- 4th exp |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1589 a = t |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1590 end |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1591 </code> |
| 1667 | 1592 |
| 1593 <p> | |
| 1594 The order of the assignments in a constructor is undefined. | |
| 1595 (This order would be relevant only when there are repeated keys.) | |
| 1596 </p> | |
| 1597 | |
| 1598 <p> | |
| 1599 If the last field in the list has the form <code>exp</code> | |
| 1600 and the expression is a function call or a vararg expression, | |
| 1601 then all values returned by this expression enter the list consecutively | |
| 1602 (see <a href="#fn_calls">Function Calls</a>). | |
| 1603 </p> | |
| 1604 | |
| 1605 <p> | |
| 1606 The field list can have an optional trailing separator, | |
| 1607 as a convenience for machine-generated code. | |
| 1608 </p> | |
| 1609 <% | |
| 1610 end | |
| 1611 } | |
| 1612 fn_calls = { | |
| 1613 title = "Function Calls" | |
| 1614 content = function() | |
| 1615 %> | |
| 1616 <p> | |
| 1617 A function call in Luan has the following syntax: | |
| 1618 </p> | |
| 1619 | |
| 1620 <pre> | |
| 1621 functioncall ::= prefixexp args | |
| 1622 </pre> | |
| 1623 | |
| 1624 <p> | |
| 1625 In a function call, | |
| 1626 first prefixexp and args are evaluated. | |
| 1627 The value of prefixexp must have type <em>function</em>. | |
| 1628 This function is called | |
| 1629 with the given arguments. | |
| 1630 </p> | |
| 1631 | |
| 1632 <p> | |
| 1633 Arguments have the following syntax: | |
| 1634 </p> | |
| 1635 | |
| 1636 <pre> | |
| 1637 args ::= ‘<b>(</b>’ [explist] ‘<b>)</b>’ | |
| 1638 args ::= tableconstructor | |
| 1639 args ::= LiteralString | |
| 1640 </pre> | |
| 1641 | |
| 1642 <p> | |
| 1643 All argument expressions are evaluated before the call. | |
| 1644 A call of the form <code>f{<em>fields</em>}</code> is | |
| 1645 syntactic sugar for <code>f({<em>fields</em>})</code>; | |
| 1646 that is, the argument list is a single new table. | |
| 1647 A call of the form <code>f'<em>string</em>'</code> | |
| 1648 (or <code>f"<em>string</em>"</code> or <code>f[[<em>string</em>]]</code>) | |
| 1649 is syntactic sugar for <code>f('<em>string</em>')</code>; | |
| 1650 that is, the argument list is a single literal string. | |
| 1651 </p> | |
| 1652 <% | |
| 1653 end | |
| 1654 } | |
| 1655 fn_def = { | |
| 1656 title = "Function Definitions" | |
| 1657 content = function() | |
| 1658 %> | |
| 1659 <p> | |
| 1660 The syntax for function definition is | |
| 1661 </p> | |
| 1662 | |
| 1663 <pre> | |
| 1664 functiondef ::= <b>function</b> funcbody | |
| 1665 funcbody ::= ‘<b>(</b>’ [parlist] ‘<b>)</b>’ block end_function | |
| 1666 end_function ::= <b>end_function</b> | <b>end</b> | |
| 1667 </pre> | |
| 1668 | |
| 1669 <p> | |
| 1670 The following syntactic sugar simplifies function definitions: | |
| 1671 </p> | |
| 1672 | |
| 1673 <pre> | |
| 1674 stat ::= <b>function</b> funcname funcbody | |
| 1675 stat ::= <b>local</b> <b>function</b> Name funcbody | |
| 1676 funcname ::= Name {‘<b>.</b>’ Name} [‘<b>:</b>’ Name] | |
| 1677 </pre> | |
| 1678 | |
| 1679 <p> | |
| 1680 The statement | |
| 1681 </p> | |
| 1682 | |
| 1683 <pre> | |
| 1684 function f () <em>body</em> end | |
| 1685 </pre> | |
| 1686 | |
| 1687 <p> | |
| 1688 translates to | |
| 1689 </p> | |
| 1690 | |
| 1691 <pre> | |
| 1692 f = function () <em>body</em> end | |
| 1693 </pre> | |
| 1694 | |
| 1695 <p> | |
| 1696 The statement | |
| 1697 <p> | |
| 1698 | |
| 1699 <pre> | |
| 1700 function t.a.b.c.f () <em>body</em> end | |
| 1701 </pre> | |
| 1702 | |
| 1703 <p> | |
| 1704 translates to | |
| 1705 </p> | |
| 1706 | |
| 1707 <pre> | |
| 1708 t.a.b.c.f = function () <em>body</em> end | |
| 1709 </pre> | |
| 1710 | |
| 1711 <p> | |
| 1712 The statement | |
| 1713 </p> | |
| 1714 | |
| 1715 <pre> | |
| 1716 local function f () <em>body</em> end | |
| 1717 </pre> | |
| 1718 | |
| 1719 <p> | |
| 1720 translates to | |
| 1721 </p> | |
| 1722 | |
| 1723 <pre> | |
| 1724 local f; f = function () <em>body</em> end | |
| 1725 </pre> | |
| 1726 | |
| 1727 <p> | |
| 1728 not to | |
| 1729 </p> | |
| 1730 | |
| 1731 <pre> | |
| 1732 local f = function () <em>body</em> end | |
| 1733 </pre> | |
| 1734 | |
| 1735 <p> | |
| 1736 (This only makes a difference when the body of the function | |
| 1737 contains references to <code>f</code>.) | |
| 1738 </p> | |
| 1739 | |
| 1740 <p> | |
| 1741 A function definition is an executable expression, | |
| 1742 whose value has type <em>function</em>. | |
| 1743 When Luan precompiles a chunk, | |
| 1744 all its function bodies are precompiled too. | |
| 1745 Then, whenever Luan executes the function definition, | |
| 1746 the function is <em>instantiated</em> (or <em>closed</em>). | |
| 1747 This function instance (or <em>closure</em>) | |
| 1748 is the final value of the expression. | |
| 1749 </p> | |
| 1750 | |
| 1751 <p> | |
| 1752 Parameters act as local variables that are | |
| 1753 initialized with the argument values: | |
| 1754 </p> | |
| 1755 | |
| 1756 <pre> | |
| 1757 parlist ::= namelist [‘<b>,</b>’ ‘<b>...</b>’] | ‘<b>...</b>’ | |
| 1758 </pre> | |
| 1759 | |
| 1760 <p> | |
| 1761 When a function is called, | |
| 1762 the list of arguments is adjusted to | |
| 1763 the length of the list of parameters if the list is too short, | |
| 1764 unless the function is a <em>vararg function</em>, | |
| 1765 which is indicated by three dots ('<code>...</code>') | |
| 1766 at the end of its parameter list. | |
| 1767 A vararg function does not adjust its argument list; | |
| 1768 instead, it collects all extra arguments and supplies them | |
| 1769 to the function through a <em>vararg expression</em>, | |
| 1770 which is also written as three dots. | |
| 1771 The value of this expression is a list of all actual extra arguments, | |
| 1772 similar to a function with multiple results. | |
| 1773 If a vararg expression is used inside another expression | |
| 1774 or in the middle of a list of expressions, | |
| 1775 then its return list is adjusted to one element. | |
| 1776 If the expression is used as the last element of a list of expressions, | |
| 1777 then no adjustment is made | |
| 1778 (unless that last expression is enclosed in parentheses). | |
| 1779 </p> | |
| 1780 | |
| 1781 <p> | |
| 1782 As an example, consider the following definitions: | |
| 1783 </p> | |
| 1784 <pre> | |
| 1785 function f(a, b) end | |
| 1786 function g(a, b, ...) end | |
| 1787 function r() return 1,2,3 end | |
| 1788 </pre> | |
| 1789 | |
| 1790 <p> | |
| 1791 Then, we have the following mapping from arguments to parameters and | |
| 1792 to the vararg expression: | |
| 1793 </p> | |
| 1794 <pre> | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1795 CALL PARAMETERS |
| 1667 | 1796 |
| 1797 f(3) a=3, b=nil | |
| 1798 f(3, 4) a=3, b=4 | |
| 1799 f(3, 4, 5) runtime error | |
| 1800 f(r(), 10) runtime error | |
| 1801 f(r()) runtime error | |
| 1802 | |
| 1803 g(3) a=3, b=nil, ... --> (nothing) | |
| 1804 g(3, 4) a=3, b=4, ... --> (nothing) | |
| 1805 g(3, 4, 5, 8) a=3, b=4, ... --> 5 8 | |
| 1806 g(5, r()) a=5, b=1, ... --> 2 3 | |
| 1807 </pre> | |
| 1808 | |
| 1809 <p> | |
| 1810 Results are returned using the <b>return</b> statement (see <a href="#control">Control Structures</a>). | |
| 1811 If control reaches the end of a function | |
| 1812 without encountering a <b>return</b> statement, | |
| 1813 then the function returns with no results. | |
| 1814 </p> | |
| 1815 <% | |
| 1816 end | |
| 1817 } | |
| 1797 | 1818 backticks = { |
| 1819 title = "Backticks" | |
| 1820 content = function() | |
| 1821 %> | |
| 1822 <p> | |
| 1823 A block between backticks is run and then whatever was sent to standard output is returned as a string. Examples: | |
| 1824 </p> | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1825 <code block> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1826 local s = `%>1 + 1 = <%=1+1%><%` |
| 1797 | 1827 |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1828 local s = ` fn(whatever) ` |
| 1797 | 1829 |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1830 local s = `%> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1831 ... |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1832 <%` |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1833 </code> |
| 1797 | 1834 <p> |
| 1835 Backticks complement <a href="#template_stmt">template statements</a>. | |
| 1836 </p> | |
| 1837 <% | |
| 1838 end | |
| 1839 } | |
| 1667 | 1840 } |
| 1841 } | |
| 1842 visibility = { | |
| 1843 title = "Visibility Rules" | |
| 1844 content = function() | |
| 1845 %> | |
| 1846 <p> | |
| 1847 Luan is a lexically scoped language. | |
| 1848 The scope of a local variable begins at the first statement after | |
| 1849 its declaration and lasts until the last non-void statement | |
| 1850 of the innermost block that includes the declaration. | |
| 1851 Consider the following example: | |
| 1852 </p> | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1853 <code block> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1854 local x = 10 -- global to module |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1855 do -- new block |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1856 local x = x -- new 'x', with value 10 |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1857 print(x) --> 10 |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1858 x = x+1 |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1859 do -- another block |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1860 local x = x+1 -- another 'x' |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1861 print(x) --> 12 |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1862 end |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1863 print(x) --> 11 |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1864 end |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1865 print(x) --> 10 (the global one) |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1866 </code> |
| 1667 | 1867 |
| 1868 <p> | |
| 1869 Notice that, in a declaration like <code>local x = x</code>, | |
| 1870 the new <code>x</code> being declared is not in scope yet, | |
| 1871 and so the second <code>x</code> refers to the outside variable. | |
| 1872 </p> | |
| 1873 | |
| 1874 <p> | |
| 1875 Because of the lexical scoping rules, | |
| 1876 local variables can be freely accessed by functions | |
| 1877 defined inside their scope. | |
| 1878 A local variable used by an inner function is called | |
| 1879 an <em>upvalue</em>, or <em>external local variable</em>, | |
| 1880 inside the inner function. | |
| 1881 </p> | |
| 1882 | |
| 1883 <p> | |
| 1884 Notice that each execution of a <b>local</b> statement | |
| 1885 defines new local variables. | |
| 1886 Consider the following example: | |
| 1887 </p> | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1888 |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1889 <code block> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1890 local a = {} |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1891 local x = 20 |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1892 for i=1,10 do |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1893 local y = 0 |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1894 a[i] = function () y=y+1; return x+y end |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1895 end |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1896 </code> |
| 1667 | 1897 |
| 1898 <p> | |
| 1899 The loop creates ten closures | |
| 1900 (that is, ten instances of the anonymous function). | |
| 1901 Each of these closures uses a different <code>y</code> variable, | |
| 1902 while all of them share the same <code>x</code>. | |
| 1903 </p> | |
| 1904 <% | |
| 1905 end | |
| 1906 } | |
| 1907 } | |
| 1908 } | |
| 1909 libs = { | |
| 1910 title = "Standard Libraries" | |
| 1911 content = function() | |
| 1912 %> | |
| 1913 <p> | |
| 1914 The standard Luan libraries provide useful functions | |
| 1915 that are implemented both in Java and in Luan itself. | |
| 1916 How each function is implemented shouldn't matter to the user. | |
| 1917 Some of these functions provide essential services to the language | |
| 1918 (e.g., <a href="#Luan.type"><code>type</code></a> and <a href="#Luan.get_metatable"><code>get_metatable</code></a>); | |
| 1919 others provide access to "outside" services (e.g., I/O). | |
| 1920 </p> | |
| 1921 <% | |
| 1922 end | |
| 1923 subs = { | |
| 1924 default_lib = { | |
| 1925 title = "Default Environment" | |
| 1926 content = function() | |
| 1927 %> | |
| 1928 <p> | |
| 1929 This is provided by default as a local variable for any Luan code as described in <a href="#env">Environments</a>. | |
| 1930 </p> | |
| 1931 <% | |
| 1932 end | |
| 1933 subs = { | |
| 1934 require = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1935 title = "require (mod_uri)" |
| 1667 | 1936 content = function() |
| 1937 %> | |
| 1938 <p> | |
| 1939 Example use: | |
| 1940 </p> | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1941 <code block> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1942 local Table = require "luan:Table.luan" |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1943 </code> |
| 1667 | 1944 |
| 1945 <p> | |
| 1946 Could be defined as: | |
| 1947 </p> | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1948 <code block> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1949 local function require(mod_name) |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1950 return <a href="#Package.load">Package.load</a>(mod_name) or <a href="#Luan.error">Luan.error</a>("module '"..mod_name.."' not found") |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1951 end |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1952 </code> |
| 1667 | 1953 |
| 1954 <p> | |
| 1955 A special case is: | |
| 1956 </p> | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1957 <code block> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1958 require "java" |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1959 </code> |
| 1667 | 1960 |
| 1961 <p> | |
| 1962 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. | |
| 1963 </p> | |
| 1964 <% | |
| 1965 end | |
| 1966 } | |
| 1967 } | |
| 1968 } | |
| 1969 luan_lib = { | |
| 1970 title = "Basic Functions" | |
| 1971 content = function() | |
| 1972 %> | |
| 1973 <p> | |
| 1974 Include this library by: | |
| 1975 </p> | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1976 |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1977 <code block> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1978 local Luan = require "luan:Luan.luan" |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
1979 </code> |
| 1667 | 1980 |
| 1981 <p> | |
| 1982 The basic library provides basic functions to Luan that don't depend on other libaries. | |
| 1983 </p> | |
| 1984 <% | |
| 1985 end | |
| 1986 subs = { | |
| 1813 | 1987 ["Luan.arg"] = { |
| 1988 title = "Luan.arg" | |
| 1989 content = function() | |
| 1990 %> | |
| 1991 <p>If Luan was run from the command line then this is a list of the command line arguments. For example if one runs Luan like this:</p> | |
| 1992 | |
| 1993 <code block> | |
| 1994 luan t.luan a b c | |
| 1995 </code> | |
| 1996 | |
| 1997 <p>Then Luan.arg will contain:</p> | |
| 1998 | |
| 1999 <code block> | |
| 2000 { | |
| 2001 [0] = "t.luan" | |
| 2002 [1] = "a" | |
| 2003 [2] = "b" | |
| 2004 [3] = "c" | |
| 2005 } | |
| 2006 </code> | |
| 2007 | |
| 2008 <p>And of course <code>#Luan.arg</code> will be <code>3</code>.</p> | |
| 2009 <% | |
| 2010 end | |
| 2011 } | |
| 1667 | 2012 ["Luan.do_file"] = { |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2013 title = "Luan.do_file ([uri])" |
| 1667 | 2014 content = function() |
| 2015 %> | |
| 2016 <p> | |
| 2017 Could be defined as: | |
| 2018 </p> | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2019 <code block> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2020 function Luan.do_file(uri) |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2021 local fn = <a href="#Luan.load_file">Luan.load_file</a>(uri) or <a href="#Luan.error">Luan.error</a>("file '"..uri.."' not found") |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2022 return fn() |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2023 end |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2024 </code> |
| 1667 | 2025 <% |
| 2026 end | |
| 2027 } | |
| 2028 ["Luan.error"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2029 title = "Luan.error (message)" |
| 1667 | 2030 content = function() |
| 2031 %> | |
| 2032 <p> | |
| 2033 Throws an error containing the message. | |
| 2034 </p> | |
| 2035 | |
| 2036 <p> | |
| 2037 Could be defined as: | |
| 2038 </p> | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2039 <code block> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2040 function Luan.error(message) |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2041 <a href="#Luan.new_error">Luan.new_error</a>(message).throw() |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2042 end |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2043 </code> |
| 1667 | 2044 <% |
| 2045 end | |
| 2046 } | |
| 2047 ["Luan.eval"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2048 title = "Luan.eval (text [, source_name [, env]])" |
| 1667 | 2049 content = function() |
| 2050 %> | |
| 2051 <p> | |
| 2052 Evaluates <code>text</code> as a Luan expression. | |
| 2053 </p> | |
| 2054 | |
| 2055 <p> | |
| 2056 Could be defined as: | |
| 2057 </p> | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2058 <code block> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2059 function Luan.eval(text,source_name, env) |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2060 return <a href="#Luan.load">Luan.load</a>( "return "..text, source_name or "eval", env )() |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2061 end |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2062 </code> |
| 1667 | 2063 <% |
| 2064 end | |
| 2065 } | |
| 2066 ["Luan.get_metatable"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2067 title = "Luan.get_metatable (table)" |
| 1667 | 2068 content = function() |
| 2069 %> | |
| 2070 <p> | |
| 2071 If <code>table</code> does not have a metatable, returns <b>nil</b>. | |
| 2072 Otherwise, | |
| 2073 if the table's metatable has a <code>"__metatable"</code> field, | |
| 2074 returns the associated value. | |
| 2075 Otherwise, returns the metatable of the given table. | |
| 2076 </p> | |
| 2077 <% | |
| 2078 end | |
| 2079 } | |
| 2080 ["Luan.hash_code"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2081 title = "Luan.hash_code (v)" |
| 1667 | 2082 content = function() |
| 2083 %> | |
| 2084 <p> | |
| 2085 Returns the hash code of <code>v</code>. | |
| 2086 </p> | |
| 2087 <% | |
| 2088 end | |
| 2089 } | |
| 2090 ["Luan.ipairs"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2091 title = "Luan.ipairs (t)" |
| 1667 | 2092 content = function() |
| 2093 %> | |
| 2094 <p> | |
| 2095 Returns an iterator function | |
| 2096 so that the construction | |
| 2097 </p> | |
| 2098 <pre> | |
| 2099 for i,v in ipairs(t) do <em>body</em> end | |
| 2100 </pre> | |
| 2101 | |
| 2102 <p> | |
| 2103 will iterate over the key–value pairs | |
| 2104 (<code>1,t[1]</code>), (<code>2,t[2]</code>), ..., | |
| 2105 up to the first nil value. | |
| 2106 </p> | |
| 2107 | |
| 2108 <p> | |
| 2109 Could be defined as: | |
| 2110 </p> | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2111 <code block> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2112 function Luan.ipairs(t) |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2113 local i = 0 |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2114 return function() |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2115 if i < #t then |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2116 i = i + 1 |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2117 return i, t[i] |
| 1667 | 2118 end |
| 2119 end | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2120 end |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2121 </code> |
| 1667 | 2122 <% |
| 2123 end | |
| 2124 } | |
| 2125 ["Luan.load"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2126 title = "Luan.load (text, [source_name [, env [, persist]]])" |
| 1667 | 2127 content = function() |
| 2128 %> | |
| 2129 <p> | |
| 2130 Loads a chunk. | |
| 2131 </p> | |
| 2132 | |
| 2133 <p> | |
| 2134 The <code>text</code> is compiled. | |
| 2135 If there are no syntactic errors, | |
| 2136 returns the compiled chunk as a function; | |
| 2137 otherwise, throws an error. | |
| 2138 </p> | |
| 2139 | |
| 2140 <p> | |
| 2141 The <code>source_name</code> parameter is a string saying where the text came from. It is used to produce error messages. Defaults to "load". | |
| 2142 </p> | |
| 2143 | |
| 2144 <p> | |
| 2145 If the <code>env</code> parameter is supplied, it becomes the <code>_ENV</code> of the chunk. | |
| 2146 </p> | |
| 2147 | |
| 2148 <p> | |
| 2149 The <code>persist</code> parameter is a boolean which determines if the compiled code is persistently cached to a temporary file. Defaults to <code>false</code>. | |
| 2150 </p> | |
| 2151 <% | |
| 2152 end | |
| 2153 } | |
| 2154 ["Luan.load_file"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2155 title = "Luan.load_file (file_uri)" |
| 1667 | 2156 content = function() |
| 2157 %> | |
| 2158 <p> | |
| 2159 Similar to <a href="#Luan.load"><code>load</code></a>, | |
| 2160 but gets the chunk from file <code>file_uri</code>. | |
| 2161 <code>file_uri</code> can be a string or a uri table. | |
| 2162 </p> | |
| 2163 <% | |
| 2164 end | |
| 2165 } | |
| 2166 ["Luan.new_error"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2167 title = "Luan.new_error (message)" |
| 1667 | 2168 content = function() |
| 2169 %> | |
| 2170 <p> | |
| 2171 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. | |
| 2172 </p> | |
| 2173 | |
| 2174 <p> | |
| 2175 To print the current stack trace, you could do: | |
| 2176 </p> | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2177 <code block> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2178 Io.print( Luan.new_error "stack" ) |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2179 </code> |
| 1667 | 2180 <% |
| 2181 end | |
| 2182 } | |
| 2183 ["Luan.pairs"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2184 title = "Luan.pairs (t)" |
| 1667 | 2185 content = function() |
| 2186 %> | |
| 2187 <p> | |
| 2188 If <code>t</code> has a metamethod <code>__pairs</code>, | |
| 2189 calls it with <code>t</code> as argument and returns the | |
| 2190 result from the call. | |
| 2191 </p> | |
| 2192 | |
| 2193 <p> | |
| 2194 Otherwise, | |
| 2195 returns a function | |
| 2196 so that the construction | |
| 2197 </p> | |
| 2198 <pre> | |
| 2199 for k,v in pairs(t) do <em>body</em> end | |
| 2200 </pre> | |
| 2201 | |
| 2202 <p> | |
| 2203 will iterate over all key–value pairs of table <code>t</code>. | |
| 2204 </p> | |
| 2205 <% | |
| 2206 end | |
| 2207 } | |
| 1813 | 2208 ["Luan.parse"] = { |
| 2209 title = "Luan.parse (s)" | |
| 2210 content = function() | |
| 2211 %> | |
| 2212 <p>This Luan's equivalent to Javascript's JSON.parse(), but for a Luan value. In addition to the usual JSON values, Luan.parse allows long strings and allows specifying numeric types of <i>double</i>, <i>float</i>, <i>integer</i>, and <i>long</i>. For example:</p> | |
| 2213 | |
| 2214 <code block> | |
| 2215 local t = Luan.parse[=[ | |
| 2216 { | |
| 2217 nothing = nil | |
| 2218 t = true | |
| 2219 f = false | |
| 2220 s = "string" | |
| 2221 ls = [[long string]] | |
| 2222 n = 3 | |
| 2223 d = double(3) | |
| 2224 f = float(3) | |
| 2225 i = integer(3) | |
| 2226 l = long(3) | |
| 2227 list = { 1, 2, 3 } | |
| 2228 table = { | |
| 2229 one = 1 | |
| 2230 two = 2 | |
| 2231 three = 3 | |
| 2232 } | |
| 2233 ["ugly-key"] = "something" | |
| 2234 } | |
| 2235 ]=] | |
| 2236 </code> | |
| 2237 <% | |
| 2238 end | |
| 2239 } | |
| 1667 | 2240 ["Luan.range"] = { |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2241 title = "Luan.range (start, stop [, step])" |
| 1667 | 2242 content = function() |
| 2243 %> | |
| 2244 <p> | |
| 2245 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. | |
| 2246 </p> | |
| 2247 | |
| 2248 <p> | |
| 2249 Example use: | |
| 2250 </p> | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2251 <code block> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2252 for i in range(1,10) do |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2253 Io.print("count up:",i) |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2254 end |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2255 for i in range(10,0,-1) do |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2256 Io.print("count down:",i) |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2257 end |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2258 </code> |
| 1667 | 2259 |
| 2260 <p> | |
| 2261 Could be defined as: | |
| 2262 </p> | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2263 <code block> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2264 function Luan.range(start, stop, step) |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2265 step = step or 1 |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2266 step == 0 and <a href="#Luan.error">Luan.error</a> "bad argument #3 (step may not be zero)" |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2267 local i = start |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2268 return function() |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2269 if step > 0 and i <= stop or step < 0 and i >= stop then |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2270 local rtn = i |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2271 i = i + step |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2272 return rtn |
| 1667 | 2273 end |
| 2274 end | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2275 end |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2276 </code> |
| 1667 | 2277 <% |
| 2278 end | |
| 2279 } | |
| 2280 ["Luan.raw_equal"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2281 title = "Luan.raw_equal (v1, v2)" |
| 1667 | 2282 content = function() |
| 2283 %> | |
| 2284 <p> | |
| 2285 Checks whether <code>v1</code> is equal to <code>v2</code>, | |
| 2286 without invoking any metamethod. | |
| 2287 Returns a boolean. | |
| 2288 </p> | |
| 2289 <% | |
| 2290 end | |
| 2291 } | |
| 2292 ["Luan.raw_get"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2293 title = "Luan.raw_get (table, index)" |
| 1667 | 2294 content = function() |
| 2295 %> | |
| 2296 <p> | |
| 2297 Gets the real value of <code>table[index]</code>, | |
| 2298 without invoking any metamethod. | |
| 2299 <code>table</code> must be a table; | |
| 2300 <code>index</code> may be any value. | |
| 2301 </p> | |
| 2302 <% | |
| 2303 end | |
| 2304 } | |
| 2305 ["Luan.raw_len"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2306 title = "Luan.raw_len (v)" |
| 1667 | 2307 content = function() |
| 2308 %> | |
| 2309 <p> | |
| 2310 Returns the length of the object <code>v</code>, | |
| 2311 which must be a table or a string, | |
| 2312 without invoking any metamethod. | |
| 2313 Returns an integer. | |
| 2314 </p> | |
| 2315 <% | |
| 2316 end | |
| 2317 } | |
| 2318 ["Luan.raw_set"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2319 title = "Luan.raw_set (table, index, value)" |
| 1667 | 2320 content = function() |
| 2321 %> | |
| 2322 <p> | |
| 2323 Sets the real value of <code>table[index]</code> to <code>value</code>, | |
| 2324 without invoking any metamethod. | |
| 2325 <code>table</code> must be a table, | |
| 2326 <code>index</code> any value different from <b>nil</b>, | |
| 2327 and <code>value</code> any Luan value. | |
| 2328 </p> | |
| 2329 <% | |
| 2330 end | |
| 2331 } | |
| 2332 ["Luan.set_metatable"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2333 title = "Luan.set_metatable (table, metatable)" |
| 1667 | 2334 content = function() |
| 2335 %> | |
| 2336 <p> | |
| 2337 Sets the metatable for the given table. | |
| 2338 If <code>metatable</code> is <b>nil</b>, | |
| 2339 removes the metatable of the given table. | |
| 2340 If the original metatable has a <code>"__metatable"</code> field, | |
| 2341 raises an error. | |
| 2342 </p> | |
| 2343 <% | |
| 2344 end | |
| 2345 } | |
| 2346 ["Luan.stringify"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2347 title = "Luan.stringify (v [,options])" |
| 1667 | 2348 content = function() |
| 2349 %> | |
| 2350 <p> | |
| 1813 | 2351 This Luan's equivalent to Javascript's JSON.stringify(), but for a Luan value. |
| 2352 <code>v</code> is a value of any type which is converted to a string that is a Luan expression. <code>options</code> may be a table or a function. If <code>options</code> is a table, it may contain the following flags whose <code>true</code> value means: | |
| 2353 </p> | |
| 2354 | |
| 2355 <ul> | |
| 2356 <li><b>strict</b> - invalid types throw an error</li> | |
| 2357 <li><b>number_types</b> - numbers will be wrapped in functions for their type</li> | |
| 2358 <li><b>compressed</b> - eliminates white space</li> | |
| 2359 <li><b>inline</b> - on one line</li> | |
| 2360 <li><b>no_name_keys</b> - forces all keys to be of the form <code>["key"]</code></li> | |
| 2361 </ul> | |
| 2362 | |
| 2363 <p>If <code>options</code> is a function then this function should take an argument <code>stack</code> and return an <code>options</code> table. The <code>stack</code> will be a list of keys indicating where stringify is currently processing. This allows different options to be applied at different places in a data structure.</p> | |
| 1667 | 2364 <% |
| 2365 end | |
| 2366 } | |
| 2367 ["Luan.to_string"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2368 title = "Luan.to_string (v)" |
| 1667 | 2369 content = function() |
| 2370 %> | |
| 2371 <p> | |
| 2372 Receives a value of any type and | |
| 2373 converts it to a string in a human-readable format. | |
| 2374 </p> | |
| 2375 | |
| 2376 <p> | |
| 2377 If the metatable of <code>v</code> has a <code>"__to_string"</code> field, | |
| 2378 then <code>to_string</code> calls the corresponding value | |
| 2379 with <code>v</code> as argument, | |
| 2380 and uses the result of the call as its result. | |
| 2381 </p> | |
| 2382 <% | |
| 2383 end | |
| 2384 } | |
| 2385 ["Luan.type"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2386 title = "Luan.type (v)" |
| 1667 | 2387 content = function() |
| 2388 %> | |
| 2389 <p> | |
| 2390 Returns the type of its only argument, coded as a string. | |
| 2391 The possible results of this function are | |
| 2392 "<code>nil</code>" (a string, not the value <b>nil</b>), | |
| 2393 "<code>number</code>", | |
| 2394 "<code>string</code>", | |
| 2395 "<code>binary</code>", | |
| 2396 "<code>boolean</code>", | |
| 2397 "<code>table</code>", | |
| 2398 "<code>function</code>", | |
| 2399 and "<code>java</code>". | |
| 2400 </p> | |
| 2401 <% | |
| 2402 end | |
| 2403 } | |
| 2404 ["Luan.values"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2405 title = "Luan.values (···)" |
| 1667 | 2406 content = function() |
| 2407 %> | |
| 2408 <p> | |
| 2409 Returns a function so that the construction | |
| 2410 </p> | |
| 2411 <pre> | |
| 2412 for i, v in Luan.values(···) do <em>body</em> end | |
| 2413 </pre> | |
| 2414 | |
| 2415 <p> | |
| 2416 will iterate over all values of <code>···</code>. | |
| 2417 </p> | |
| 2418 <% | |
| 2419 end | |
| 2420 } | |
| 2421 ["Luan.VERSION"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2422 title = "Luan.VERSION" |
| 1667 | 2423 content = function() |
| 2424 %> | |
| 2425 <p> | |
| 2426 A global variable (not a function) that | |
| 2427 holds a string containing the current Luan version. | |
| 2428 </p> | |
| 2429 <% | |
| 2430 end | |
| 2431 } | |
| 2432 } | |
| 2433 } | |
| 2434 package_lib = { | |
| 2435 title = "Modules" | |
| 2436 content = function() | |
| 2437 %> | |
| 2438 <p> | |
| 2439 Include this library by: | |
| 2440 </p> | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2441 <code block> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2442 local Package = require "luan:Package.luan" |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2443 </code> |
| 1667 | 2444 |
| 2445 <p> | |
| 2446 The package library provides basic | |
| 2447 facilities for loading modules in Luan. | |
| 2448 </p> | |
| 2449 <% | |
| 2450 end | |
| 2451 subs = { | |
| 2452 ["Package.load"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2453 title = "Package.load (mod_uri)" |
| 1667 | 2454 content = function() |
| 2455 %> | |
| 2456 <p> | |
| 2457 Loads the given module. | |
| 2458 The function starts by looking into the <a href="#Package.loaded"><code>Package.loaded</code></a> table | |
| 2459 to determine whether <code>mod_uri</code> is already loaded. | |
| 2460 If it is, then <code>Package.load</code> returns the value stored | |
| 2461 at <code>Package.loaded[mod_uri]</code>. | |
| 2462 Otherwise, it tries to load a new value for the module. | |
| 2463 </p> | |
| 2464 | |
| 2465 <p> | |
| 2466 To load a new value, <code>Package.load</code> first checks if <code>mod_uri</code> starts with "<b>java:</b>". If yes, then this is a Java class which is loaded by special Java code. | |
| 2467 </p> | |
| 2468 | |
| 2469 <p> | |
| 2470 Otherwise <code>Package.load</code> tries to read the text of the file referred to by <code>mod_uri</code>. If the file doesn't exist, then <code>Package.load</code> returns <b>false</b>. If the file exists, then its content is compiled into a chunk by calling <a href="#Luan.load"><code>Luan.load</code></a>. This chunk is run passing in <code>mod_uri</code> as an argument. The value returned by the chunk must not be <b>nil</b> and is loaded. | |
| 2471 </p> | |
| 2472 | |
| 2473 <p> | |
| 2474 If a new value for the module successful loaded, then it is stored in <code>Package.loaded[mod_uri]</code>. The value is returned. | |
| 2475 </p> | |
| 2476 <% | |
| 2477 end | |
| 2478 } | |
| 2479 ["Package.loaded"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2480 title = "Package.loaded" |
| 1667 | 2481 content = function() |
| 2482 %> | |
| 2483 <p> | |
| 2484 A table used by <a href="#Package.load"><code>Package.load</code></a> to control which | |
| 2485 modules are already loaded. | |
| 2486 When you load a module <code>mod_uri</code> and | |
| 2487 <code>Package.loaded[mod_uri]</code> is not <b>nil</b>, | |
| 2488 <a href="#Package.load"><code>Package.load</code></a> simply returns the value stored there. | |
| 2489 </p> | |
| 2490 | |
| 2491 <p> | |
| 2492 This variable is only a reference to the real table; | |
| 2493 assignments to this variable do not change the | |
| 2494 table used by <a href="#Package.load"><code>Package.load</code></a>. | |
| 2495 </p> | |
| 2496 <% | |
| 2497 end | |
| 2498 } | |
| 1656 | 2499 } |
| 2500 } | |
| 1668 | 2501 string_lib = { |
| 2502 title = "String Manipulation" | |
| 2503 content = function() | |
| 2504 %> | |
| 2505 <p> | |
| 2506 Include this library by: | |
| 2507 </p> | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2508 <code block> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2509 local String = require "luan:String.luan" |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2510 </code> |
| 1668 | 2511 |
| 2512 <p> | |
| 2513 This library provides generic functions for string manipulation, | |
| 2514 such as finding and extracting substrings, and pattern matching. | |
| 2515 When indexing a string in Luan, the first character is at position 1 | |
| 2516 (not at 0, as in Java). | |
| 2517 Indices are allowed to be negative and are interpreted as indexing backwards, | |
| 2518 from the end of the string. | |
| 2519 Thus, the last character is at position -1, and so on. | |
| 2520 </p> | |
| 2521 <% | |
| 2522 end | |
| 2523 subs = { | |
| 2524 ["String.char"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2525 title = "String.char (···)" |
| 1668 | 2526 content = function() |
| 2527 %> | |
| 2528 <p> | |
| 2529 Receives zero or more integers. | |
| 2530 Returns a string with length equal to the number of arguments, | |
| 2531 in which each character has the internal numerical code equal | |
| 2532 to its corresponding argument. | |
| 2533 </p> | |
| 2534 <% | |
| 2535 end | |
| 2536 } | |
| 1716 | 2537 ["String.contains"] = { |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2538 title = "String.contains (s, s2)" |
| 1716 | 2539 content = function() |
| 2540 %> | |
| 2541 <p> | |
| 2542 Returns a boolean indicating whether the <code>s</code> contains <code>s2</code>. | |
| 2543 </p> | |
| 2544 <% | |
| 2545 end | |
| 2546 } | |
| 1668 | 2547 ["String.encode"] = { |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2548 title = "String.encode (s)" |
| 1668 | 2549 content = function() |
| 2550 %> | |
| 2551 <p> | |
| 2552 Encodes argument <code>s</code> into a string that can be placed in quotes so as to return the original value of the string. | |
| 2553 </p> | |
| 2554 <% | |
| 2555 end | |
| 2556 } | |
| 1716 | 2557 ["String.ends_with"] = { |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2558 title = "String.ends_with (s, s2)" |
| 1716 | 2559 content = function() |
| 2560 %> | |
| 2561 <p> | |
| 2562 Returns a boolean indicating whether the <code>s</code> ends with <code>s2</code>. | |
| 2563 </p> | |
| 2564 <% | |
| 2565 end | |
| 2566 } | |
| 1668 | 2567 ["String.find"] = { |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2568 title = "String.find (s, s2 [, init])" |
| 1668 | 2569 content = function() |
| 2570 %> | |
| 2571 <p> | |
|
1721
5c69d2e8bd75
no regex in String.find and String.split
Franklin Schmidt <fschmidt@gmail.com>
parents:
1719
diff
changeset
|
2572 Looks for the first substring |
|
5c69d2e8bd75
no regex in String.find and String.split
Franklin Schmidt <fschmidt@gmail.com>
parents:
1719
diff
changeset
|
2573 <code>s2</code> in the string <code>s</code>. |
| 1668 | 2574 If it finds a match, then <code>find</code> returns the indices of <code>s</code> |
| 2575 where this occurrence starts and ends; | |
| 2576 otherwise, it returns <b>nil</b>. | |
| 2577 A third, optional numerical argument <code>init</code> specifies | |
| 2578 where to start the search; | |
| 2579 its default value is 1 and can be negative. | |
| 2580 </p> | |
| 2581 | |
| 2582 <p> | |
| 2583 If the pattern has captures, | |
| 2584 then in a successful match | |
| 2585 the captured values are also returned, | |
| 2586 after the two indices. | |
| 2587 </p> | |
| 2588 <% | |
| 2589 end | |
| 2590 } | |
| 2591 ["String.format"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2592 title = "String.format (formatstring, ···)" |
| 1668 | 2593 content = function() |
| 2594 %> | |
| 2595 <p> | |
| 2596 Returns a formatted version of its variable number of arguments | |
| 2597 following the description given in its first argument (which must be a string). | |
| 2598 The format string follows the same rules as the Java function <a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html#format(java.lang.String,%20java.lang.Object...)"><code>String.format</code></a> because Luan calls this internally. | |
| 2599 </p> | |
| 2600 | |
| 2601 <p> | |
| 2602 Note that Java's <code>String.format</code> is too stupid to convert between ints and floats, so you must provide the right kind of number. | |
| 2603 </p> | |
| 2604 <% | |
| 2605 end | |
| 2606 } | |
| 2607 ["String.lower"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2608 title = "String.lower (s)" |
| 1668 | 2609 content = function() |
| 2610 %> | |
| 2611 <p> | |
| 2612 Receives a string and returns a copy of this string with all | |
| 2613 uppercase letters changed to lowercase. | |
| 2614 All other characters are left unchanged. | |
| 2615 </p> | |
| 2616 <% | |
| 2617 end | |
| 2618 } | |
| 1716 | 2619 ["String.regex"] = { |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2620 title = "String.regex (s)" |
| 1716 | 2621 content = function() |
| 2622 %> | |
| 2623 <p> | |
| 2624 Returns a <a href="#regex_table">regex</a> table for the pattern <code>s</code>. | |
| 2625 </p> | |
| 2626 <% | |
| 2627 end | |
| 2628 } | |
| 1668 | 2629 ["String.regex_quote"] = { |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2630 title = "String.regex_quote (s)" |
| 1668 | 2631 content = function() |
| 2632 %> | |
| 2633 <p> | |
| 2634 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>. | |
| 2635 </p> | |
| 2636 <% | |
| 2637 end | |
| 2638 } | |
|
1718
5603ee8e2a71
rename String.rep to String.repeated
Franklin Schmidt <fschmidt@gmail.com>
parents:
1717
diff
changeset
|
2639 ["String.repeated"] = { |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2640 title = "String.repeated (s, n [, sep])" |
| 1668 | 2641 content = function() |
| 2642 %> | |
| 2643 <p> | |
| 2644 Returns a string that is the concatenation of <code>n</code> copies of | |
| 2645 the string <code>s</code> separated by the string <code>sep</code>. | |
| 2646 The default value for <code>sep</code> is the empty string | |
| 2647 (that is, no separator). | |
| 2648 Returns the empty string if <code>n</code> is not positive. | |
| 2649 </p> | |
| 2650 <% | |
| 2651 end | |
| 2652 } | |
| 1717 | 2653 ["String.replace"] = { |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2654 title = "String.replace (s, target, replacement)" |
| 1717 | 2655 content = function() |
| 2656 %> | |
| 2657 <p> | |
| 2658 Returns a string where each substring <code>target</code> in <code>s</code> is replaced by <code>replacement</code>. | |
| 2659 </p> | |
| 2660 <% | |
| 2661 end | |
| 2662 } | |
| 1668 | 2663 ["String.reverse"] = { |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2664 title = "String.reverse (s)" |
| 1668 | 2665 content = function() |
| 2666 %> | |
| 2667 <p> | |
| 2668 Returns a string that is the string <code>s</code> reversed. | |
| 2669 </p> | |
| 2670 <% | |
| 2671 end | |
| 2672 } | |
| 2673 ["String.split"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2674 title = "String.split (s, s2 [, limit])" |
| 1668 | 2675 content = function() |
| 2676 %> | |
| 2677 <p> | |
|
1721
5c69d2e8bd75
no regex in String.find and String.split
Franklin Schmidt <fschmidt@gmail.com>
parents:
1719
diff
changeset
|
2678 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. |
| 1668 | 2679 </p> |
| 2680 <% | |
| 2681 end | |
| 2682 } | |
| 1716 | 2683 ["String.starts_with"] = { |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2684 title = "String.starts_with (s, s2)" |
| 1716 | 2685 content = function() |
| 2686 %> | |
| 2687 <p> | |
| 2688 Returns a boolean indicating whether the <code>s</code> starts with <code>s2</code>. | |
| 2689 </p> | |
| 2690 <% | |
| 2691 end | |
| 2692 } | |
| 1668 | 2693 ["String.sub"] = { |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2694 title = "String.sub (s, i [, j])" |
| 1668 | 2695 content = function() |
| 2696 %> | |
| 2697 <p> | |
| 2698 Returns the substring of <code>s</code> that | |
| 2699 starts at <code>i</code> and continues until <code>j</code>; | |
| 2700 <code>i</code> and <code>j</code> can be negative. | |
| 2701 If <code>j</code> is absent, then it is assumed to be equal to -1 | |
| 2702 (which is the same as the string length). | |
| 2703 In particular, | |
| 2704 the call <code>string.sub(s,1,j)</code> returns a prefix of <code>s</code> | |
| 2705 with length <code>j</code>, | |
| 2706 and <code>string.sub(s, -i)</code> returns a suffix of <code>s</code> | |
| 2707 with length <code>i</code>. | |
| 2708 </p> | |
| 2709 | |
| 2710 <p> | |
| 2711 If, after the translation of negative indices, | |
| 2712 <code>i</code> is less than 1, | |
| 2713 it is corrected to 1. | |
| 2714 If <code>j</code> is greater than the string length, | |
| 2715 it is corrected to that length. | |
| 2716 If, after these corrections, | |
| 2717 <code>i</code> is greater than <code>j</code>, | |
| 2718 the function returns the empty string. | |
| 2719 </p> | |
| 2720 <% | |
| 2721 end | |
| 2722 } | |
| 2723 ["String.to_binary"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2724 title = "String.to_binary (s)" |
| 1668 | 2725 content = function() |
| 2726 %> | |
| 2727 <p> | |
| 2728 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>. | |
| 2729 </p> | |
| 2730 <% | |
| 2731 end | |
| 2732 } | |
| 2733 ["String.to_number"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2734 title = "String.to_number (s [, base])" |
| 1668 | 2735 content = function() |
| 2736 %> | |
| 2737 <p> | |
| 2738 When called with no <code>base</code>, | |
| 2739 <code>to_number</code> tries to convert its argument to a number. | |
| 2740 If the argument is | |
| 2741 a string convertible to a number, | |
| 2742 then <code>to_number</code> returns this number; | |
| 2743 otherwise, it returns <b>nil</b>. | |
| 2744 The conversion of strings can result in integers or floats. | |
| 2745 </p> | |
| 2746 | |
| 2747 <p> | |
| 2748 When called with <code>base</code>, | |
| 2749 then <code>s</code> must be a string to be interpreted as | |
| 2750 an integer numeral in that base. | |
| 2751 In bases above 10, the letter '<code>A</code>' (in either upper or lower case) | |
| 2752 represents 10, '<code>B</code>' represents 11, and so forth, | |
| 2753 with '<code>Z</code>' representing 35. | |
| 2754 If the string <code>s</code> is not a valid numeral in the given base, | |
| 2755 the function returns <b>nil</b>. | |
| 2756 </p> | |
| 2757 <% | |
| 2758 end | |
| 2759 } | |
| 2760 ["String.trim"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2761 title = "String.trim (s)" |
| 1668 | 2762 content = function() |
| 2763 %> | |
| 2764 <p> | |
| 2765 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>. | |
| 2766 </p> | |
| 2767 <% | |
| 2768 end | |
| 2769 } | |
| 2770 ["String.unicode"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2771 title = "String.unicode (s [, i [, j]])" |
| 1668 | 2772 content = function() |
| 2773 %> | |
| 2774 <p> | |
| 2775 Returns the internal numerical codes of the characters <code>s[i]</code>, | |
| 2776 <code>s[i+1]</code>, ..., <code>s[j]</code>. | |
| 2777 The default value for <code>i</code> is 1; | |
| 2778 the default value for <code>j</code> is <code>i</code>. | |
| 2779 These indices are corrected | |
| 2780 following the same rules of function <a href="#String.sub"><code>String.sub</code></a>. | |
| 2781 </p> | |
| 2782 <% | |
| 2783 end | |
| 2784 } | |
| 2785 ["String.upper"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2786 title = "String.upper (s)" |
| 1668 | 2787 content = function() |
| 2788 %> | |
| 2789 <p> | |
| 2790 Receives a string and returns a copy of this string with all | |
| 2791 lowercase letters changed to uppercase. | |
| 2792 All other characters are left unchanged. | |
| 2793 The definition of what a lowercase letter is depends on the current locale. | |
| 2794 </p> | |
| 2795 <% | |
| 2796 end | |
| 2797 } | |
| 2798 } | |
| 2799 } | |
| 1716 | 2800 regex_table = { |
| 2801 title = "Regular Expressions" | |
| 2802 content = function() | |
| 2803 %> | |
| 2804 <p> | |
| 2805 Regular expressions are handled using a regex table generated by <a href="#String.regex">String.regex</a>. | |
| 2806 </p> | |
| 2807 | |
| 2808 <p> | |
| 2809 Pattern matching is based on the Java <a href="http://docs.oracle.com/javase/7/docs/api/java/util/regex/Pattern.html">Pattern</a> class. | |
| 2810 </p> | |
| 2811 <% | |
| 2812 end | |
| 2813 subs = { | |
| 2814 ["regex.find"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2815 title = "regex.find (s [, init])" |
| 1716 | 2816 content = function() |
| 2817 %> | |
| 2818 <p> | |
| 2819 Looks for the first match of | |
| 2820 the regex in the string <code>s</code>. | |
| 2821 If it finds a match, then <code>find</code> returns the indices of <code>s</code> | |
| 2822 where this occurrence starts and ends; | |
| 2823 otherwise, it returns <b>nil</b>. | |
| 2824 A third, optional numerical argument <code>init</code> specifies | |
| 2825 where to start the search; | |
| 2826 its default value is 1 and can be negative. | |
| 2827 </p> | |
| 2828 | |
| 2829 <p> | |
| 2830 If the regex has captures, | |
| 2831 then in a successful match | |
| 2832 the captured values are also returned, | |
| 2833 after the two indices. | |
| 2834 </p> | |
| 2835 <% | |
| 2836 end | |
| 2837 } | |
| 2838 ["regex.gmatch"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2839 title = "regex.gmatch (s)" |
| 1716 | 2840 content = function() |
| 2841 %> | |
| 2842 <p> | |
| 2843 Returns an iterator function that, | |
| 2844 each time it is called, | |
| 2845 returns the next captures from the regex | |
| 2846 over the string <code>s</code>. | |
| 2847 If the regex specifies no captures, | |
| 2848 then the whole match is produced in each call. | |
| 2849 </p> | |
| 2850 | |
| 2851 <p> | |
| 2852 As an example, the following loop | |
| 2853 will iterate over all the words from string <code>s</code>, | |
| 2854 printing one per line: | |
| 2855 </p> | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2856 <code block> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2857 local r = String.regex[[\w+]] |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2858 local s = "hello world from Lua" |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2859 for w in r.gmatch(s) do |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2860 print(w) |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2861 end |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2862 </code> |
| 1716 | 2863 |
| 2864 <p> | |
| 2865 The next example collects all pairs <code>key=value</code> from the | |
| 2866 given string into a table: | |
| 2867 </p> | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2868 <code block> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2869 local t = {} |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2870 local r = String.regex[[(\w+)=(\w+)]] |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2871 local s = "from=world, to=Lua" |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2872 for k, v in r.gmatch(s) do |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2873 t[k] = v |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2874 end |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2875 </code> |
| 1716 | 2876 |
| 2877 <p> | |
| 2878 For this function, a caret '<code>^</code>' at the start of a pattern does not | |
| 2879 work as an anchor, as this would prevent the iteration. | |
| 2880 </p> | |
| 2881 <% | |
| 2882 end | |
| 2883 } | |
| 2884 ["regex.gsub"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2885 title = "regex.gsub (s, repl [, n])" |
| 1716 | 2886 content = function() |
| 2887 %> | |
| 2888 <p> | |
| 2889 Returns a copy of <code>s</code> | |
| 2890 in which all (or the first <code>n</code>, if given) | |
| 2891 occurrences of the regex have been | |
| 2892 replaced by a replacement string specified by <code>repl</code>, | |
| 2893 which can be a string, a table, or a function. | |
| 2894 <code>gsub</code> also returns, as its second value, | |
| 2895 the total number of matches that occurred. | |
| 2896 The name <code>gsub</code> comes from <em>Global SUBstitution</em>. | |
| 2897 </p> | |
| 2898 | |
| 2899 <p> | |
| 2900 If <code>repl</code> is a string, then its value is used for replacement. | |
| 2901 The character <code>\</code> works as an escape character. | |
| 2902 Any sequence in <code>repl</code> of the form <code>$<em>d</em></code>, | |
| 2903 with <em>d</em> between 1 and 9, | |
| 2904 stands for the value of the <em>d</em>-th captured substring. | |
| 2905 The sequence <code>$0</code> stands for the whole match. | |
| 2906 </p> | |
| 2907 | |
| 2908 <p> | |
| 2909 If <code>repl</code> is a table, then the table is queried for every match, | |
| 2910 using the first capture as the key. | |
| 2911 </p> | |
| 2912 | |
| 2913 <p> | |
| 2914 If <code>repl</code> is a function, then this function is called every time a | |
| 2915 match occurs, with all captured substrings passed as arguments, | |
| 2916 in order. | |
| 2917 </p> | |
| 2918 | |
| 2919 <p> | |
| 2920 In any case, | |
| 2921 if the regex specifies no captures, | |
| 2922 then it behaves as if the whole regex was inside a capture. | |
| 2923 </p> | |
| 2924 | |
| 2925 <p> | |
| 2926 If the value returned by the table query or by the function call | |
| 2927 is not <b>nil</b>, | |
| 2928 then it is used as the replacement string; | |
| 2929 otherwise, if it is <b>nil</b>, | |
| 2930 then there is no replacement | |
| 2931 (that is, the original match is kept in the string). | |
| 2932 </p> | |
| 2933 | |
| 2934 <p> | |
| 2935 Here are some examples: | |
| 2936 </p> | |
| 2937 | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2938 <code block> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2939 local r = String.regex[[(\w+)]] |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2940 local x = r.gsub("hello world", "$1 $1") |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2941 --> x="hello hello world world" |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2942 |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2943 local r = String.regex[[(\w+)]] |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2944 local x = r.gsub("hello world", "$0 $0", 1) |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2945 --> x="hello hello world" |
| 1716 | 2946 |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2947 local r = String.regex[[(\w+)\s*(\w+)]] |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2948 local x = r.gsub("hello world from Luan", "$2 $1") |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2949 --> x="world hello Luan from" |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2950 |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2951 local r = String.regex[[\$(.*?)\$]] |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2952 local x = r.gsub("4+5 = $return 4+5$", function(s) |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2953 return load(s)() |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2954 end) |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2955 --> x="4+5 = 9" |
| 1716 | 2956 |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2957 local r = String.regex[[\$(\w+)]] |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2958 local t = {name="lua", version="5.3"} |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2959 local x = r.gsub("$name-$version.tar.gz", t) |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2960 --> x="lua-5.3.tar.gz" |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2961 </code> |
| 1716 | 2962 <% |
| 2963 end | |
| 2964 } | |
| 2965 ["regex.match"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2966 title = "regex.match (s [, init])" |
| 1716 | 2967 content = function() |
| 2968 %> | |
| 2969 <p> | |
| 2970 Looks for the first <em>match</em> of | |
| 2971 the regex in the string <code>s</code>. | |
| 2972 If it finds one, then <code>match</code> returns | |
| 2973 the captures from the regex; | |
| 2974 otherwise it returns <b>nil</b>. | |
| 2975 If the regex specifies no captures, | |
| 2976 then the whole match is returned. | |
| 2977 A third, optional numerical argument <code>init</code> specifies | |
| 2978 where to start the search; | |
| 2979 its default value is 1 and can be negative. | |
| 2980 </p> | |
| 2981 <% | |
| 2982 end | |
| 2983 } | |
| 2984 ["regex.matches"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2985 title = "regex.matches (s)" |
| 1716 | 2986 content = function() |
| 2987 %> | |
| 2988 <p> | |
| 2989 Returns a boolean indicating whether the regex can be found in string <code>s</code>. | |
| 2990 This function is equivalent to | |
| 2991 </p> | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2992 <code block> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2993 return regex.match(s) ~= nil |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2994 </code> |
| 1716 | 2995 <% |
| 2996 end | |
| 2997 } | |
| 1719 | 2998 ["regex.set"] = { |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
2999 title = "regex.set (pattern)" |
| 1719 | 3000 content = function() |
| 3001 %> | |
| 3002 <p> | |
| 3003 Changes the regex pattern to <code>pattern</code>. | |
| 3004 </p> | |
| 3005 <% | |
| 3006 end | |
| 3007 } | |
| 3008 ["regex.split"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3009 title = "regex.split (s [, limit])" |
| 1719 | 3010 content = function() |
| 3011 %> | |
| 3012 <p> | |
| 3013 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. | |
| 3014 </p> | |
| 3015 <% | |
| 3016 end | |
| 3017 } | |
| 1716 | 3018 } |
| 3019 } | |
| 1668 | 3020 binary_lib = { |
| 3021 title = "Binary Manipulation" | |
| 3022 content = function() | |
| 3023 %> | |
| 3024 <p> | |
| 3025 Include this library by: | |
| 3026 </p> | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3027 <code block> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3028 local Binary = require "luan:Binary.luan" |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3029 </code> |
| 1668 | 3030 <% |
| 3031 end | |
| 3032 subs = { | |
| 3033 ["Binary.binary"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3034 title = "Binary.binary (···)" |
| 1668 | 3035 content = function() |
| 3036 %> | |
| 3037 <p> | |
| 3038 Receives zero or more bytes (as integers). | |
| 3039 Returns a binary with length equal to the number of arguments, | |
| 3040 in which each byte has the internal numerical code equal | |
| 3041 to its corresponding argument. | |
| 3042 </p> | |
| 3043 <% | |
| 3044 end | |
| 3045 } | |
| 3046 ["Binary.byte"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3047 title = "Binary.byte (b [, i [, j]])" |
| 1668 | 3048 content = function() |
| 3049 %> | |
| 3050 <p> | |
| 3051 Returns the internal numerical codes of the bytes <code>b[i]</code>, | |
| 3052 <code>b[i+1]</code>, ..., <code>b[j]</code>. | |
| 3053 The default value for <code>i</code> is 1; | |
| 3054 the default value for <code>j</code> is <code>i</code>. | |
| 3055 These indices are corrected | |
| 3056 following the same rules of function <a href="#String.sub"><code>String.sub</code></a>. | |
| 3057 </p> | |
| 3058 <% | |
| 3059 end | |
| 3060 } | |
| 3061 ["Binary.to_string"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3062 title = "Binary.to_string (b [,charset])" |
| 1668 | 3063 content = function() |
| 3064 %> | |
| 3065 <p> | |
| 3066 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. | |
| 3067 </p> | |
| 3068 <% | |
| 3069 end | |
| 3070 } | |
| 3071 } | |
| 3072 } | |
| 3073 table_lib = { | |
| 3074 title = "Table Manipulation" | |
| 3075 content = function() | |
| 3076 %> | |
| 3077 <p> | |
| 3078 Include this library by: | |
| 3079 </p> | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3080 <code block> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3081 local Table = require "luan:Table.luan" |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3082 </code> |
| 1668 | 3083 |
| 3084 <p> | |
| 3085 This library provides generic functions for table manipulation. | |
| 3086 It provides all its functions inside the table <code>Table</code>. | |
| 3087 </p> | |
| 3088 <% | |
| 3089 end | |
| 3090 subs = { | |
| 3091 ["Table.clear"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3092 title = "Table.clear (tbl)" |
| 1668 | 3093 content = function() |
| 3094 %> | |
| 3095 <p> | |
| 3096 Clears the table. | |
| 3097 </p> | |
| 3098 <% | |
| 3099 end | |
| 3100 } | |
| 3101 ["Table.concat"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3102 title = "Table.concat (list [, sep [, i [, j]]])" |
| 1668 | 3103 content = function() |
| 3104 %> | |
| 3105 <p> | |
| 3106 Given a list, | |
| 3107 returns the string <code>list[i]..sep..list[i+1] ··· sep..list[j]</code>. | |
| 3108 The default value for <code>sep</code> is the empty string, | |
| 3109 the default for <code>i</code> is 1, | |
| 3110 and the default for <code>j</code> is <code>#list</code>. | |
| 3111 If <code>i</code> is greater than <code>j</code>, returns the empty string. | |
| 3112 </p> | |
| 3113 <% | |
| 3114 end | |
| 3115 } | |
| 3116 ["Table.copy"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3117 title = "Table.copy (tbl [, i [, j]])" |
| 1668 | 3118 content = function() |
| 3119 %> | |
| 3120 <p> | |
| 3121 If <code>i</code> is <code>nil</code>, returns a shallow copy of <code>tbl</code>. | |
| 3122 Otherwise returns a new table which is a list of the elements <code>tbl[i] ··· tbl[j]</code>. | |
| 3123 By default, <code>j</code> is <code>#tbl</code>. | |
| 3124 </p> | |
| 3125 <% | |
| 3126 end | |
| 3127 } | |
| 3128 ["Table.insert"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3129 title = "Table.insert (list, pos, value)" |
| 1668 | 3130 content = function() |
| 3131 %> | |
| 3132 <p> | |
| 3133 Inserts element <code>value</code> at position <code>pos</code> in <code>list</code>, | |
| 3134 shifting up the elements | |
| 3135 <code>list[pos], list[pos+1], ···, list[#list]</code>. | |
| 3136 </p> | |
| 3137 <% | |
| 3138 end | |
| 3139 } | |
| 3140 ["Table.is_empty"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3141 title = "Table.is_empty (tbl)" |
| 1668 | 3142 content = function() |
| 3143 %> | |
| 3144 <% | |
| 3145 end | |
| 3146 } | |
| 1704 | 3147 ["Table.is_list"] = { |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3148 title = "Table.is_list (tbl)" |
| 1704 | 3149 content = function() |
| 3150 %> | |
| 3151 <% | |
| 3152 end | |
| 3153 } | |
| 1668 | 3154 ["Table.pack"] = { |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3155 title = "Table.pack (···)" |
| 1668 | 3156 content = function() |
| 3157 %> | |
| 3158 <p> | |
| 3159 Returns a new table with all parameters stored into keys 1, 2, etc. | |
| 3160 and with a field "<code>n</code>" with the total number of parameters. | |
| 3161 Note that the resulting table may not be a sequence. | |
| 3162 </p> | |
| 3163 <% | |
| 3164 end | |
| 3165 } | |
| 3166 ["Table.remove"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3167 title = "Table.remove (list, pos)" |
| 1668 | 3168 content = function() |
| 3169 %> | |
| 3170 <p> | |
| 3171 Removes from <code>list</code> the element at position <code>pos</code>, | |
| 3172 returning the value of the removed element. | |
| 3173 When <code>pos</code> is an integer between 1 and <code>#list</code>, | |
| 3174 it shifts down the elements | |
| 3175 <code>list[pos+1], list[pos+2], ···, list[#list]</code> | |
| 3176 and erases element <code>list[#list]</code>; | |
| 3177 The index <code>pos</code> can also be 0 when <code>#list</code> is 0, | |
| 3178 or <code>#list + 1</code>; | |
| 3179 in those cases, the function erases the element <code>list[pos]</code>. | |
| 3180 </p> | |
| 3181 <% | |
| 3182 end | |
| 3183 } | |
| 3184 ["Table.size"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3185 title = "Table.size (tbl)" |
| 1668 | 3186 content = function() |
| 3187 %> | |
| 3188 <% | |
| 3189 end | |
| 3190 } | |
| 3191 ["Table.sort"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3192 title = "Table.sort (list [, comp])" |
| 1668 | 3193 content = function() |
| 3194 %> | |
| 3195 <p> | |
| 3196 Sorts list elements in a given order, <em>in-place</em>, | |
| 3197 from <code>list[1]</code> to <code>list[#list]</code>. | |
| 3198 If <code>comp</code> is given, | |
| 3199 then it must be a function that receives two list elements | |
| 3200 and returns true when the first element must come | |
| 3201 before the second in the final order | |
| 3202 (so that <code>not comp(list[i+1],list[i])</code> will be true after the sort). | |
| 3203 If <code>comp</code> is not given, | |
| 3204 then the standard Lua operator <code><</code> is used instead. | |
| 3205 </p> | |
| 3206 | |
| 3207 <p> | |
| 3208 The sort algorithm is not stable; | |
| 3209 that is, elements considered equal by the given order | |
| 3210 may have their relative positions changed by the sort. | |
| 3211 </p> | |
| 3212 <% | |
| 3213 end | |
| 3214 } | |
| 3215 ["Table.unpack"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3216 title = "Table.unpack (list [, i [, j]])" |
| 1668 | 3217 content = function() |
| 3218 %> | |
| 3219 <p> | |
| 3220 Returns the elements from the given list. | |
| 3221 This function is equivalent to | |
| 3222 </p> | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3223 <code block> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3224 return list[i], list[i+1], ···, list[j] |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3225 </code> |
| 1668 | 3226 |
| 3227 <p> | |
| 3228 By default, <code>i</code> is 1 and <code>j</code> is <code>list.n or #list</code>. | |
| 3229 </p> | |
| 3230 <% | |
| 3231 end | |
| 3232 } | |
| 3233 } | |
| 3234 } | |
| 3235 number_lib = { | |
| 3236 title = "Number Manipulation" | |
| 3237 content = function() | |
| 3238 %> | |
| 3239 <p> | |
| 3240 Include this library by: | |
| 3241 </p> | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3242 <code block> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3243 local Number = require "luan:Number.luan" |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3244 </code> |
| 1668 | 3245 <% |
| 3246 end | |
| 3247 subs = { | |
| 3248 ["Number.double"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3249 title = "Number.double (x)" |
| 1668 | 3250 content = function() |
| 3251 %> | |
| 3252 <p> | |
| 3253 Returns <code>x</code> as a double. | |
| 3254 </p> | |
| 3255 <% | |
| 3256 end | |
| 3257 } | |
| 3258 ["Number.float"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3259 title = "Number.float (x)" |
| 1668 | 3260 content = function() |
| 3261 %> | |
| 3262 <p> | |
| 3263 Returns <code>x</code> as a float. | |
| 3264 </p> | |
| 3265 <% | |
| 3266 end | |
| 3267 } | |
| 3268 ["Number.integer"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3269 title = "Number.integer (x)" |
| 1668 | 3270 content = function() |
| 3271 %> | |
| 3272 <p> | |
| 3273 If the value <code>x</code> is convertible to an integer, | |
| 3274 returns that integer. | |
| 3275 Otherwise throws an error. | |
| 3276 </p> | |
| 3277 <% | |
| 3278 end | |
| 3279 } | |
| 3280 ["Number.long"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3281 title = "Number.long (x)" |
| 1668 | 3282 content = function() |
| 3283 %> | |
| 3284 <p> | |
| 3285 If the value <code>x</code> is convertible to an long, | |
| 3286 returns that long. | |
| 3287 Otherwise throws an error. | |
| 3288 </p> | |
| 3289 <% | |
| 3290 end | |
| 3291 } | |
| 3292 ["Number.long_to_string"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3293 title = "Number.long_to_string (i, radix)" |
| 1668 | 3294 content = function() |
| 3295 %> | |
| 3296 <p> | |
| 3297 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>. | |
| 3298 </p> | |
| 3299 <% | |
| 3300 end | |
| 3301 } | |
| 3302 ["Number.type"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3303 title = "Number.type (x)" |
| 1668 | 3304 content = function() |
| 3305 %> | |
| 3306 <p> | |
| 3307 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>". | |
| 3308 </p> | |
| 3309 <% | |
| 3310 end | |
| 3311 } | |
| 3312 } | |
| 3313 } | |
| 1669 | 3314 math_lib = { |
| 3315 title = "Mathematical Functions" | |
| 3316 content = function() | |
| 3317 %> | |
| 3318 <p> | |
| 3319 Include this library by: | |
| 3320 </p> | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3321 <code block> |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3322 local Math = require "luan:Math.luan" |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3323 </code> |
| 1669 | 3324 |
| 3325 <p> | |
| 3326 This library provides basic mathematical functions. | |
| 3327 It provides all its functions and constants inside the table <code>Math</code>. | |
| 3328 </p> | |
| 3329 <% | |
| 3330 end | |
| 3331 subs = { | |
| 3332 ["Math.abs"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3333 title = "Math.abs (x)" |
| 1669 | 3334 content = function() |
| 3335 %> | |
| 3336 <p> | |
| 3337 Returns the absolute value of <code>x</code>. | |
| 3338 </p> | |
| 3339 <% | |
| 3340 end | |
| 3341 } | |
| 3342 ["Math.acos"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3343 title = "Math.acos (x)" |
| 1669 | 3344 content = function() |
| 3345 %> | |
| 3346 <p> | |
| 3347 Returns the arc cosine of <code>x</code> (in radians). | |
| 3348 </p> | |
| 3349 <% | |
| 3350 end | |
| 3351 } | |
| 3352 ["Math.asin"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3353 title = "Math.asin (x)" |
| 1669 | 3354 content = function() |
| 3355 %> | |
| 3356 <p> | |
| 3357 Returns the arc sine of <code>x</code> (in radians). | |
| 3358 </p> | |
| 3359 <% | |
| 3360 end | |
| 3361 } | |
| 3362 ["Math.atan"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3363 title = "Math.atan (y, x)" |
| 1669 | 3364 content = function() |
| 3365 %> | |
| 3366 <p> | |
| 3367 Returns the arc tangent of <code>y/x</code> (in radians), | |
| 3368 but uses the signs of both parameters to find the | |
| 3369 quadrant of the result. | |
| 3370 (It also handles correctly the case of <code>x</code> being zero.) | |
| 3371 </p> | |
| 3372 <% | |
| 3373 end | |
| 3374 } | |
| 3375 ["Math.ceil"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3376 title = "Math.ceil (x)" |
| 1669 | 3377 content = function() |
| 3378 %> | |
| 3379 <p> | |
| 3380 Returns the smallest integral value larger than or equal to <code>x</code>. | |
| 3381 </p> | |
| 3382 <% | |
| 3383 end | |
| 3384 } | |
| 3385 ["Math.cos"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3386 title = "Math.cos (x)" |
| 1669 | 3387 content = function() |
| 3388 %> | |
| 3389 <p> | |
| 3390 Returns the cosine of <code>x</code> (assumed to be in radians). | |
| 3391 </p> | |
| 3392 <% | |
| 3393 end | |
| 3394 } | |
| 3395 ["Math.deg"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3396 title = "Math.deg (x)" |
| 1669 | 3397 content = function() |
| 3398 %> | |
| 3399 <p> | |
| 3400 Converts the angle <code>x</code> from radians to degrees. | |
| 3401 </p> | |
| 3402 <% | |
| 3403 end | |
| 3404 } | |
| 3405 ["Math.exp"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3406 title = "Math.exp (x)" |
| 1669 | 3407 content = function() |
| 3408 %> | |
| 3409 <p> | |
| 3410 Returns the value <em>e<sup>x</sup></em> | |
| 3411 (where <code>e</code> is the base of natural logarithms). | |
| 3412 </p> | |
| 3413 <% | |
| 3414 end | |
| 3415 } | |
| 3416 ["Math.floor"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3417 title = "Math.floor (x)" |
| 1669 | 3418 content = function() |
| 3419 %> | |
| 3420 <p> | |
| 3421 Returns the largest integral value smaller than or equal to <code>x</code>. | |
| 3422 </p> | |
| 3423 <% | |
| 3424 end | |
| 3425 } | |
| 3426 ["Math.fmod"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3427 title = "Math.fmod (x, y)" |
| 1669 | 3428 content = function() |
| 3429 %> | |
| 3430 <p> | |
| 3431 Returns the remainder of the division of <code>x</code> by <code>y</code> | |
| 3432 that rounds the quotient towards zero. | |
| 3433 </p> | |
| 3434 <% | |
| 3435 end | |
| 3436 } | |
| 3437 ["Math.huge"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3438 title = "Math.huge" |
| 1669 | 3439 content = function() |
| 3440 %> | |
| 3441 <p> | |
| 3442 A value larger than any other numerical value. | |
| 3443 </p> | |
| 3444 <% | |
| 3445 end | |
| 3446 } | |
| 3447 ["Math.log"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3448 title = "Math.log (x [, base])" |
| 1669 | 3449 content = function() |
| 3450 %> | |
| 3451 <p> | |
| 3452 Returns the logarithm of <code>x</code> in the given base. | |
| 3453 The default for <code>base</code> is <em>e</em> | |
| 3454 (so that the function returns the natural logarithm of <code>x</code>). | |
| 3455 </p> | |
| 3456 <% | |
| 3457 end | |
| 3458 } | |
| 3459 ["Math.max"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3460 title = "Math.max (x, ···)" |
| 1669 | 3461 content = function() |
| 3462 %> | |
| 3463 <p> | |
| 3464 Returns the argument with the maximum value, | |
| 3465 according to the Lua operator <code><</code>. | |
| 3466 </p> | |
| 3467 <% | |
| 3468 end | |
| 3469 } | |
| 3470 ["Math.max_integer"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3471 title = "Math.max_integer" |
| 1669 | 3472 content = function() |
| 3473 %> | |
| 3474 <p> | |
| 3475 An integer with the maximum value for an integer. | |
| 3476 </p> | |
| 3477 <% | |
| 3478 end | |
| 3479 } | |
| 3480 ["Math.min"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3481 title = "Math.min (x, ···)" |
| 1669 | 3482 content = function() |
| 3483 %> | |
| 3484 <p> | |
| 3485 Returns the argument with the minimum value, | |
| 3486 according to the Lua operator <code><</code>. | |
| 3487 </p> | |
| 3488 <% | |
| 3489 end | |
| 3490 } | |
| 3491 ["Math.min_integer"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3492 title = "Math.min_integer" |
| 1669 | 3493 content = function() |
| 3494 %> | |
| 3495 <p> | |
| 3496 An integer with the minimum value for an integer. | |
| 3497 </p> | |
| 3498 <% | |
| 3499 end | |
| 3500 } | |
| 3501 ["Math.modf"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3502 title = "Math.modf (x)" |
| 1669 | 3503 content = function() |
| 3504 %> | |
| 3505 <p> | |
| 3506 Returns the integral part of <code>x</code> and the fractional part of <code>x</code>. | |
| 3507 </p> | |
| 3508 <% | |
| 3509 end | |
| 3510 } | |
| 3511 ["Math.pi"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3512 title = "Math.pi" |
| 1669 | 3513 content = function() |
| 3514 %> | |
| 3515 <p> | |
| 3516 The value of <em>π</em>. | |
| 3517 </p> | |
| 3518 <% | |
| 3519 end | |
| 3520 } | |
| 3521 ["Math.rad"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3522 title = "Math.rad (x)" |
| 1669 | 3523 content = function() |
| 3524 %> | |
| 3525 <p> | |
| 3526 Converts the angle <code>x</code> from degrees to radians. | |
| 3527 </p> | |
| 3528 <% | |
| 3529 end | |
| 3530 } | |
| 3531 ["Math.random"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3532 title = "Math.random ([m [, n])" |
| 1669 | 3533 content = function() |
| 3534 %> | |
| 3535 <p> | |
| 3536 When called without arguments, | |
| 3537 returns a pseudo-random float with uniform distribution | |
| 3538 in the range <em>[0,1)</em>. | |
| 3539 When called with two integers <code>m</code> and <code>n</code>, | |
| 3540 <code>Math.random</code> returns a pseudo-random integer | |
| 3541 with uniform distribution in the range <em>[m, n]</em>. | |
| 3542 (The value <em>m-n</em> cannot be negative and must fit in a Luan integer.) | |
| 3543 The call <code>Math.random(n)</code> is equivalent to <code>Math.random(1,n)</code>. | |
| 3544 </p> | |
| 3545 | |
| 3546 <p> | |
| 3547 This function is an interface to the underling | |
| 3548 pseudo-random generator function provided by Java. | |
| 3549 No guarantees can be given for its statistical properties. | |
| 3550 </p> | |
| 3551 <% | |
| 3552 end | |
| 3553 } | |
| 3554 ["Math.sin"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3555 title = "Math.sin (x)" |
| 1669 | 3556 content = function() |
| 3557 %> | |
| 3558 <p> | |
| 3559 Returns the sine of <code>x</code> (assumed to be in radians). | |
| 3560 </p> | |
| 3561 <% | |
| 3562 end | |
| 3563 } | |
| 3564 ["Math.sqrt"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3565 title = "Math.sqrt (x)" |
| 1669 | 3566 content = function() |
| 3567 %> | |
| 3568 <p> | |
| 3569 Returns the square root of <code>x</code>. | |
| 3570 (You can also use the expression <code>x^0.5</code> to compute this value.) | |
| 3571 </p> | |
| 3572 <% | |
| 3573 end | |
| 3574 } | |
| 3575 ["Math.tan"] = { | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3576 title = "Math.tan (x)" |
| 1669 | 3577 content = function() |
| 3578 %> | |
| 3579 <p> | |
| 3580 Returns the tangent of <code>x</code> (assumed to be in radians). | |
| 3581 </p> | |
| 3582 <% | |
| 3583 end | |
| 3584 } | |
| 3585 } | |
| 3586 } | |
| 1656 | 3587 } |
| 3588 } | |
| 3589 } | |
| 3590 | |
| 3591 | |
| 3592 return function() | |
| 3593 Io.stdout = Http.response.text_writer() | |
| 3594 %> | |
| 3595 <!doctype html> | |
| 3596 <html> | |
| 3597 <head> | |
| 3598 <% head() %> | |
| 3599 <title>Luan Reference Manual</title> | |
| 3600 <style> | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3601 p[list] { |
| 1656 | 3602 font-family: monospace; |
| 3603 margin-left: 40px; | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3604 } |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3605 p[list] span { |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3606 display: inline-block; |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3607 } |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3608 p[list=keywords] { |
| 1656 | 3609 max-width: 700px; |
| 3610 } | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3611 p[list=keywords] span { |
| 1656 | 3612 width: 100px; |
| 3613 } | |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3614 p[list=tokens] { |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3615 max-width: 400px; |
| 1716 | 3616 } |
|
1812
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3617 p[list=tokens] span { |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3618 width: 50px; |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3619 } |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3620 li[c_libs] li li > a { |
|
f44dcb3fedf7
docs - add code block
Franklin Schmidt <fschmidt@gmail.com>
parents:
1797
diff
changeset
|
3621 font-family: monospace; |
| 1716 | 3622 } |
| 1656 | 3623 </style> |
| 3624 </head> | |
| 3625 <body> | |
| 3626 <% docs_header() %> | |
| 3627 <div content> | |
| 3628 <h1><a href="manual.html">Luan Reference Manual</a></h1> | |
| 3629 <p small> | |
| 3630 Original copyright © 2015 Lua.org, PUC-Rio. | |
| 3631 Freely available under the terms of the | |
| 3632 <a href="http://www.lua.org/license.html">Lua license</a>. | |
| 3633 Modified for Luan. | |
| 3634 </p> | |
| 3635 <hr> | |
| 3636 <h2>Contents</h2> | |
| 3637 <div toc> | |
| 3638 <% show_toc(content) %> | |
| 3639 </div> | |
| 3640 <hr> | |
| 3641 <% show_content(content,2) %> | |
| 3642 </div> | |
| 3643 </body> | |
| 3644 </html> | |
| 3645 <% | |
| 3646 end |