mirror of
https://github.com/luau-lang/luau.git
synced 2025-05-04 10:33:46 +01:00
101 lines
4.5 KiB
Markdown
101 lines
4.5 KiB
Markdown
---
|
|
layout: single
|
|
title: "Luau Recap: November 2021"
|
|
---
|
|
|
|
Luau is our new language that you can read more about at [https://luau-lang.org](https://luau-lang.org).
|
|
|
|
[Cross-posted to the [Roblox Developer Forum](https://devforum.roblox.com/t/luau-recap-november-2021/).]
|
|
|
|
## Singleton types
|
|
|
|
Singleton types, also known as literal types, allow you to represent a specific value of a string or boolean in the type system. This is useful for representing enums and similar constructs.
|
|
|
|
```lua
|
|
type Status = "ok" | "error"
|
|
|
|
local x: Status = "ok"
|
|
```
|
|
|
|
At the moment, support for these is limited to just the type construct. In the near future, Luau will make use of this information to better infer `if` statements and expressions:
|
|
|
|
```lua
|
|
type Result = {
|
|
success: true,
|
|
value: number,
|
|
}
|
|
|
|
type Error = {
|
|
success: false,
|
|
error: string,
|
|
}
|
|
|
|
type ResultOrError = Result | Error
|
|
local x: ResultOrError
|
|
|
|
if x.success then
|
|
-- x is inferred to be of type Result
|
|
print(x.value * 2)
|
|
else
|
|
-- x is inferred to be of type Error
|
|
print("error:", x.error)
|
|
end
|
|
```
|
|
|
|
## Type packs in type aliases
|
|
|
|
Type packs are the construct Luau uses to represent a sequence of types. We've had syntax for generic type packs for a while now, and it sees use in generic functions, but it hasn't been available in type aliases. That has changed, and it is now syntactically legal to write the following type alias:
|
|
```lua
|
|
type X<A...> = () -> A...
|
|
type Y = X<number, string>
|
|
```
|
|
|
|
We've also added support for explicit type packs. Previously, it was impossible to instantiate a generic with two or more type pack parameters, because it wasn't clear where the first pack ended and the second one began. We have introduced a new syntax for this use case:
|
|
```
|
|
type Fn<P..., R...> = (P...) -> R...
|
|
type X = Fn<(number, string), (string, number)>
|
|
```
|
|
|
|
For more information, check out [the RFC for this feature](https://github.com/Roblox/luau/blob/f86d4c6995418e489a55be0100159009492778ff/rfcs/syntax-type-alias-type-packs.md).
|
|
|
|
## Library improvements
|
|
|
|
```lua
|
|
function bit32.countlz(n: number): number
|
|
function bit32.countrz(n: number): number
|
|
```
|
|
Given a number, returns the number of preceding left or trailing right-hand bits that are `0`.
|
|
|
|
See [the RFC for these functions](https://github.com/Roblox/luau/blob/f86d4c6995418e489a55be0100159009492778ff/rfcs/function-bit32-countlz-countrz.md) for more information.
|
|
|
|
## Type checking improvements
|
|
|
|
We have enabled a rewrite of how Luau handles require tracing. This has two main effects: firstly, in strict mode, requires that Luau can't resolve will trigger type errors; secondly, Luau now understands the `FindFirstAncestor` method in require expressions.
|
|
|
|
Luau now warns when the index to `table.move` is 0, as this is non-idiomatic and performs poorly. If this behavior is intentional, wrap the index in parentheses to suppress the warning.
|
|
|
|
Luau now provides additional context in table and class type mismatch errors.
|
|
|
|
## Performance improvements
|
|
|
|
We have enabled several changes that aim to avoid allocating a new closure object in cases where it's not necessary to. This is helpful in cases where many closures are being allocated; in our benchmark suite, the two benchmarks that allocate a large number of closures improved by 15% and 5%, respectively.
|
|
|
|
When checking union types, we now try possibilities whose synthetic names match. This will speed up type checking unions in cases where synthetic names are populated.
|
|
|
|
We have also enabled an optimization that shares state in a hot path on the type checker. This will improve type checking performance, and also prevent some
|
|
|
|
The Luau VM now attempts to cache the length of tables' array portion. This change showed a small performance improvement in benchmarks, and should speed up `#` expressions.
|
|
|
|
The Luau type checker now caches a specific category of table unification results. This can improve type checking performance significantly when the same set of types is used frequently.
|
|
|
|
When Luau is not retaining type graphs, the type checker now discards more of a module's type surface after type checking it. This improves memory usage significantly.
|
|
|
|
## Bug fixes
|
|
|
|
We've fixed a bug causing Luau unit tests on ARM systems to fail, rooted in an issue in `string.pack`.
|
|
|
|
We've fixed an issue with type aliases that reuse generic type names that caused them to be instantiated incorrectly.
|
|
|
|
We've corrected a subtle bug that could cause free types to leak into a table type when a free table is bound to that table.
|
|
|
|
We've fixed an issue that could cause Luau to report an infinitely recursive type error when the type was not infinitely recursive.
|