Skip to content

Commit

Permalink
News about string interpolation feature and a syntax page update (#829)
Browse files Browse the repository at this point in the history
News can be viewed
[here](https://vegorov-rbx.github.io/luau/2023/02/02/luau-string-interpolation.html)
And syntax can be viewed
[here](https://vegorov-rbx.github.io/luau/syntax#string-interpolation)

Note that link appears to be broken in the news section. It goes to
`https://vegorov-rbx.github.io/syntax#string-interpolation` instead of
`https://vegorov-rbx.github.io/luau/syntax#string-interpolation`
The link I use in the source is `/syntax#string-interpolation` but the
root 'offset' is different on Luau website (doesn't have extra 'luau'
folder) and on my GitHub pages.
Hope this is ok. But if GitHub page masters know how to avoid this,
please let me know.

---------

Co-authored-by: Alan Jeffrey <403333+asajeffrey@users.noreply.github.com>
Co-authored-by: Alexander McCord <11488393+alexmccord@users.noreply.github.com>
  • Loading branch information
3 people committed Feb 3, 2023
1 parent 62483d4 commit c5555c6
Show file tree
Hide file tree
Showing 2 changed files with 87 additions and 0 deletions.
54 changes: 54 additions & 0 deletions docs/_pages/syntax.md
Original file line number Diff line number Diff line change
Expand Up @@ -219,3 +219,57 @@ end
```

The default iteration order for tables is specified to be consecutive for elements `1..#t` and unordered after that, visiting every element; similarly to iteration using `pairs`, modifying the table entries for keys other than the current one results in unspecified behavior.

## String interpolation

Luau adds an additional way to define string values that allows you to place runtime expressions directly inside specific spots of the literal.

This is a more ergonomic alternative over using `string.format` or `("literal"):format`.

To use string interpolation, use a backtick string literal:

```lua
local count = 3
print(`Bob has {count} apple(s)!`)
--> Bob has 3 apple(s)!
```

Any expression can be used inside `{}`:

```lua
local combos = {2, 7, 1, 8, 5}
print(`The lock combination is {table.concat(combos)}.`)
--> The lock combination is 27185.
```

Inside backtick string literal, `\` is used to escape `` ` ``, `{`, `\` itself and a newline:

```lua
print(`Some example escaping the braces \{like so}`)
--> Some example escaping the braces {like so}

print(`Backslash \ that escapes the space is not a part of the string...`)
--> Backslash that escapes the space is not a part of the string...

print(`Backslash \\ will escape the second backslash...`)
--> Backslash \ will escape the second backslash...

print(`Some text that also includes \`...`)
--> Some text that also includes `...

local name = "Luau"

print(`Welcome to {
name
}!`)
--> Welcome to Luau!
```

### Restrictions and limitations

The sequence of two opening braces {{"`{{`"}} is rejected with a parse error.
This restriction is made to prevent developers using other programming languages with a similar feature from trying to attempt that as a way to escape a single `{` and getting unexpected results in Luau.

Luau currently does not support backtick string literals as a type annotation, so `` type Foo = `Foo` `` is invalid.

Function calls with a backtick string literal without parenthesis is not supported, so `` print`hello` `` is invalid.
33 changes: 33 additions & 0 deletions docs/_posts/2023-02-02-luau-string-interpolation.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,33 @@
---
layout: single
title: "String Interpolation"
---

String interpolation is the new syntax introduced to Luau that allows you to create a string literal with expressions inside of that string literal.

In short, it's a safer and more ergonomic alternative over `string.format`.

Here's a quick example of a string interpolation:

```lua
local combos = {2, 7, 1, 8, 5}
print(`The lock combination is {table.concat(combos)}. Again, {table.concat(combos, ", ")}.`)
--> The lock combination is 27185. Again, 2, 7, 1, 8, 5.
```

String interpolation also composes well with the `__tostring` metamethod.

```lua
local balance = setmetatable({ value = 500 }, {
__tostring = function(self)
return "$" .. tostring(self.value)
end
})

print(`You have {balance}!`)
--> You have $500!
```

To find out more details about this feature, check out [Luau Syntax page](/syntax#string-interpolation).

This is also the first major language feature implemented in a [contribution](https://github.com/Roblox/luau/pull/614) from the open-source community. Thanks [Kampfkarren](https://github.com/Kampfkarren)!

0 comments on commit c5555c6

Please sign in to comment.