Luau

https://luau.org/
Admin
Luau is a small, fast, and embeddable programming language based on Lua, featuring a gradual type...
Tokens:82,685
Snippets:1,254
Trust Score:8.1
Update:2 months ago
Show doc for...
Tokens:
Raw
### Type Annotations

Source: https://luau.org/typecheck

Examples of applying type annotations to variables, functions, and custom table types.

```luau
-- Variable annotations
local age: number = 25
local names: {string} = {"Alice", "Bob"}
  

-- Function annotations
function greet(name: string): string
return "Hello, " .. name
end
  

-- Table type annotations
type Person = {
name: string,
age: number,
email: string?
}
  

local user: Person = {
name = "Alice",
age = 30
}
  

print(greet(user.name))
```

--------------------------------

### Define Type Annotations

Source: https://luau.org/news/2020-01-16-luau-type-checking-beta

Examples of annotating variables, function parameters, return types, type aliases, and using the as keyword.

```luau
local foo: number = 55
  

function is_empty(param: string) => boolean
return 0 == param:len()
end
  

type Point = {x: number, y: number}
  

local baz = quux as number
```

--------------------------------

### Parser recovery example

Source: https://luau.org/news/2021-09-30-luau-recap-september-2021

Code snippet demonstrating a structure that previously caused parser recovery issues.

```luau
local x = y
(expr)[smth] = z
```

--------------------------------

### Userdata Direct Access Callback Type

Source: https://luau.org/api

Defines the signature for get and set metamethod callbacks.

```c
typedef void (*lua_UserdataDirectAccess)(lua_State* L, void* data, int atom, uint16_t* cachedslot, int utag);
```

--------------------------------

### Match pattern in string

Source: https://luau.org/library

Returns the first match or captures found in the string starting from the specified index.

```lua
function string.match(s: string, p: string, init: number?): ...string?
```

--------------------------------

### Initialize All Libraries

Source: https://luau.org/api

Initializes all the libraries.

```c
void luaL_openlibs(lua_State* L);
```

--------------------------------

### Get UTF8 byte offset

Source: https://luau.org/library

Returns the byte offset of the Unicode codepoint n in the string, starting from byte position i.

```lua
function utf8.offset(s: string, n: number, i: number?): number?
```

--------------------------------

### Initialize OS Library

Source: https://luau.org/api

Initializes the os library.

```c
#define LUA_OSLIBNAME "os"
int luaopen_os(lua_State* L);
```

--------------------------------

### lua_getglobal

Source: https://luau.org/api

Gets a global variable.

```APIDOC
## int lua_getglobal(lua_State* L, const char* s)

### Description
Same as lua_getfield when called on the global table value (LUA_GLOBALSINDEX). Return value is the type tag of the value (nil if it was not found).
```

--------------------------------

### Registering a callback event handler

Source: https://luau.org/news/2021-09-30-luau-recap-september-2021

Example of a callback where bidirectional typechecking helps infer the type of the 'other' parameter.

```luau
part.Touched:Connect(function(other)
-- ...
end)
```

--------------------------------

### lua_getfenv

Source: https://luau.org/api

Gets the environment table of the value at index.

```APIDOC
## void lua_getfenv(lua_State* L, int idx)

### Description
Gets the environment table of the value at index and places it on top of the stack. Environment tables can be associated with functions and threads. For values of other types, result is nil.
```

--------------------------------

### Initialize String Library

Source: https://luau.org/api

Initializes the string library.

```c
#define LUA_STRLIBNAME "string"
int luaopen_string(lua_State* L);
```

--------------------------------

### lua_getuserdatadtor

Source: https://luau.org/api

Gets the destructor function for a specific tag.

```APIDOC
## lua_Destructor lua_getuserdatadtor(lua_State* L, int tag)

### Description
Gets the destructor function associated with userdata values with the specified tag.
```

--------------------------------

### Initialize Class Library

Source: https://luau.org/api

Initializes the class library (Experimental).

```c
#define LUA_CLASSLIBNAME "class"
int luaopen_class(lua_State* L);
```

--------------------------------

### Using __len metamethod and rawlen

Source: https://luau.org/news/2022-08-29-luau-recap-august-2022

Tables now respect the __len metamethod, and rawlen provides a way to get the length of a table without triggering metamethods.

```luau
local t = setmetatable({}, {
	__len = function()
		return 10
	end
})
print(#t) -- 10
print(rawlen(t)) -- 0
```

--------------------------------

### Initialize Bit32 Library

Source: https://luau.org/api

Initializes the bit32 library.

```c
#define LUA_BITLIBNAME "bit32"
int luaopen_bit32(lua_State* L);
```

--------------------------------

### lua_isthreadreset

Source: https://luau.org/api

Checks if a thread has been reset or has not started executing.

```APIDOC
## lua_isthreadreset(lua_State* L)

### Description
Check if a thread has been reset or has not started executing any code yet.
```

--------------------------------

### Initialize Math Library

Source: https://luau.org/api

Initializes the math library.

```c
#define LUA_MATHLIBNAME "math"
int luaopen_math(lua_State* L);
```

--------------------------------

### lua_totalbytes

Source: https://luau.org/api

Gets the number of bytes associated with a memory category.

```APIDOC
## size_t lua_totalbytes(lua_State* L, int category)

### Description
Gets the number of bytes associated with a memory category. When category is -1, the total amount of bytes in all categories is returned.
```

--------------------------------

### void luaL_openlibs(lua_State* L)

Source: https://luau.org/api

Initializes all available Luau builtin libraries at once.

```APIDOC
## void luaL_openlibs(lua_State* L)

### Description
Initializes all builtin libraries for the given Luau state.
```

--------------------------------

### Get table length

Source: https://luau.org/library

Deprecated; use the # operator instead.

```Luau
function table.getn<V>(t: {V}): number
```

--------------------------------

### lua_getupvalue

Source: https://luau.org/api

Gets the value of the nth upvalue of the function at the specified index.

```APIDOC
## const char* lua_getupvalue(lua_State* L, int funcindex, int n)

### Description
Gets the value of the nth upvalue of the function at the specified index and places it on top of the stack.
```

--------------------------------

### Initialize Base Library

Source: https://luau.org/api

Initializes the set of global functions.

```c
int luaopen_base(lua_State* L);
```

--------------------------------

### Get stack size

Source: https://luau.org/api

Returns the current number of items on the stack.

```c
int lua_gettop(lua_State* L);
```

--------------------------------

### Create a new Luau VM with default allocator

Source: https://luau.org/api

Initializes a new Luau VM instance using the default system realloc and free functions.

```c
lua_State* luaL_newstate(void);
```

--------------------------------

### Instantiate type packs with argument names

Source: https://luau.org/news/2022-08-29-luau-recap-august-2022

Demonstrates the syntax for type instantiation that previously triggered a parser bug.

```luau
type Foo<T> = T
type Bar = Foo<(a: number, b: string)>
```

--------------------------------

### Get buffer length

Source: https://luau.org/library

Returns the total size of the buffer in bytes.

```lua
function buffer.len(b: buffer): number
```

--------------------------------

### TableOperations Lint Check

Source: https://luau.org/news/2021-07-30-luau-recap-july-2021

Examples of common correctness and performance issues with table.insert and table.remove detected by the new linter.

```luau
local t = { 1, 2, 3 }
  

-- table.insert will insert the value before the last element, which is likely a bug; consider removing the second argument or wrap it in parentheses to silence
table.insert(t, #t, 42)
  

-- table.insert will append the value to the table; consider removing the second argument for efficiency
table.insert(t, #t + 1, 42)
  

-- table.insert uses index 0 but arrays are 1-based; did you mean 1 instead?
table.insert(t, 0, 42)
  

-- table.remove uses index 0 but arrays are 1-based; did you mean 1 instead?
table.remove(t, 0)
  

-- table.remove will remove the value before the last element, which is likely a bug; consider removing the second argument or wrap it in parentheses to silence
table.remove(t, #t - 1)
  

-- table.insert may change behavior if the call returns more than one result; consider adding parentheses around second argument
table.insert(t, string.find("hello", "h"))
```

--------------------------------

### Initialize Debug Library

Source: https://luau.org/api

Initializes the debug library.

```c
#define LUA_DBLIBNAME "debug"
int luaopen_debug(lua_State* L);
```

--------------------------------

### Get string length

Source: https://luau.org/library

Returns the total number of bytes in the string.

```lua
function string.len(s: string): number
```

--------------------------------

### Initialize Integer Library

Source: https://luau.org/api

Initializes the integer library.

```c
#define LUA_INTLIBNAME "integer"
int luaopen_integer(lua_State* L);
```

--------------------------------

### Get object type

Source: https://luau.org/library

Returns the primitive type of an object as a string.

```luau
function type(obj: any): string
```

--------------------------------

### Initialize Buffer Library

Source: https://luau.org/api

Initializes the buffer library.

```c
#define LUA_BUFFERLIBNAME "buffer"
int luaopen_buffer(lua_State* L);
```

--------------------------------

### lua_getargument

Source: https://luau.org/api

Gets the value of the nth argument of the function at the specified call frame.

```APIDOC
## int lua_getargument(lua_State* L, int level, int n)

### Description
Gets the value of the nth argument of the function at the specified call frame. Returns 1 on success with the argument value placed on top of the stack.
```

--------------------------------

### Iterate table with lua_next

Source: https://luau.org/api

Iterates through table elements by pushing the next key and value to the stack. Requires nil as the starting key.

```c
int lua_next(lua_State* L, int idx);
```

```c
// in this table iteration example, table is initially at stack index -1
lua_pushnil(L);


while (lua_next(L, -2) != 0)
{
    // value at stack index -2 is now the key
    // value at stack index -1 is now the value


    lua_pop(L, 1); // remove the value, but keep the key
}


// the table we started with is at -1 index again
```

--------------------------------

### Get type name from tag

Source: https://luau.org/api

Returns the string representation of a type tag.

```c
const char* lua_typename(lua_State* L, int tp);
```

--------------------------------

### Initialize Table Library

Source: https://luau.org/api

Initializes the table library.

```c
#define LUA_TABLIBNAME "table"
int luaopen_table(lua_State* L);
```

--------------------------------

### Create Table

Source: https://luau.org/api

Creates a new table and pushes it onto the stack, optionally reserving space for array and hash elements.

```c
void lua_createtable(lua_State* L, int narr, int nrec);
```

```c
void lua_newtable(lua_State* L);
#define lua_newtable(L) // Implemented as a macro
```

--------------------------------

### lua_getlocal

Source: https://luau.org/api

Gets the value of the nth active local of the function at the specified call frame.

```APIDOC
## const char* lua_getlocal(lua_State* L, int level, int n)

### Description
Gets the value of the nth active local of the function at the specified call frame. Returns the name of the local on success with the local value placed on top of the stack.
```

--------------------------------

### Initialize UTF8 Library

Source: https://luau.org/api

Initializes the utf8 library.

```c
#define LUA_UTF8LIBNAME "utf8"
int luaopen_utf8(lua_State* L);
```

--------------------------------

### Get Luau upvalue

Source: https://luau.org/api

Retrieves the value of the nth upvalue of the function at the specified index.

```c
const char* lua_getupvalue(lua_State* L, int funcindex, int n);
```

--------------------------------

### Get coroutine status

Source: https://luau.org/api

Returns the status of a coroutine relative to the currently executing thread.

```c
int lua_costatus(lua_State* L, lua_State* co);
```

--------------------------------

### Initialize Vector Library

Source: https://luau.org/api

Initializes the vector library.

```c
#define LUA_VECLIBNAME "vector"
int luaopen_vector(lua_State* L);
```

--------------------------------

### Get Userdata Tag

Source: https://luau.org/api

Retrieves the tag value associated with the userdata at the given index.

```c
int lua_userdatatag(lua_State* L, int idx);
```

--------------------------------

### Create a new Luau VM instance

Source: https://luau.org/api

Initializes a new Luau VM instance using a custom memory allocation function.

```c
lua_State* lua_newstate(lua_Alloc f, void* ud);
```

--------------------------------

### Define a function for lower bounds inference

Source: https://luau.org/news/2022-07-07-luau-recap-june-2022

Example demonstrating how Luau infers return types using lower bounds calculation.

```luau
function find_first_if(vec, f)
for i, e in ipairs(vec) do
if f(e) then
return i
end
end
  

return nil
end
```

--------------------------------

### print(args: ...any)

Source: https://luau.org/library

Prints all arguments to the standard output.

```APIDOC
## print(args: ...any)

### Description
Prints all arguments to the standard output, using Tab as a separator.
```

--------------------------------

### Get object length

Source: https://luau.org/api

Returns the size or length of the object at the index based on its type.

```c
int lua_objlen(lua_State* L, int idx);
```

--------------------------------

### luaL_buffinit

Source: https://luau.org/api

Initializes the buffer B for use.

```APIDOC
## void luaL_buffinit(lua_State* L, luaL_Strbuf* B)

### Description
Initializes the buffer B for use.
```

--------------------------------

### Get upvalue index

Source: https://luau.org/api

Returns the pseudo index used to refer to a function upvalue.

```c
int lua_upvalueindex(int i);
#define lua_upvalueindex(i) // Implemented as a macro
```

--------------------------------

### Initialize a string buffer

Source: https://luau.org/api

Initializes a buffer B for use.

```c
void luaL_buffinit(lua_State* L, luaL_Strbuf* B);
```

--------------------------------

### Get the main thread

Source: https://luau.org/api

Retrieves the main thread of execution associated with the provided thread.

```c
lua_State* lua_mainthread(lua_State* L);
```

--------------------------------

### Initialize Coroutine Library

Source: https://luau.org/api

Initializes the coroutine library.

```c
#define LUA_COLIBNAME "coroutine"
int luaopen_coroutine(lua_State* L);
```

--------------------------------

### Raw Get function

Source: https://luau.org/library

Performs a table lookup for a specific key, bypassing metatables.

```Luau
function rawget<K, V>(t: { [K]: V }, k: K): V?
```

--------------------------------

### luaL_newstate

Source: https://luau.org/api

Creates a new instance of the Luau VM using default memory allocation functions.

```APIDOC
## luaL_newstate

### Description
Creates a new instance of the Luau VM. Luau will use default realloc and free functions for memory management.

### Signature
`lua_State* luaL_newstate(void);`
```

--------------------------------

### Get Luau stack depth

Source: https://luau.org/api

Returns the active number of call frames of the executing thread.

```c
int lua_stackdepth(lua_State* L);
```

--------------------------------

### Use the floor division operator

Source: https://luau.org/news/2023-11-01-luau-recap-october-2023

Demonstrates the syntax for floor division and the compound assignment operator.

```luau
local a = 10 // 3 -- a == 3
a //= 2 -- a == 1
```

--------------------------------

### Get Error Location

Source: https://luau.org/api

Retrieves source and line information for a specific call frame level.

```c
void luaL_where(lua_State* L, int lvl);
```

--------------------------------

### Create a buffer

Source: https://luau.org/library

Initializes a new buffer of a specified size with all bytes set to 0. The maximum allowed size is 1GB.

```lua
function buffer.create(size: number): buffer
```

--------------------------------

### Get global variable

Source: https://luau.org/api

Retrieves a global variable, functioning as a macro for lua_getfield on the global table.

```c
int lua_getglobal(lua_State* L, const char* s);
#define lua_getglobal(L, s) // Implemented as a macro
```

--------------------------------

### Use variadic types

Source: https://luau.org/types/basic-types

Shows how to annotate variadic parameters and define variadic type aliases.

```luau
local function f(...: number)
end
  
f(1, 2, 3) -- ok
f(1, "string") -- not ok
```

```luau
type F = (...number) -> ...string
```

--------------------------------

### lua_newstate

Source: https://luau.org/api

Creates a new instance of the Luau VM, returning a handle to the main thread of execution.

```APIDOC
## lua_newstate

### Description
Creates a new instance of the Luau VM, represented as a handle to the main Luau thread of execution.

### Signature
`lua_State* lua_newstate(lua_Alloc f, void* ud);`

### Parameters
- **f** (lua_Alloc) - Required - Memory allocation function
- **ud** (void*) - Required - Custom data pointer for the allocation function
```

--------------------------------

### Get Metatable from Registry

Source: https://luau.org/api

Checks if a value at the index is a userdata with a metatable registered under the specified name.

```c
int luaL_getmetatable(lua_State* L, const char* tname);
#define luaL_getmetatable(L, n) // Implemented as a macro
```

--------------------------------

### lua_singlestep

Source: https://luau.org/api

Switches execution to a single-step mode.

```APIDOC
## void lua_singlestep(lua_State* L, int enabled)

### Description
Switches execution to a single-step mode. In single-step mode, debugstep callback is called before executing each instruction.
```

--------------------------------

### Get string length

Source: https://luau.org/api

Returns the length of the value at the index, compatible with older Lua APIs.

```c
int lua_strlen(lua_State* L, int idx);
#define lua_strlen(L, i) // Implemented as a macro
```

--------------------------------

### table.create<V>(n: number, v: V?): {V}

Source: https://luau.org/library

Creates a new table of size n.

```APIDOC
## function table.create<V>(n: number, v: V?): {V}

### Description
Creates a new table of size n.
```

--------------------------------

### Get maximum numeric key

Source: https://luau.org/library

Returns the highest numeric key or zero if none exist.

```Luau
function table.maxn<V>(t: {V}): number
```

--------------------------------

### Run the Luau Profiler

Source: https://luau.org/guides/profile

Execute a Luau script with the --profile argument to generate a performance dump file.

```bash
$ luau --profile tests/chess.lua
OK      8902    rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1
OK      2039    r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq - 0 0
OK      2812    8/2p5/3p4/KP5r/1R3p1k/8/4P1P1/8 w - - 0 0
OK      9467    r3k2r/Pppp1ppp/1b3nbN/nP6/BBP1P3/q4N2/Pp1P2PP/R2Q1RK1 w kq - 0 1
OK      1486    rnbq1k1r/pp1Pbppp/2p5/8/2B5/8/PPP1NnPP/RNBQK2R w KQ - 1 8
OK      2079    r4rk1/1pp1qppp/p1np1n2/2b1p1B1/2B1P1b1/P1NP1N2/1PP1QPPP/R4RK1 w - - 0 10
Profiler dump written to profile.out (total runtime 2.034 seconds, 20344 samples, 374 stacks)
GC: 0.378 seconds (18.58%), mark 46.80%, remark 3.33%, atomic 1.93%, sweepstring 6.77%, sweep 41.16%
```

--------------------------------

### Get number sign

Source: https://luau.org/library

Returns -1 for negative, 1 for positive, and 0 for zero or NaN.

```Luau
function math.sign(n: number): number
```

--------------------------------

### Get Environment function

Source: https://luau.org/library

Returns the environment table for a target function or a caller stack index.

```Luau
function getfenv(target: (function | number)?): table
```

--------------------------------

### Manage Function Generics

Source: https://luau.org/types-library

Methods to get or set the generic types for a function type instance.

```lua
functiontype:generics(): {type}
```

```lua
functiontype:setgenerics(generics: {type}?)
```

--------------------------------

### Table indexer usage

Source: https://luau.org/types/tables

Shows how to use table indexers for array-like structures.

```luau
local t = {"Hello", "world!"} -- {[number]: string}
print(table.concat(t, ", "))
```

--------------------------------

### Read string from buffer

Source: https://luau.org/library

Reads a string of a specified length from the buffer starting at the given offset.

```lua
function buffer.readstring(b: buffer, offset: number, count: number): string
```

--------------------------------

### Autocomplete for union string singleton keys

Source: https://luau.org/news/2023-03-31-luau-recap-march-2023

Demonstrates how table keys defined as a union of string singletons trigger autocomplete suggestions.

```luau
type Direction = "north" | "south" | "east" | "west"
  

local a: {[Direction]: boolean} = {[^] = true}
local b: {[Direction]: boolean} = {["^"]}
local b: {[Direction]: boolean} = {^}
```

--------------------------------

### void luaL_sandboxthread(lua_State* L)

Source: https://luau.org/api

Creates a proxied global table for a thread to isolate writes while maintaining read access to the original globals.

```APIDOC
## void luaL_sandboxthread(lua_State* L)

### Description
Creates a new global table which proxies reads to the original global table. This new table is marked as a safe environment table. Writes to the global table are allowed but only affect the new table, leaving the original intact.

### Parameters
- **L** (lua_State*) - The Lua state.
```

--------------------------------

### Built-in Generic Type Signature

Source: https://luau.org/types/generics

Example of the generic type signature for the built-in table.insert function.

```luau
<T>({T}, T) -> ()
```

--------------------------------

### void luaL_sandbox(lua_State* L)

Source: https://luau.org/api

Secures the environment by marking global libraries, built-in metatables, and the globals table as read-only.

```APIDOC
## void luaL_sandbox(lua_State* L)

### Description
Marks all global libraries and all built-in metatables read-only. Additionally marks the globals table as read-only and configures it as a safe environment table.

### Parameters
- **L** (lua_State*) - The Lua state.
```

--------------------------------

### Nested generic function inference

Source: https://luau.org/news/2021-09-30-luau-recap-september-2021

Example of a function returning another function where types are inferred.

```luau
function mkPoint(x)
return function(y)
return { x = x, y = y }
end
end
```

--------------------------------

### Create table

Source: https://luau.org/library

Creates a new table with a specified size and optional default value.

```Luau
function table.create<V>(n: number, v: V?): {V}
```

--------------------------------

### lua_pushlightuserdata

Source: https://luau.org/api

Pushes a lightuserdata onto the stack.

```APIDOC
## void lua_pushlightuserdata(lua_State* L, void* p)

### Description
Same as lua_pushlightuserdatatagged with a default tag of 0.
```

--------------------------------

### Get Luau function argument

Source: https://luau.org/api

Retrieves the value of the nth argument of the function at the specified call frame.

```c
int lua_getargument(lua_State* L, int level, int n);
```

--------------------------------

### Load bytecode into the VM

Source: https://luau.org/api

Loads bytecode into the VM. Returns 0 on success with the closure on the stack, or 1 on failure with an error message.

```c
int luau_load(lua_State* L, const char* chunkname, const char* data, size_t size, int env);
```

--------------------------------

### Get environment table

Source: https://luau.org/api

Retrieves the environment table of the value at the specified index and pushes it onto the stack.

```c
void lua_getfenv(lua_State* L, int idx);
```

--------------------------------

### Get Light Userdata Tag

Source: https://luau.org/api

Returns the tag associated with the lightuserdata at the index, or -1 if the value is not a lightuserdata.

```C
int lua_lightuserdatatag(lua_State* L, int idx);
```

--------------------------------

### Constraint Resolver: Basic Null Check

Source: https://luau.org/news/2021-06-30-luau-recap-june-2021

Demonstrates improved type inference for nullable strings using the new constraint resolver.

```luau
function say_hello(name: string?)
-- extra parentheses were enough to trip the old typechecker
if (name) then
print("Hello " .. name .. "!")
else
print("Hello mysterious stranger!")
end
end
```

--------------------------------

### Get Unix timestamp with os.time

Source: https://luau.org/library

Returns the current Unix timestamp or converts a date table into a timestamp.

```lua
function os.time(t: table?): number
```

--------------------------------

### int luau_load(lua_State* L, const char* chunkname, const char* data, size_t size, int env)

Source: https://luau.org/api

Loads bytecode into the VM. On success, returns 0 and places the top closure on the stack; on failure, returns 1 and places an error message on the stack.

```APIDOC
## int luau_load(lua_State* L, const char* chunkname, const char* data, size_t size, int env)

### Description
Load bytecode into the VM. When env is 0, the current thread's global table is used; otherwise, it must be a stack index to a table object.

### Parameters
- **L** (lua_State*) - The VM state.
- **chunkname** (const char*) - A name to associate with the bytecode functions.
- **data** (const char*) - Pointer to the bytecode.
- **size** (size_t) - Bytecode size.
- **env** (int) - Environment table index or 0.
```

--------------------------------

### Get Metatable function

Source: https://luau.org/library

Retrieves the metatable for an object. Returns the value of the __metatable key if the metatable is protected.

```Luau
function getmetatable(obj: any): table?
```

--------------------------------

### Push Light Userdata with Tag

Source: https://luau.org/api

Places a lightuserdata value with a specific tag onto the stack.

```C
void lua_pushlightuserdatatagged(lua_State* L, void* p, int tag);
```

--------------------------------

### lua_createtable

Source: https://luau.org/api

Creates a new table with pre-allocated space.

```APIDOC
## void lua_createtable(lua_State* L, int narr, int nrec)

### Description
Creates a table with a reserved number of array and hash slots and places it on the stack.

### Parameters
- **narr** (int) - Required - Number of array elements (cannot be negative).
- **nrec** (int) - Required - Number of hash elements (cannot be negative).
```

--------------------------------

### Find element in table

Source: https://luau.org/library

Searches for the first occurrence of a value in an array, optionally starting from a specific index.

```Luau
function table.find<V>(t: {V}, v: V, init: number?): number?
```

--------------------------------

### lua_setupvalue

Source: https://luau.org/api

Sets the value of the nth upvalue of the function at the specified index.

```APIDOC
## const char* lua_setupvalue(lua_State* L, int funcindex, int n)

### Description
Sets the value of the nth upvalue of the function at the specified index using the value at the top of the stack.
```

--------------------------------

### Autocomplete for singleton types

Source: https://luau.org/news/2022-05-02-luau-recap-april-2022

Autocomplete now provides string literal suggestions for singleton types.

```luau
local function f(x: "a" | "b") end
f("_") -- suggest "a" and "b"
```

--------------------------------

### Get Luau local variable

Source: https://luau.org/api

Retrieves the value of the nth active local variable at the specified call frame.

```c
const char* lua_getlocal(lua_State* L, int level, int n);
```

--------------------------------

### Get Luau function information

Source: https://luau.org/api

Retrieves information about a function based on the stack level and requested data fields.

```c
int lua_getinfo(lua_State* L, int level, const char* what, lua_Debug* ar);
```

--------------------------------

### Create new buffer

Source: https://luau.org/api

Allocates a new zero-initialized buffer of the specified size on the stack. Throws an error if the size exceeds 1 GiB.

```c
void* lua_newbuffer(lua_State* L, size_t sz);
```

--------------------------------

### Get Light Userdata Name

Source: https://luau.org/api

Retrieves the name associated with a lightuserdata tag, returning nullptr if no name is associated.

```C
const char* lua_getlightuserdataname(lua_State* L, int tag);
```

--------------------------------

### Get UTF8 codepoints

Source: https://luau.org/library

Returns a number for each Unicode codepoint in the string within the specified byte offset range.

```lua
function utf8.codepoint(s: string, i: number?, j: number?): ...number
```

--------------------------------

### luaL_where

Source: https://luau.org/api

Places source and line information on the stack.

```APIDOC
## void luaL_where(lua_State* L, int lvl)

### Description
Places a string with source and line information about the selected call frame level lvl in a format "{short_src}:{line}: " on top of the stack.
```

--------------------------------

### lua_pushcclosurek

Source: https://luau.org/api

Creates a function from a C function pointer.

```APIDOC
## void lua_pushcclosurek(lua_State* L, lua_CFunction fn, const char* debugname, int nup, lua_Continuation cont)

### Description
Creates a function from a C function pointer and places it on top of the stack. Supports upvalues and C continuation functions.
```

--------------------------------

### Get byte values from string

Source: https://luau.org/library

Returns the numeric byte codes for characters within a specified index range.

```lua
function string.byte(s: string, f: number?, t: number?): ...number
```

--------------------------------

### Find pattern in string

Source: https://luau.org/library

Searches for a pattern match starting from a given index, returning match positions and captures.

```lua
function string.find(s: string, p: string, init: number?, plain: boolean?): (number?, number?, ...string)
```

--------------------------------

### luaL_opt

Source: https://luau.org/api

A macro wrapper for checking and retrieving optional arguments from the stack.

```APIDOC
## #define luaL_opt(L, f, n, d)

### Description
A wrapper for checking on optional arguments. When an argument is provided and not `nil`, function `f` is called with the argument number. Otherwise, the default value `d` is returned verbatim.
```

--------------------------------

### Creating a basic Luau script

Source: https://luau.org/getting-started

A simple script demonstrating function definitions and print statements in default non-strict mode.

```luau
function ispositive(x)
return x > 0
end
  

print(ispositive(1))
print(ispositive("2"))
  

function isfoo(a)
return a == "foo"
end
  

print(isfoo("bar"))
print(isfoo(1))
```

--------------------------------

### Push Light Userdata

Source: https://luau.org/api

Places a lightuserdata value on the stack using a default tag of 0.

```C
void lua_pushlightuserdata(lua_State* L, void* p);
#define lua_pushlightuserdata(L, p) // Implemented as a macro
```

--------------------------------

### Cyclic type definition

Source: https://luau.org/news/2022-07-07-luau-recap-june-2022

Example of a cyclic type that currently triggers a known bug when lower-bounds calculation is enabled.

```luau
type T = {T?}? -- spuriously reduces to {nil}?
```

--------------------------------

### Format string

Source: https://luau.org/library

Generates a formatted string using printf-style specifiers.

```lua
function string.format(s: string, args: ...any): string
```

--------------------------------

### lua_pcall

Source: https://luau.org/api

Performs a function call in a new protected environment.

```APIDOC
## int lua_pcall(lua_State* L, int nargs, int nresults, int errfunc)

### Description
Similar to lua_call, but executes in a protected environment. Returns the status of the call. If an error occurs, the error object is placed on the stack.
```

--------------------------------

### Identify ComparisonPrecedence lint triggers

Source: https://luau.org/news/2022-08-29-luau-recap-august-2022

Examples of code patterns that trigger the ComparisonPrecedence lint due to ambiguous operator binding.

```luau
local x, y = 6, 7
  

-- not X == Y is equivalent to (not X) == Y; consider using X ~= Y, or wrap one of the expressions in parentheses to silence
if not x == y then end
  

-- not X ~= Y is equivalent to (not X) ~= Y; consider using X == Y, or wrap one of the expressions in parentheses to silence
if not x ~= y then end
  

-- not X <= Y is equivalent to (not X) <= Y; wrap one of the expressions in parentheses to silence
if not x <= y then end
  

-- X <= Y == Z is equivalent to (X <= Y) == Z; wrap one of the expressions in parentheses to silence
if x <= y == 0 then end
```

--------------------------------

### lua_cpcall

Source: https://luau.org/api

Performs a C function call in a new protected environment.

```APIDOC
## int lua_cpcall(lua_State* L, lua_CFunction func, void* ud)

### Description
Performs a C function call in a protected environment. The function receives the ud pointer as its first argument.
```

--------------------------------

### Report union type errors

Source: https://luau.org/news/2022-01-27-luau-recap-january-2022

Example of code that triggers improved error reporting for union types in strict mode.

```luau
--!strict
  

type T = {x: number}
  

local x: T? = {w=4}
```

--------------------------------

### lua_rawsetp

Source: https://luau.org/api

Assigns the data on top of the stack to the lightuserdata and tag key in the value at the index.

```APIDOC
void lua_rawsetp(lua_State* L, int idx, void* p);
```

--------------------------------

### Identify Typo with Type Checking

Source: https://luau.org/news/2020-11-19-luau-type-checking-release

Example demonstrating a common typo that the Luau type checker can detect before the code is executed.

```luau
local p = Instance.new("Part")
p.Positio = Vector3.new(1,2,3)
```

--------------------------------

### void lua_setsafeenv(lua_State* L, int idx, int enabled)

Source: https://luau.org/api

Marks the table at the specified index as a 'safe' environment table, enabling VM optimizations for global lookups and built-in function calls.

```APIDOC
## void lua_setsafeenv(lua_State* L, int idx, int enabled)

### Description
Marks the table at the index as a ‘safe’ environment table. When executing a function with a ‘safe’ environment, the VM performs optimizations such as caching global lookups and using fastcalls for built-in functions.

### Parameters
- **L** (lua_State*) - The Lua state.
- **idx** (int) - The stack index of the table to mark.
- **enabled** (int) - Boolean flag to enable or disable the safe environment status.
```

--------------------------------

### Function Reference Restriction

Source: https://luau.org/news/2021-06-30-luau-recap-june-2021

Example of a behavior change where referencing a function by name within its own argument list is no longer permitted.

```luau
local function f(a: number, b: typeof(f)) -- 'f' is no longer visible here
```

--------------------------------

### Initialize a string buffer with reserved size

Source: https://luau.org/api

Initializes the buffer B with a reserved size of at least size. Returns a pointer to the writable data.

```c
char* luaL_buffinitsize(lua_State* L, luaL_Strbuf* B, size_t size);
```

--------------------------------

### Push 64-bit integer

Source: https://luau.org/api

Places an integer value on top of the stack with the exact 64-bit value.

```c
void lua_pushinteger64(lua_State* L, int64_t n);
```

--------------------------------

### Get Table Value

Source: https://luau.org/api

Retrieves values from tables or objects using various key types, with options to respect or ignore metamethods.

```c
int lua_gettable(lua_State* L, int idx);
```

```c
int lua_rawget(lua_State* L, int idx);
```

```c
int lua_getfield(lua_State* L, int idx, const char* k);
```

```c
int lua_rawgetfield(lua_State* L, int idx, const char* k);
```

```c
int lua_rawgeti(lua_State* L, int idx, int n);
```

```c
int lua_rawgetptagged(lua_State* L, int idx, void* p, int tag);
```

```c
int lua_rawgetp(lua_State* L, int idx, void* p);
#define lua_rawgetp(L, idx, p) // Implemented as a macro
```

--------------------------------

### Interacting with type instances

Source: https://luau.org/types-library

Methods and properties available on type instances for inspection and comparison.

```luau
type.tag: "nil" | "unknown" | "never" | "any" | "boolean" | "number" | "string" | "singleton" | "negation" | "union" | "intersection" | "table" | "function" | "extern" | "thread" | "buffer"
```

```luau
__eq(arg: type): boolean
```

```luau
type:is(arg: "nil" | "unknown" | "never" | "any" | "boolean" | "number" | "string" | "singleton" | "negation" | "union" | "intersection" | "table" | "function" | "extern" | "thread" | "buffer")
```

--------------------------------

### Get namecall atom

Source: https://luau.org/api

Retrieves the name of the method being called during a __namecall metamethod invocation. Should only be used inside the C metamethod implementation.

```c
const char* lua_namecallatom(lua_State* L, int* atom);
```

--------------------------------

### Assign data to table with lua_rawsetp

Source: https://luau.org/api

Assigns data from the stack to a table using a lightuserdata key. Throws an error if the target table is read-only.

```c
void lua_rawsetp(lua_State* L, int idx, void* p);
#define lua_rawsetp(L, idx, p) // Implemented as a macro
```

--------------------------------

### Get type name of object

Source: https://luau.org/api

Returns the type name of the object at the index, respecting metatable __type overrides for userdata and other types.

```c
const char* luaL_typename(lua_State* L, int idx);
```

--------------------------------

### Retrieve the current allocation function

Source: https://luau.org/api

Gets the memory allocation function and its associated custom data pointer currently in use by the VM.

```c
lua_Alloc lua_getallocf(lua_State* L, void** ud);
```

--------------------------------

### Format dates with os.date

Source: https://luau.org/library

Returns a table or string representation of a time based on a format string.

```lua
function os.date(s: string?, t: number?): table | string
```

--------------------------------

### Get object type with host support

Source: https://luau.org/library

Returns the type of an object, respecting host-defined types via the __type metatable field.

```luau
function typeof(obj: any): string
```

--------------------------------

### lua_pushlightuserdatatagged

Source: https://luau.org/api

Pushes a tagged lightuserdata onto the stack.

```APIDOC
## void lua_pushlightuserdatatagged(lua_State* L, void* p, int tag)

### Description
Place a lightuserdata value p with tag tag on top of the stack.
```

--------------------------------

### Define and use type packs

Source: https://luau.org/types/basic-types

Covers the definition of generic type packs and their instantiation in functions and type aliases.

```luau
type Signal<T, U...> = { f: (T, U...) -> (), data: T }
```

```luau
type Signal<T, U...> = { f: (T, U...) -> (), data: T }
  
local function call<T, U...>(s: Signal<T, U...>, ...: U...)
s.f(s.data, ...)
end
```

```luau
type Signal<T, U...> = { f: (T, U...) -> (), data: T }
local function call<T, U...>(s: Signal<T, U...>, ...: U...) end
  
local signal: Signal<string, (number, number, boolean)> = {} :: any
  
call(signal, 1, 2, false)
```

```luau
type A<T, U...> = (T) -> U...
  
type B = A<number, ...string> -- with a variadic type pack
type C<S...> = A<number, S...> -- with a generic type pack
type D = A<number, ()> -- with an empty type pack
```

```luau
type List<Head, Rest...> = (Head, Rest...) -> ()
  
type B = List<number> -- Rest... is ()
type C = List<number, string, boolean> -- Rest is (string, boolean)
  
type Returns<T...> = () -> T...
  
-- When there are no type parameters, the list can be left empty
type D = Returns<> -- T... is ()
```

```luau
type Callback<Args..., Rets...> = { f: (Args...) -> Rets... }
  
type A = Callback<(number, string), ...number>
```

--------------------------------

### Handle 'a and b or c' and 'if-then-else' expressions

Source: https://luau.org/news/2021-10-31-luau-recap-october-2021

Examples of how Luau handles conditional expressions to prevent false positive type errors.

```luau
--!strict
function f(t: {x: number}?)
local a = t and t.x or 5 -- 'a' is a 'number', no false positive errors here
end
```

```luau
--!strict
function f(t: {x: number}?)
local a = if t then t.x else 5 -- 'a' is a 'number', no false positive errors here
end
```

--------------------------------

### Clone table with lua_clonetable

Source: https://luau.org/api

Creates a shallow copy of the table at the index and pushes it to the stack. The copy is always read-write.

```c
void lua_clonetable(lua_State* L, int idx);
```

--------------------------------

### Optimize string.byte usage

Source: https://luau.org/news/2020-06-20-luau-recap-june-2020

Call string.byte directly rather than using method syntax to achieve significant performance gains.

```lua
string.byte(foo, 5)
```

```lua
foo:byte(5)
```

--------------------------------

### Detect duplicate variable definitions

Source: https://luau.org/news/2021-08-31-luau-recap-august-2021

Examples of code that triggers the linter warning for duplicate function arguments or local variable declarations.

```luau
local function foo(a1, a2, a2) -- Function argument 'a2' already defined on column 24
end
local a1, a2, a2 = foo() -- Variable 'a2' already defined on column 11
  

local bar = {}
function bar:test(self) -- Function argument 'self' already defined implicitly
end
```

--------------------------------

### Invoking a Function with Vector Types

Source: https://luau.org/news/2024-07-23-luau-recap-july-2024

Example of calling a function with vector arguments, which may trigger slower paths if types are not explicitly defined.

```luau
local intlPos = MulAddScaled(Part.Position, v, vector(12, 0, 0))
```

--------------------------------

### Check Option Argument

Source: https://luau.org/api

Matches a string or number argument against a list of options. Throws an error if the value is not found in the provided list.

```c
int luaL_checkoption(lua_State* L, int narg, const char* def, const char* const lst[]);
```

--------------------------------

### Unpack table into arguments

Source: https://luau.org/library

Returns values from a table range. Use index fields for packed varargs.

```Luau
function table.unpack<V>(a: {V}, f: number?, t: number?): ...V
```

--------------------------------

### Robustness testing script

Source: https://luau.org/news/2020-05-18-luau-recap-may-2020

An example of an obscure script used to test the type checker's stability and prevent crashes or unbounded recursion.

```luau
type ( ... ) ( ) ;
( ... ) ( - - ... ) ( - ... )
type = ( ... ) ;
( ... ) ( ) ( ... ) ;
( ... ) ""
```

--------------------------------

### Identify unexpected Unicode characters

Source: https://luau.org/news/2020-02-25-luau-recap-february-2020

Example of a source code line containing an invalid Unicode character that triggers a specific diagnostic warning.

```luau
local pi = 3․13 -- spoiler alert: this is not a dot!
```

--------------------------------

### Push buffer result to stack

Source: https://luau.org/api

Places the accumulated string on top of the stack and cleans up internal storage.

```c
void luaL_pushresult(luaL_Strbuf* B);
```

--------------------------------

### math.min

Source: https://luau.org/library

Returns the minimum of input arguments.

```APIDOC
## math.min(list: ...number): number

### Description
Returns the minimum number of the input arguments. The function requires at least one input and will error if zero parameters are passed.
```

--------------------------------

### Improve error messages for optional and union types

Source: https://luau.org/news/2021-10-31-luau-recap-october-2021

Examples of clearer error messages when accessing optional types or missing properties in union types.

```luau
--!strict
function f(a: {number}?)
return a[1] -- "Value of type '{number}?' could be nil" instead of "'{number}?' is not a table'
end
```

```luau
--!strict
type A = { x: number, y: number }
type B = { x: number }
local a: A | B
local b = a.y -- Key 'y' is missing from 'B' in the type 'A | B'
```

--------------------------------

### Optimize table size prediction

Source: https://luau.org/news/2021-09-30-luau-recap-september-2021

Use setmetatable with an empty table to allow the engine to predict the final table size.

```Luau
local self = setmetatable({}, Klass)
```

--------------------------------

### utf8.len(s: string, i: number?, j: number?): number?

Source: https://luau.org/library

Returns the number of Unicode codepoints with the starting byte offset in [i..j] range, or nil if malformed.

```APIDOC
### function utf8.len(s: string, i: number?, j: number?): number?

Returns the number of Unicode codepoints with the starting byte offset in `[i..j]` range, or `nil` followed by the first invalid byte position if the input string is malformed. `i` defaults to 1 and `j` defaults to `#s`.
```

--------------------------------

### luaL_newmetatable

Source: https://luau.org/api

Creates and registers a new metatable.

```APIDOC
## int luaL_newmetatable(lua_State* L, const char* tname)

### Description
Creates a new metatable and registers it under tname name in the registry table.
```

--------------------------------

### utf8.codepoint(s: string, i: number?, j: number?): ...number

Source: https://luau.org/library

Returns a number for each Unicode codepoint in the string with the starting byte offset in [i..j] range.

```APIDOC
### function utf8.codepoint(s: string, i: number?, j: number?): ...number

Returns a number for each Unicode codepoint in the string with the starting byte offset in `[i..j]` range. `i` defaults to 1 and `j` defaults to `i`.
```

--------------------------------

### Execute protected C function call

Source: https://luau.org/api

Performs a C function call in a protected environment, passing a lightuserdata pointer as the first argument.

```C
int lua_cpcall(lua_State* L, lua_CFunction func, void* ud);
```

--------------------------------

### Demonstrate false positive type error

Source: https://luau.org/news/2022-11-01-luau-recap-september-october-2022

An example of a type error in Luau where the type system incorrectly flags valid code due to syntax-driven subtyping limitations.

```luau
local x : CFrame = CFrame.new()
local y : Vector3 | CFrame
if (math.random()) then
y = CFrame.new()
else
y = Vector3.new()
end
local z : Vector3 | CFrame = x * y -- Type Error!
```

--------------------------------

### luaL_buffinitsize

Source: https://luau.org/api

Initializes the buffer B with a reserved size.

```APIDOC
## char* luaL_buffinitsize(lua_State* L, luaL_Strbuf* B, size_t size)

### Description
Initializes the buffer B with reserved size of at least size for use. Returns the pointer to the start of the data with size bytes that are writable.
```

--------------------------------

### utf8.offset(s: string, n: number, i: number?): number?

Source: https://luau.org/library

Returns the byte offset of the Unicode codepoint number n in the string, starting from the byte position i. Returns nil if the character is not found.

```APIDOC
### function utf8.offset(s: string, n: number, i: number?): number?

Returns the byte offset of the Unicode codepoint number `n` in the string, starting from the byte position `i`. When the character is not found, returns `nil` instead.
```

--------------------------------

### Create New Userdata

Source: https://luau.org/api

Functions to allocate new userdata objects on the stack with specific configurations.

```c
void* lua_newuserdatatagged(lua_State* L, size_t sz, int tag);
```

```c
void* lua_newuserdata(lua_State* L, size_t sz);
#define lua_newuserdata(L, s) // Implemented as a macro
```

```c
void* lua_newuserdatataggedwithmetatable(lua_State* L, size_t sz, int tag);
```

```c
void* lua_newuserdatadtor(lua_State* L, size_t sz, void (*dtor)(void*));
```

--------------------------------

### Print function

Source: https://luau.org/library

Outputs arguments to the standard output, separated by tabs.

```Luau
function print(args: ...any)
```
Tokens:
Raw