luau-lang/rfcs
1
0
Fork 0
mirror of https://github.com/luau-lang/rfcs.git synced 2025-05-04 10:43:48 +01:00
Code Issues Projects Releases Packages Wiki Activity

Update support-for-type-packs-in-user-defined-type-functions.md

Browse source 
Major change: 
Separated packs from the type userdata since packs are not types.
This commit is contained in:
Tenebris Noctua 2025-04-13 18:33:09 +03:00 • committed by GitHub
parent e56c2b4213
commit 94304b2e57
Signed by: DevComp
GPG key ID: B5690EEEBB952194
1 changed files with 34 additions and 29 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

63
docs/support-for-type-packs-in-user-defined-type-functions.md
View file

@ -13,16 +13,16 @@ This limits the usage for packs as they are used often in the language, and thei
## Design
We introduce a new runtime type called `pack` to extend the support of type packs within the type runtime.
We introduce a new userdata called `pack` alongside `type` to extend the support of type packs within the type runtime.
Packs will have a `kind` property that specifies the kind of the pack. A pack can either be a `list` kind or a `variadic` kind.
`pack` instances will have a `kind` property that specifies the kind of the pack. A `pack` can either be of a `literal` kind or of a `variadic` kind.
For example, consider a variadic type pack (e.g `...number`), in the new pack type, it will be represented as a `pack` with a `variadic` kind.
Or for a normal type pack such as `(number, string)`, it will be represented as a `pack` with a `list` kind.
Or for a normal type pack such as `(number, string)`, it will be represented as a `pack` with a `literal` kind.
`list` kind of packs will be able to contain other packs, or types more than one, whereas `variadic` type of packs will only contain *one* type.
`literal` packs will be able to contain other packs, or types more than one, whereas `variadic` kind of packs will only contain *one* type.
The user will be able to obtain the types within `pack`s using the `:unpack()` method, this method will return a table containing all the types or type packs within the pack.
The user will be able to obtain the `type`s within `pack`s using the `:unpack()` method, this method will return a table containing all the `type`s or `pack`s within the `pack`.
In `variadic` kind of `pack`s, `:unpack()` will only return a table with one element. This is because variadic packs are essentially many elements of the same type.
In user-defined type functions, type packs can be created by providing types or type packs that will be included within the pack. A pack will also be able to contain other packs, even packs of different kinds.
@ -32,10 +32,9 @@ In user-defined type functions, type packs can be created by providing types or
Creating a type function that accepts type packs:
```luau
type function f(arg: type)
if not arg:is("pack") then error("The given argument is not a type pack!") end
type function f(arg: pack)
if typeof(arg) ~= "pack" then error("The given argument is not a type pack!") end
local unpacked = arg:unpack() -- {string, number}
print(unpacked)
end
type a = f<(string, number)>
```
@ -44,8 +43,9 @@ Creating a type function that returns a function with a type pack:
```luau
type function f()
local newListPack = types.pack({types.string, types.number})
local newVariadicPack = types.pack({types.any}, true)
local newPack = types.pack({types.string, types.number}) -- (string, number)
local newVariadicPack = types.pack({types.any}, true) -- ...any
local newfunc = types.newfunction()
newfunc:setparameters({newPack}, newVariadicPack)
newfunc:setreturns({newPack}, newVariadicPack)
@ -58,7 +58,7 @@ The pack type will also enable generic type packs to be provided to type functio
Generic type pack arguments will pass the given type pack to the type function.
```luau
type function createCallback(args: type, returns: type) -- args will be a list pack, returns will be a variadic pack.
type function createCallback(args: pack, returns: pack) -- args will be a literal pack, returns will be a variadic pack.
local newTable = types.newtable()
local newfunc = types.newfunction()
newfunc:setparameters({args})
@ -74,35 +74,40 @@ If variadic type functions were to be implemented, type packs could be retrieved
```luau
type function f(...)
local packed = {...} -- {type}
local firstPack = packed[1] -- type.kind: list
local secondPack = packed[2] -- type.kind: variadic
local packed = {...} -- {pack}
local firstPack = packed[1] -- pack.kind: literal
local secondPack = packed[2] -- pack.kind: variadic
end
type a = f<(string, number), ...number>
```
## Updates to the types library and type userdata
Evaluating `typeof(...)` on a `pack` userdata will give the string `"pack"`.
```luau
type function f(arg: pack)
print(typeof(arg)) -- "pack"
end
type a = f<(string, number)>
```
## New pack userdata
### `pack` Instance
| New/Update | Instance Properties & Methods | Type | Description |
| ------------- | ------------- | ------------- | ------------- |
| New | `kind` | `"literal" \| "variadic"` | indicates the kind of the `pack`. |
| New | `unpack()` | `{pack \| type}` | returns the `type`s contained within the `pack`, returns only one element if `kind` is `variadic`. |
## Updates to the types library and the type userdata
### `types` Library
| New/Update | Library Functions | Return Type | Description |
| ------------- | ------------- | ------------- | ------------- |
| New | `pack(types: {type} isvariadic: boolean?)` | `type` | returns an immutable instance of a type pack; when `isvariadic` is true, `types` table can only have one type. |
| New | `pack(args: {pack \| type}, isvariadic: boolean?)` | `pack` | returns an immutable instance of a type pack; when `isvariadic` is true, `args` table can only have one `type`. |
| Update | `newfunction(parameters: { head: {type}?, tail: type? }, returns: { head: {type}?, tail: type? }, generics: {type}?)` | `type` | `tail` arguments can now accept variadic packs.
### `type` Instance
| New/Update | Instance Properties | Type | Description |
| ------------- | ------------- | ------------- | ------------- |
| Update | `tag` | `"nil" \| "unknown" \| "never" \| "any" \| "boolean" \| "number" \| "string" \| "singleton" \| "negation" \| "union" \| "intersection" \| "table" \| "function" \| "class" \| "thread" \| "buffer" \| "generic" \| "pack"` | Added `pack` as a possible tag |
#### Pack `type` instance
| New/Update | Instance Methods | Type | Description |
| ------------- | ------------- | ------------- | ------------- |
| New | `kind` | `"list" \| "variadic"` | indicates the kind of the pack. |
| New | `unpack()` | `{type}` | returns the types contained within the pack, returns only one element if `kind` is `variadic`. |
#### Function `type` instance
| New/Update | Instance Methods | Return Type | Description |