From 640486e2740721732610121903d5a0e972967b27 Mon Sep 17 00:00:00 2001 From: qwjyh Date: Sat, 17 Aug 2024 17:39:36 +0200 Subject: [PATCH] add doc - lua-language-server --doc --doc_out_dir docs --- .gitignore | 1 + docs/doc.md | 2943 +++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 2944 insertions(+) create mode 100644 docs/doc.md diff --git a/.gitignore b/.gitignore index 140f8cf..7204fbb 100644 --- a/.gitignore +++ b/.gitignore @@ -1 +1,2 @@ *.so +docs/doc.json diff --git a/docs/doc.md b/docs/doc.md new file mode 100644 index 0000000..8a28871 --- /dev/null +++ b/docs/doc.md @@ -0,0 +1,2943 @@ +# LuaLS + + +--- + +# _G + + +A global variable (not a function) that holds the global environment (see [§2.2](command:extension.lua.doc?["en-us/54/manual.html/2.2"])). Lua itself does not use this variable; changing its value does not affect any environment, nor vice versa. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-_G"]) + + + +```lua +_G +``` + + +--- + +# _VERSION + + +A global variable (not a function) that holds a string containing the running Lua version. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-_VERSION"]) + + + +```lua +string +``` + + +--- + +# arg + + +Command-line arguments of Lua Standalone. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-arg"]) + + + +```lua +string[] +``` + + +--- + +# assert + + +Raises an error if the value of its argument v is false (i.e., `nil` or `false`); otherwise, returns all its arguments. In case of error, `message` is the error object; when absent, it defaults to `"assertion failed!"` + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-assert"]) + + +```lua +function assert(v?: , message?: any, ...any) + -> + 2. ...any +``` + + +--- + +# collectgarbage + + +This function is a generic interface to the garbage collector. It performs different functions according to its first argument, `opt`. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-collectgarbage"]) + + +```lua +opt: + -> "collect" -- Performs a full garbage-collection cycle. + | "stop" -- Stops automatic execution. + | "restart" -- Restarts automatic execution. + | "count" -- Returns the total memory in Kbytes. + | "step" -- Performs a garbage-collection step. + | "isrunning" -- Returns whether the collector is running. + | "incremental" -- Change the collector mode to incremental. + | "generational" -- Change the collector mode to generational. +``` + + +```lua +function collectgarbage(opt?: "collect"|"count"|"generational"|"incremental"|"isrunning"...(+3), ...any) + -> any +``` + + +--- + +# coroutine + + + + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-coroutine"]) + + + +```lua +coroutinelib +``` + + +--- + +# coroutine.close + + +Closes coroutine `co` , closing all its pending to-be-closed variables and putting the coroutine in a dead state. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-coroutine.close"]) + + +```lua +function coroutine.close(co: thread) + -> noerror: boolean + 2. errorobject: any +``` + + +--- + +# coroutine.create + + +Creates a new coroutine, with body `f`. `f` must be a function. Returns this new coroutine, an object with type `"thread"`. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-coroutine.create"]) + + +```lua +function coroutine.create(f: fun(...any):...unknown) + -> thread +``` + + +--- + +# coroutine.isyieldable + + +Returns true when the coroutine `co` can yield. The default for `co` is the running coroutine. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-coroutine.isyieldable"]) + + +```lua +function coroutine.isyieldable(co?: thread) + -> boolean +``` + + +--- + +# coroutine.resume + + +Starts or continues the execution of coroutine `co`. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-coroutine.resume"]) + + +```lua +function coroutine.resume(co: thread, val1?: any, ...any) + -> success: boolean + 2. ...any +``` + + +--- + +# coroutine.running + + +Returns the running coroutine plus a boolean, true when the running coroutine is the main one. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-coroutine.running"]) + + +```lua +function coroutine.running() + -> running: thread + 2. ismain: boolean +``` + + +--- + +# coroutine.status + + +Returns the status of coroutine `co`. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-coroutine.status"]) + + +```lua +return #1: + | "running" -- Is running. + | "suspended" -- Is suspended or not started. + | "normal" -- Is active but not running. + | "dead" -- Has finished or stopped with an error. +``` + + +```lua +function coroutine.status(co: thread) + -> "dead"|"normal"|"running"|"suspended" +``` + + +--- + +# coroutine.wrap + + +Creates a new coroutine, with body `f`; `f` must be a function. Returns a function that resumes the coroutine each time it is called. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-coroutine.wrap"]) + + +```lua +function coroutine.wrap(f: fun(...any):...unknown) + -> fun(...any):...unknown +``` + + +--- + +# coroutine.yield + + +Suspends the execution of the calling coroutine. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-coroutine.yield"]) + + +```lua +(async) function coroutine.yield(...any) + -> ...any +``` + + +--- + +# debug + + + + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-debug"]) + + + +```lua +debuglib +``` + + +--- + +# debug.debug + + +Enters an interactive mode with the user, running each string that the user enters. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-debug.debug"]) + + +```lua +function debug.debug() +``` + + +--- + +# debug.getfenv + + +Returns the environment of object `o` . + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-debug.getfenv"]) + + +```lua +function debug.getfenv(o: any) + -> table +``` + + +--- + +# debug.gethook + + +Returns the current hook settings of the thread. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-debug.gethook"]) + + +```lua +function debug.gethook(co?: thread) + -> hook: function + 2. mask: string + 3. count: integer +``` + + +--- + +# debug.getinfo + + +Returns a table with information about a function. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-debug.getinfo"]) + + +--- + +```lua +what: + +> "n" -- `name` and `namewhat` + +> "S" -- `source`, `short_src`, `linedefined`, `lastlinedefined`, and `what` + +> "l" -- `currentline` + +> "t" -- `istailcall` + +> "u" -- `nups`, `nparams`, and `isvararg` + +> "f" -- `func` + +> "r" -- `ftransfer` and `ntransfer` + +> "L" -- `activelines` +``` + + +```lua +function debug.getinfo(thread: thread, f: integer|fun(...any):...unknown, what?: string|"L"|"S"|"f"|"l"...(+4)) + -> debuginfo +``` + + +--- + +# debug.getlocal + + +Returns the name and the value of the local variable with index `local` of the function at level `f` of the stack. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-debug.getlocal"]) + + +```lua +function debug.getlocal(thread: thread, f: integer|fun(...any):...unknown, index: integer) + -> name: string + 2. value: any +``` + + +--- + +# debug.getmetatable + + +Returns the metatable of the given value. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-debug.getmetatable"]) + + +```lua +function debug.getmetatable(object: any) + -> metatable: table +``` + + +--- + +# debug.getregistry + + +Returns the registry table. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-debug.getregistry"]) + + +```lua +function debug.getregistry() + -> table +``` + + +--- + +# debug.getupvalue + + +Returns the name and the value of the upvalue with index `up` of the function. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-debug.getupvalue"]) + + +```lua +function debug.getupvalue(f: fun(...any):...unknown, up: integer) + -> name: string + 2. value: any +``` + + +--- + +# debug.getuservalue + + +Returns the `n`-th user value associated +to the userdata `u` plus a boolean, +`false` if the userdata does not have that value. + + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-debug.getuservalue"]) + + +```lua +function debug.getuservalue(u: userdata, n?: integer) + -> any + 2. boolean +``` + + +--- + +# debug.setcstacklimit + + +### **Deprecated in `Lua 5.4.2`** + +Sets a new limit for the C stack. This limit controls how deeply nested calls can go in Lua, with the intent of avoiding a stack overflow. + +In case of success, this function returns the old limit. In case of error, it returns `false`. + + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-debug.setcstacklimit"]) + + +```lua +function debug.setcstacklimit(limit: integer) + -> boolean|integer +``` + + +--- + +# debug.setfenv + + +Sets the environment of the given `object` to the given `table` . + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-debug.setfenv"]) + + +```lua +function debug.setfenv(object: , env: table) + -> object: +``` + + +--- + +# debug.sethook + + +Sets the given function as a hook. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-debug.sethook"]) + + +--- + +```lua +mask: + +> "c" -- Calls hook when Lua calls a function. + +> "r" -- Calls hook when Lua returns from a function. + +> "l" -- Calls hook when Lua enters a new line of code. +``` + + +```lua +function debug.sethook(thread: thread, hook: fun(...any):...unknown, mask: string|"c"|"l"|"r", count?: integer) +``` + + +--- + +# debug.setlocal + + +Assigns the `value` to the local variable with index `local` of the function at `level` of the stack. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-debug.setlocal"]) + + +```lua +function debug.setlocal(thread: thread, level: integer, index: integer, value: any) + -> name: string +``` + + +--- + +# debug.setmetatable + + +Sets the metatable for the given value to the given table (which can be `nil`). + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-debug.setmetatable"]) + + +```lua +function debug.setmetatable(value: , meta?: table) + -> value: +``` + + +--- + +# debug.setupvalue + + +Assigns the `value` to the upvalue with index `up` of the function. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-debug.setupvalue"]) + + +```lua +function debug.setupvalue(f: fun(...any):...unknown, up: integer, value: any) + -> name: string +``` + + +--- + +# debug.setuservalue + + +Sets the given `value` as +the `n`-th user value associated to the given `udata`. +`udata` must be a full userdata. + + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-debug.setuservalue"]) + + +```lua +function debug.setuservalue(udata: userdata, value: any, n?: integer) + -> udata: userdata +``` + + +--- + +# debug.traceback + + +Returns a string with a traceback of the call stack. The optional message string is appended at the beginning of the traceback. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-debug.traceback"]) + + +```lua +function debug.traceback(thread: thread, message?: any, level?: integer) + -> message: string +``` + + +--- + +# debug.upvalueid + + +Returns a unique identifier (as a light userdata) for the upvalue numbered `n` from the given function. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-debug.upvalueid"]) + + +```lua +function debug.upvalueid(f: fun(...any):...unknown, n: integer) + -> id: lightuserdata +``` + + +--- + +# debug.upvaluejoin + + +Make the `n1`-th upvalue of the Lua closure `f1` refer to the `n2`-th upvalue of the Lua closure `f2`. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-debug.upvaluejoin"]) + + +```lua +function debug.upvaluejoin(f1: fun(...any):...unknown, n1: integer, f2: fun(...any):...unknown, n2: integer) +``` + + +--- + +# dofile + + +Opens the named file and executes its content as a Lua chunk. When called without arguments, `dofile` executes the content of the standard input (`stdin`). Returns all values returned by the chunk. In case of errors, `dofile` propagates the error to its caller. (That is, `dofile` does not run in protected mode.) + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-dofile"]) + + +```lua +function dofile(filename?: string) + -> ...any +``` + + +--- + +# error + + +Terminates the last protected function called and returns message as the error object. + +Usually, `error` adds some information about the error position at the beginning of the message, if the message is a string. + + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-error"]) + + +```lua +function error(message: any, level?: integer) +``` + + +--- + +# getfenv + + +Returns the current environment in use by the function. `f` can be a Lua function or a number that specifies the function at that stack level. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-getfenv"]) + + +```lua +function getfenv(f?: integer|fun(...any):...unknown) + -> table +``` + + +--- + +# getmetatable + + +If object does not have a metatable, returns nil. Otherwise, if the object's metatable has a __metatable field, returns the associated value. Otherwise, returns the metatable of the given object. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-getmetatable"]) + + +```lua +function getmetatable(object: any) + -> metatable: table +``` + + +--- + +# io + + + + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-io"]) + + + +```lua +iolib +``` + + +--- + +# io.close + + +Close `file` or default output file. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-io.close"]) + + +```lua +exitcode: + | "exit" + | "signal" +``` + + +```lua +function io.close(file?: file*) + -> suc: boolean? + 2. exitcode: ("exit"|"signal")? + 3. code: integer? +``` + + +--- + +# io.flush + + +Saves any written data to default output file. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-io.flush"]) + + +```lua +function io.flush() +``` + + +--- + +# io.input + + +Sets `file` as the default input file. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-io.input"]) + + +```lua +function io.input(file: string|file*) +``` + + +--- + +# io.lines + + +------ +```lua +for c in io.lines(filename, ...) do + body +end +``` + + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-io.lines"]) + + +```lua +...(param): + | "n" -- Reads a numeral and returns it as number. + | "a" -- Reads the whole file. + -> "l" -- Reads the next line skipping the end of line. + | "L" -- Reads the next line keeping the end of line. +``` + + +```lua +function io.lines(filename?: string, ...string|integer|"L"|"a"|"l"...(+1)) + -> fun():any, ...unknown +``` + + +--- + +# io.open + + +Opens a file, in the mode specified in the string `mode`. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-io.open"]) + + +```lua +mode: + -> "r" -- Read mode. + | "w" -- Write mode. + | "a" -- Append mode. + | "r+" -- Update mode, all previous data is preserved. + | "w+" -- Update mode, all previous data is erased. + | "a+" -- Append update mode, previous data is preserved, writing is only allowed at the end of file. + | "rb" -- Read mode. (in binary mode.) + | "wb" -- Write mode. (in binary mode.) + | "ab" -- Append mode. (in binary mode.) + | "r+b" -- Update mode, all previous data is preserved. (in binary mode.) + | "w+b" -- Update mode, all previous data is erased. (in binary mode.) + | "a+b" -- Append update mode, previous data is preserved, writing is only allowed at the end of file. (in binary mode.) +``` + + +```lua +function io.open(filename: string, mode?: "a"|"a+"|"a+b"|"ab"|"r"...(+7)) + -> file*? + 2. errmsg: string? +``` + + +--- + +# io.output + + +Sets `file` as the default output file. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-io.output"]) + + +```lua +function io.output(file: string|file*) +``` + + +--- + +# io.popen + + +Starts program prog in a separated process. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-io.popen"]) + + +```lua +mode: + | "r" -- Read data from this program by `file`. + | "w" -- Write data to this program by `file`. +``` + + +```lua +function io.popen(prog: string, mode?: "r"|"w") + -> file*? + 2. errmsg: string? +``` + + +--- + +# io.read + + +Reads the `file`, according to the given formats, which specify what to read. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-io.read"]) + + +```lua +...(param): + | "n" -- Reads a numeral and returns it as number. + | "a" -- Reads the whole file. + -> "l" -- Reads the next line skipping the end of line. + | "L" -- Reads the next line keeping the end of line. +``` + + +```lua +function io.read(...string|integer|"L"|"a"|"l"...(+1)) + -> any + 2. ...any +``` + + +--- + +# io.tmpfile + + +In case of success, returns a handle for a temporary file. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-io.tmpfile"]) + + +```lua +function io.tmpfile() + -> file* +``` + + +--- + +# io.type + + +Checks whether `obj` is a valid file handle. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-io.type"]) + + +```lua +return #1: + | "file" -- Is an open file handle. + | "closed file" -- Is a closed file handle. + | `nil` -- Is not a file handle. +``` + + +```lua +function io.type(file: file*) + -> "closed file"|"file"|`nil` +``` + + +--- + +# io.write + + +Writes the value of each of its arguments to default output file. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-io.write"]) + + +```lua +function io.write(...any) + -> file* + 2. errmsg: string? +``` + + +--- + +# ipairs + + +Returns three values (an iterator function, the table `t`, and `0`) so that the construction +```lua + for i,v in ipairs(t) do body end +``` +will iterate over the key–value pairs `(1,t[1]), (2,t[2]), ...`, up to the first absent index. + + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-ipairs"]) + + +```lua +function ipairs(t: ) + -> fun(table: [], i?: integer):integer, + 2. + 3. i: integer +``` + + +--- + +# load + + +Loads a chunk. + +If `chunk` is a string, the chunk is this string. If `chunk` is a function, `load` calls it repeatedly to get the chunk pieces. Each call to `chunk` must return a string that concatenates with previous results. A return of an empty string, `nil`, or no value signals the end of the chunk. + + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-load"]) + + +```lua +mode: + | "b" -- Only binary chunks. + | "t" -- Only text chunks. + -> "bt" -- Both binary and text. +``` + + +```lua +function load(chunk: string|function, chunkname?: string, mode?: "b"|"bt"|"t", env?: table) + -> function? + 2. error_message: string? +``` + + +--- + +# loadfile + + +Loads a chunk from file `filename` or from the standard input, if no file name is given. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-loadfile"]) + + +```lua +mode: + | "b" -- Only binary chunks. + | "t" -- Only text chunks. + -> "bt" -- Both binary and text. +``` + + +```lua +function loadfile(filename?: string, mode?: "b"|"bt"|"t", env?: table) + -> function? + 2. error_message: string? +``` + + +--- + +# loadstring + + +Loads a chunk from the given string. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-loadstring"]) + + +```lua +function loadstring(text: string, chunkname?: string) + -> function? + 2. error_message: string? +``` + + +--- + +# math + + + + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-math"]) + + + +```lua +mathlib +``` + + +--- + +# math.abs + + +Returns the absolute value of `x`. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-math.abs"]) + + +```lua +function math.abs(x: ) + -> +``` + + +--- + +# math.acos + + +Returns the arc cosine of `x` (in radians). + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-math.acos"]) + + +```lua +function math.acos(x: number) + -> number +``` + + +--- + +# math.asin + + +Returns the arc sine of `x` (in radians). + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-math.asin"]) + + +```lua +function math.asin(x: number) + -> number +``` + + +--- + +# math.atan + + +Returns the arc tangent of `y/x` (in radians). + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-math.atan"]) + + +```lua +function math.atan(y: number, x?: number) + -> number +``` + + +--- + +# math.atan2 + + +Returns the arc tangent of `y/x` (in radians). + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-math.atan2"]) + + +```lua +function math.atan2(y: number, x: number) + -> number +``` + + +--- + +# math.ceil + + +Returns the smallest integral value larger than or equal to `x`. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-math.ceil"]) + + +```lua +function math.ceil(x: number) + -> integer +``` + + +--- + +# math.cos + + +Returns the cosine of `x` (assumed to be in radians). + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-math.cos"]) + + +```lua +function math.cos(x: number) + -> number +``` + + +--- + +# math.cosh + + +Returns the hyperbolic cosine of `x` (assumed to be in radians). + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-math.cosh"]) + + +```lua +function math.cosh(x: number) + -> number +``` + + +--- + +# math.deg + + +Converts the angle `x` from radians to degrees. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-math.deg"]) + + +```lua +function math.deg(x: number) + -> number +``` + + +--- + +# math.exp + + +Returns the value `e^x` (where `e` is the base of natural logarithms). + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-math.exp"]) + + +```lua +function math.exp(x: number) + -> number +``` + + +--- + +# math.floor + + +Returns the largest integral value smaller than or equal to `x`. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-math.floor"]) + + +```lua +function math.floor(x: number) + -> integer +``` + + +--- + +# math.fmod + + +Returns the remainder of the division of `x` by `y` that rounds the quotient towards zero. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-math.fmod"]) + + +```lua +function math.fmod(x: number, y: number) + -> number +``` + + +--- + +# math.frexp + + +Decompose `x` into tails and exponents. Returns `m` and `e` such that `x = m * (2 ^ e)`, `e` is an integer and the absolute value of `m` is in the range [0.5, 1) (or zero when `x` is zero). + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-math.frexp"]) + + +```lua +function math.frexp(x: number) + -> m: number + 2. e: number +``` + + +--- + +# math.ldexp + + +Returns `m * (2 ^ e)` . + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-math.ldexp"]) + + +```lua +function math.ldexp(m: number, e: number) + -> number +``` + + +--- + +# math.log + + +Returns the logarithm of `x` in the given base. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-math.log"]) + + +```lua +function math.log(x: number, base?: integer) + -> number +``` + + +--- + +# math.log10 + + +Returns the base-10 logarithm of x. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-math.log10"]) + + +```lua +function math.log10(x: number) + -> number +``` + + +--- + +# math.max + + +Returns the argument with the maximum value, according to the Lua operator `<`. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-math.max"]) + + +```lua +function math.max(x: , ...) + -> +``` + + +--- + +# math.min + + +Returns the argument with the minimum value, according to the Lua operator `<`. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-math.min"]) + + +```lua +function math.min(x: , ...) + -> +``` + + +--- + +# math.modf + + +Returns the integral part of `x` and the fractional part of `x`. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-math.modf"]) + + +```lua +function math.modf(x: number) + -> integer + 2. number +``` + + +--- + +# math.pow + + +Returns `x ^ y` . + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-math.pow"]) + + +```lua +function math.pow(x: number, y: number) + -> number +``` + + +--- + +# math.rad + + +Converts the angle `x` from degrees to radians. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-math.rad"]) + + +```lua +function math.rad(x: number) + -> number +``` + + +--- + +# math.random + + +* `math.random()`: Returns a float in the range [0,1). +* `math.random(n)`: Returns a integer in the range [1, n]. +* `math.random(m, n)`: Returns a integer in the range [m, n]. + + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-math.random"]) + + +```lua +function math.random(m: integer, n: integer) + -> integer +``` + + +--- + +# math.randomseed + + +* `math.randomseed(x, y)`: Concatenate `x` and `y` into a 128-bit `seed` to reinitialize the pseudo-random generator. +* `math.randomseed(x)`: Equate to `math.randomseed(x, 0)` . +* `math.randomseed()`: Generates a seed with a weak attempt for randomness. + + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-math.randomseed"]) + + +```lua +function math.randomseed(x?: integer, y?: integer) +``` + + +--- + +# math.sin + + +Returns the sine of `x` (assumed to be in radians). + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-math.sin"]) + + +```lua +function math.sin(x: number) + -> number +``` + + +--- + +# math.sinh + + +Returns the hyperbolic sine of `x` (assumed to be in radians). + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-math.sinh"]) + + +```lua +function math.sinh(x: number) + -> number +``` + + +--- + +# math.sqrt + + +Returns the square root of `x`. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-math.sqrt"]) + + +```lua +function math.sqrt(x: number) + -> number +``` + + +--- + +# math.tan + + +Returns the tangent of `x` (assumed to be in radians). + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-math.tan"]) + + +```lua +function math.tan(x: number) + -> number +``` + + +--- + +# math.tanh + + +Returns the hyperbolic tangent of `x` (assumed to be in radians). + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-math.tanh"]) + + +```lua +function math.tanh(x: number) + -> number +``` + + +--- + +# math.tointeger + + +Miss locale + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-math.tointeger"]) + + +```lua +function math.tointeger(x: any) + -> integer? +``` + + +--- + +# math.type + + +Miss locale + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-math.type"]) + + +```lua +return #1: + | "integer" + | "float" + | 'nil' +``` + + +```lua +function math.type(x: any) + -> "float"|"integer"|'nil' +``` + + +--- + +# math.ult + + +Miss locale + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-math.ult"]) + + +```lua +function math.ult(m: integer, n: integer) + -> boolean +``` + + +--- + +# module + + +Creates a module. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-module"]) + + +```lua +function module(name: string, ...any) +``` + + +--- + +# newproxy + + +```lua +function newproxy(proxy: boolean|table|userdata) + -> userdata +``` + + +--- + +# next + + +Allows a program to traverse all fields of a table. Its first argument is a table and its second argument is an index in this table. A call to `next` returns the next index of the table and its associated value. When called with `nil` as its second argument, `next` returns an initial index and its associated value. When called with the last index, or with `nil` in an empty table, `next` returns `nil`. If the second argument is absent, then it is interpreted as `nil`. In particular, you can use `next(t)` to check whether a table is empty. + +The order in which the indices are enumerated is not specified, *even for numeric indices*. (To traverse a table in numerical order, use a numerical `for`.) + +The behavior of `next` is undefined if, during the traversal, you assign any value to a non-existent field in the table. You may however modify existing fields. In particular, you may set existing fields to nil. + + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-next"]) + + +```lua +function next(table: table<, >, index?: ) + -> ? + 2. ? +``` + + +--- + +# os + + + + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-os"]) + + + +```lua +oslib +``` + + +--- + +# os.clock + + +Returns an approximation of the amount in seconds of CPU time used by the program. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-os.clock"]) + + +```lua +function os.clock() + -> number +``` + + +--- + +# os.date + + +Returns a string or a table containing date and time, formatted according to the given string `format`. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-os.date"]) + + +```lua +function os.date(format?: string, time?: integer) + -> string|osdate +``` + + +--- + +# os.difftime + + +Returns the difference, in seconds, from time `t1` to time `t2`. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-os.difftime"]) + + +```lua +function os.difftime(t2: integer, t1: integer) + -> integer +``` + + +--- + +# os.execute + + +Passes `command` to be executed by an operating system shell. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-os.execute"]) + + +```lua +exitcode: + | "exit" + | "signal" +``` + + +```lua +function os.execute(command?: string) + -> suc: boolean? + 2. exitcode: ("exit"|"signal")? + 3. code: integer? +``` + + +--- + +# os.exit + + +Calls the ISO C function `exit` to terminate the host program. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-os.exit"]) + + +```lua +function os.exit(code?: boolean|integer, close?: boolean) +``` + + +--- + +# os.getenv + + +Returns the value of the process environment variable `varname`. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-os.getenv"]) + + +```lua +function os.getenv(varname: string) + -> string? +``` + + +--- + +# os.remove + + +Deletes the file with the given name. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-os.remove"]) + + +```lua +function os.remove(filename: string) + -> suc: boolean + 2. errmsg: string? +``` + + +--- + +# os.rename + + +Renames the file or directory named `oldname` to `newname`. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-os.rename"]) + + +```lua +function os.rename(oldname: string, newname: string) + -> suc: boolean + 2. errmsg: string? +``` + + +--- + +# os.setlocale + + +Sets the current locale of the program. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-os.setlocale"]) + + +```lua +category: + -> "all" + | "collate" + | "ctype" + | "monetary" + | "numeric" + | "time" +``` + + +```lua +function os.setlocale(locale: string|nil, category?: "all"|"collate"|"ctype"|"monetary"|"numeric"...(+1)) + -> localecategory: string +``` + + +--- + +# os.time + + +Returns the current time when called without arguments, or a time representing the local date and time specified by the given table. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-os.time"]) + + +```lua +function os.time(date?: osdateparam) + -> integer +``` + + +--- + +# os.tmpname + + +Returns a string with a file name that can be used for a temporary file. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-os.tmpname"]) + + +```lua +function os.tmpname() + -> string +``` + + +--- + +# package + + + + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-package"]) + + + +```lua +packagelib +``` + + +--- + +# package.config + + +A string describing some compile-time configurations for packages. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-package.config"]) + + + +```lua +string +``` + + +--- + +# package.loaders + + +A table used by `require` to control how to load modules. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-package.loaders"]) + + + +```lua +table +``` + + +--- + +# package.loadlib + + +Dynamically links the host program with the C library `libname`. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-package.loadlib"]) + + +```lua +function package.loadlib(libname: string, funcname: string) + -> any +``` + + +--- + +# package.searchers + + +A table used by `require` to control how to load modules. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-package.searchers"]) + + + +```lua +table +``` + + +--- + +# package.searchpath + + +Searches for the given `name` in the given `path`. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-package.searchpath"]) + + +```lua +function package.searchpath(name: string, path: string, sep?: string, rep?: string) + -> filename: string? + 2. errmsg: string? +``` + + +--- + +# package.seeall + + +Sets a metatable for `module` with its `__index` field referring to the global environment, so that this module inherits values from the global environment. To be used as an option to function `module` . + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-package.seeall"]) + + +```lua +function package.seeall(module: table) +``` + + +--- + +# pairs + + +If `t` has a metamethod `__pairs`, calls it with t as argument and returns the first three results from the call. + +Otherwise, returns three values: the [next](command:extension.lua.doc?["en-us/54/manual.html/pdf-next"]) function, the table `t`, and `nil`, so that the construction +```lua + for k,v in pairs(t) do body end +``` +will iterate over all key–value pairs of table `t`. + +See function [next](command:extension.lua.doc?["en-us/54/manual.html/pdf-next"]) for the caveats of modifying the table during its traversal. + + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-pairs"]) + + +```lua +function pairs(t: ) + -> fun(table: table<, >, index?: ):, + 2. +``` + + +--- + +# pcall + + +Calls the function `f` with the given arguments in *protected mode*. This means that any error inside `f` is not propagated; instead, `pcall` catches the error and returns a status code. Its first result is the status code (a boolean), which is true if the call succeeds without errors. In such case, `pcall` also returns all results from the call, after this first result. In case of any error, `pcall` returns `false` plus the error object. + + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-pcall"]) + + +```lua +function pcall(f: fun(...any):...unknown, arg1?: any, ...any) + -> success: boolean + 2. result: any + 3. ...any +``` + + +--- + +# print + + +Receives any number of arguments and prints their values to `stdout`, converting each argument to a string following the same rules of [tostring](command:extension.lua.doc?["en-us/54/manual.html/pdf-tostring"]). +The function print is not intended for formatted output, but only as a quick way to show a value, for instance for debugging. For complete control over the output, use [string.format](command:extension.lua.doc?["en-us/54/manual.html/pdf-string.format"]) and [io.write](command:extension.lua.doc?["en-us/54/manual.html/pdf-io.write"]). + + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-print"]) + + +```lua +function print(...any) +``` + + +--- + +# rawequal + + +Checks whether v1 is equal to v2, without invoking the `__eq` metamethod. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-rawequal"]) + + +```lua +function rawequal(v1: any, v2: any) + -> boolean +``` + + +--- + +# rawget + + +Gets the real value of `table[index]`, without invoking the `__index` metamethod. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-rawget"]) + + +```lua +function rawget(table: table, index: any) + -> any +``` + + +--- + +# rawlen + + +Returns the length of the object `v`, without invoking the `__len` metamethod. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-rawlen"]) + + +```lua +function rawlen(v: string|table) + -> len: integer +``` + + +--- + +# rawset + + +Sets the real value of `table[index]` to `value`, without using the `__newindex` metavalue. `table` must be a table, `index` any value different from `nil` and `NaN`, and `value` any Lua value. +This function returns `table`. + + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-rawset"]) + + +```lua +function rawset(table: table, index: any, value: any) + -> table +``` + + +--- + +# require + + +Loads the given module, returns any value returned by the searcher(`true` when `nil`). Besides that value, also returns as a second result the loader data returned by the searcher, which indicates how `require` found the module. (For instance, if the module came from a file, this loader data is the file path.) + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-require"]) + + +```lua +function require(modname: string) + -> unknown + 2. loaderdata: unknown +``` + + +--- + +# select + + +If `index` is a number, returns all arguments after argument number `index`; a negative number indexes from the end (`-1` is the last argument). Otherwise, `index` must be the string `"#"`, and `select` returns the total number of extra arguments it received. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-select"]) + + +```lua +index: + | "#" +``` + + +```lua +function select(index: integer|"#", ...any) + -> any +``` + + +--- + +# setfenv + + +Sets the environment to be used by the given function. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-setfenv"]) + + +```lua +function setfenv(f: fun(...any):...integer|unknown, table: table) + -> function +``` + + +--- + +# setmetatable + + +Sets the metatable for the given table. If `metatable` is `nil`, removes the metatable of the given table. If the original metatable has a `__metatable` field, raises an error. + +This function returns `table`. + +To change the metatable of other types from Lua code, you must use the debug library ([§6.10](command:extension.lua.doc?["en-us/54/manual.html/6.10"])). + + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-setmetatable"]) + + +```lua +function setmetatable(table: table, metatable?: table|metatable) + -> table +``` + + +--- + +# string + + + + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-string"]) + + + +```lua +stringlib +``` + + +--- + +# string.byte + + +Returns the internal numeric codes of the characters `s[i], s[i+1], ..., s[j]`. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-string.byte"]) + + +```lua +function string.byte(s: string|number, i?: integer, j?: integer) + -> ...integer +``` + + +--- + +# string.char + + +Returns a string with length equal to the number of arguments, in which each character has the internal numeric code equal to its corresponding argument. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-string.char"]) + + +```lua +function string.char(byte: integer, ...integer) + -> string +``` + + +--- + +# string.dump + + +Returns a string containing a binary representation (a *binary chunk*) of the given function. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-string.dump"]) + + +```lua +function string.dump(f: fun(...any):...unknown, strip?: boolean) + -> string +``` + + +--- + +# string.find + + +Looks for the first match of `pattern` (see [§6.4.1](command:extension.lua.doc?["en-us/54/manual.html/6.4.1"])) in the string. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-string.find"]) + +@*return* `start` + +@*return* `end` + +@*return* `...` — captured + + +```lua +function string.find(s: string|number, pattern: string|number, init?: integer, plain?: boolean) + -> start: integer|nil + 2. end: integer|nil + 3. ...any +``` + + +--- + +# string.format + + +Returns a formatted version of its variable number of arguments following the description given in its first argument. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-string.format"]) + + +```lua +function string.format(s: string|number, ...any) + -> string +``` + + +--- + +# string.gmatch + + +Returns an iterator function that, each time it is called, returns the next captures from `pattern` (see [§6.4.1](command:extension.lua.doc?["en-us/54/manual.html/6.4.1"])) over the string s. + +As an example, the following loop will iterate over all the words from string s, printing one per line: +```lua + s = +"hello world from Lua" + for w in string.gmatch(s, "%a+") do + print(w) + end +``` + + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-string.gmatch"]) + + +```lua +function string.gmatch(s: string|number, pattern: string|number, init?: integer) + -> fun():string, ...unknown +``` + + +--- + +# string.gsub + + +Returns a copy of s in which all (or the first `n`, if given) occurrences of the `pattern` (see [§6.4.1](command:extension.lua.doc?["en-us/54/manual.html/6.4.1"])) have been replaced by a replacement string specified by `repl`. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-string.gsub"]) + + +```lua +function string.gsub(s: string|number, pattern: string|number, repl: string|number|function|table, n?: integer) + -> string + 2. count: integer +``` + + +--- + +# string.len + + +Returns its length. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-string.len"]) + + +```lua +function string.len(s: string|number) + -> integer +``` + + +--- + +# string.lower + + +Returns a copy of this string with all uppercase letters changed to lowercase. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-string.lower"]) + + +```lua +function string.lower(s: string|number) + -> string +``` + + +--- + +# string.match + + +Looks for the first match of `pattern` (see [§6.4.1](command:extension.lua.doc?["en-us/54/manual.html/6.4.1"])) in the string. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-string.match"]) + + +```lua +function string.match(s: string|number, pattern: string|number, init?: integer) + -> ...any +``` + + +--- + +# string.pack + + +Returns a binary string containing the values `v1`, `v2`, etc. packed (that is, serialized in binary form) according to the format string `fmt` (see [§6.4.2](command:extension.lua.doc?["en-us/54/manual.html/6.4.2"])) . + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-string.pack"]) + + +```lua +function string.pack(fmt: string, v1: string|number, v2?: string|number, ...string|number) + -> binary: string +``` + + +--- + +# string.packsize + + +Returns the size of a string resulting from `string.pack` with the given format string `fmt` (see [§6.4.2](command:extension.lua.doc?["en-us/54/manual.html/6.4.2"])) . + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-string.packsize"]) + + +```lua +function string.packsize(fmt: string) + -> integer +``` + + +--- + +# string.rep + + +Returns a string that is the concatenation of `n` copies of the string `s` separated by the string `sep`. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-string.rep"]) + + +```lua +function string.rep(s: string|number, n: integer, sep?: string|number) + -> string +``` + + +--- + +# string.reverse + + +Returns a string that is the string `s` reversed. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-string.reverse"]) + + +```lua +function string.reverse(s: string|number) + -> string +``` + + +--- + +# string.sub + + +Returns the substring of the string that starts at `i` and continues until `j`. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-string.sub"]) + + +```lua +function string.sub(s: string|number, i: integer, j?: integer) + -> string +``` + + +--- + +# string.unpack + + +Returns the values packed in string according to the format string `fmt` (see [§6.4.2](command:extension.lua.doc?["en-us/54/manual.html/6.4.2"])) . + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-string.unpack"]) + + +```lua +function string.unpack(fmt: string, s: string, pos?: integer) + -> ...any + 2. offset: integer +``` + + +--- + +# string.upper + + +Returns a copy of this string with all lowercase letters changed to uppercase. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-string.upper"]) + + +```lua +function string.upper(s: string|number) + -> string +``` + + +--- + +# table + + + + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-table"]) + + + +```lua +tablelib +``` + + +--- + +# table.concat + + +Given a list where all elements are strings or numbers, returns the string `list[i]..sep..list[i+1] ··· sep..list[j]`. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-table.concat"]) + + +```lua +function table.concat(list: table, sep?: string, i?: integer, j?: integer) + -> string +``` + + +--- + +# table.foreach + + +Executes the given f over all elements of table. For each element, f is called with the index and respective value as arguments. If f returns a non-nil value, then the loop is broken, and this value is returned as the final value of foreach. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-table.foreach"]) + + +```lua +function table.foreach(list: any, callback: fun(key: string, value: any):|nil) + -> |nil +``` + + +--- + +# table.foreachi + + +Executes the given f over the numerical indices of table. For each index, f is called with the index and respective value as arguments. Indices are visited in sequential order, from 1 to n, where n is the size of the table. If f returns a non-nil value, then the loop is broken and this value is returned as the result of foreachi. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-table.foreachi"]) + + +```lua +function table.foreachi(list: any, callback: fun(key: string, value: any):|nil) + -> |nil +``` + + +--- + +# table.getn + + +Returns the number of elements in the table. This function is equivalent to `#list`. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-table.getn"]) + + +```lua +function table.getn(list: []) + -> integer +``` + + +--- + +# table.insert + + +Inserts element `value` at position `pos` in `list`. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-table.insert"]) + + +```lua +function table.insert(list: table, pos: integer, value: any) +``` + + +--- + +# table.maxn + + +Returns the largest positive numerical index of the given table, or zero if the table has no positive numerical indices. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-table.maxn"]) + + +```lua +function table.maxn(table: table) + -> integer +``` + + +--- + +# table.move + + +Moves elements from table `a1` to table `a2`. +```lua +a2[t],··· = +a1[f],···,a1[e] +return a2 +``` + + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-table.move"]) + + +```lua +function table.move(a1: table, f: integer, e: integer, t: integer, a2?: table) + -> a2: table +``` + + +--- + +# table.pack + + +Returns a new table with all arguments stored into keys `1`, `2`, etc. and with a field `"n"` with the total number of arguments. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-table.pack"]) + + +```lua +function table.pack(...any) + -> table +``` + + +--- + +# table.remove + + +Removes from `list` the element at position `pos`, returning the value of the removed element. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-table.remove"]) + + +```lua +function table.remove(list: table, pos?: integer) + -> any +``` + + +--- + +# table.sort + + +Sorts list elements in a given order, *in-place*, from `list[1]` to `list[#list]`. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-table.sort"]) + + +```lua +function table.sort(list: [], comp?: fun(a: , b: ):boolean) +``` + + +--- + +# table.unpack + + +Returns the elements from the given list. This function is equivalent to +```lua + return list[i], list[i+1], ···, list[j] +``` +By default, `i` is `1` and `j` is `#list`. + + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-table.unpack"]) + + +```lua +function table.unpack(list: [], i?: integer, j?: integer) + -> ... +``` + + +--- + +# tonumber + + +When called with no `base`, `tonumber` tries to convert its argument to a number. If the argument is already a number or a string convertible to a number, then `tonumber` returns this number; otherwise, it returns `fail`. + +The conversion of strings can result in integers or floats, according to the lexical conventions of Lua (see [§3.1](command:extension.lua.doc?["en-us/54/manual.html/3.1"])). The string may have leading and trailing spaces and a sign. + + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-tonumber"]) + + +```lua +function tonumber(e: any) + -> number? +``` + + +--- + +# tostring + + +Receives a value of any type and converts it to a string in a human-readable format. + +If the metatable of `v` has a `__tostring` field, then `tostring` calls the corresponding value with `v` as argument, and uses the result of the call as its result. Otherwise, if the metatable of `v` has a `__name` field with a string value, `tostring` may use that string in its final result. + +For complete control of how numbers are converted, use [string.format](command:extension.lua.doc?["en-us/54/manual.html/pdf-string.format"]). + + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-tostring"]) + + +```lua +function tostring(v: any) + -> string +``` + + +--- + +# type + + +Returns the type of its only argument, coded as a string. The possible results of this function are `"nil"` (a string, not the value `nil`), `"number"`, `"string"`, `"boolean"`, `"table"`, `"function"`, `"thread"`, and `"userdata"`. + + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-type"]) + + +```lua +type: + | "nil" + | "number" + | "string" + | "boolean" + | "table" + | "function" + | "thread" + | "userdata" +``` + + +```lua +function type(v: any) + -> type: "boolean"|"function"|"nil"|"number"|"string"...(+3) +``` + + +--- + +# uname + +## machine + + +```lua +string +``` + +## release + + +```lua +string +``` + +## sysname + + +```lua +string +``` + +## version + + +```lua +string +``` + + +--- + +# unamelib + +## numid + + +```lua +function unamelib.numid(x: integer) + -> integer +``` + +## plusone + + +```lua +function unamelib.plusone(x: integer) + -> integer +``` + +## uname + + +```lua +function unamelib.uname() + -> uname +``` + + +--- + +# unpack + + +Returns the elements from the given `list`. This function is equivalent to +```lua + return list[i], list[i+1], ···, list[j] +``` + + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-unpack"]) + + +```lua +function unpack(list: [], i?: integer, j?: integer) + -> ... +``` + + +```lua +function unpack(list: { [1]: , [2]: , [3]: , [4]: , [5]: , [6]: , [7]: , [8]: , [9]: }) + -> + 2. + 3. + 4. + 5. + 6. + 7. + 8. + 9. +``` + + +--- + +# utf8 + + + + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-utf8"]) + + + +```lua +utf8lib +``` + + +--- + +# utf8.char + + +Receives zero or more integers, converts each one to its corresponding UTF-8 byte sequence and returns a string with the concatenation of all these sequences. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-utf8.char"]) + + +```lua +function utf8.char(code: integer, ...integer) + -> string +``` + + +--- + +# utf8.codepoint + + +Returns the codepoints (as integers) from all characters in `s` that start between byte position `i` and `j` (both included). + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-utf8.codepoint"]) + + +```lua +function utf8.codepoint(s: string, i?: integer, j?: integer, lax?: boolean) + -> code: integer + 2. ...integer +``` + + +--- + +# utf8.codes + + +Returns values so that the construction +```lua +for p, c in utf8.codes(s) do + body +end +``` +will iterate over all UTF-8 characters in string s, with p being the position (in bytes) and c the code point of each character. It raises an error if it meets any invalid byte sequence. + + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-utf8.codes"]) + + +```lua +function utf8.codes(s: string, lax?: boolean) + -> fun(s: string, p: integer):integer, integer +``` + + +--- + +# utf8.len + + +Returns the number of UTF-8 characters in string `s` that start between positions `i` and `j` (both inclusive). + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-utf8.len"]) + + +```lua +function utf8.len(s: string, i?: integer, j?: integer, lax?: boolean) + -> integer? + 2. errpos: integer? +``` + + +--- + +# utf8.offset + + +Returns the position (in bytes) where the encoding of the `n`-th character of `s` (counting from position `i`) starts. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-utf8.offset"]) + + +```lua +function utf8.offset(s: string, n: integer, i?: integer) + -> p: integer +``` + + +--- + +# warn + + +Emits a warning with a message composed by the concatenation of all its arguments (which should be strings). + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-warn"]) + + +```lua +function warn(message: string, ...any) +``` + + +--- + +# xpcall + + +Calls function `f` with the given arguments in protected mode with a new message handler. + +[View documents](command:extension.lua.doc?["en-us/54/manual.html/pdf-xpcall"]) + + +```lua +function xpcall(f: fun(...any):...unknown, msgh: function, arg1?: any, ...any) + -> success: boolean + 2. result: any + 3. ...any +``` \ No newline at end of file