Keyword Index

Every reserved word, symbol and builtin name in the language, each linked to every reference entry it shows up in. It's generated, not written by hand: the keywords, contextual words and punctuation are read straight out of the railroad diagrams on Syntax, and the rest comes from the other reference pages - so a keyword appears here exactly when the grammar uses it. A name that means more than one thing (for both starts a loop and appears in implement ... for, in both part of for and an operator) lists all of them.

Keywords

The words that start a definition, statement, or part of one. Reserved everywhere.

break

Syntax: Break

case

Syntax: Enum Definition, Match Case, Union Definition

const

Syntax: Const Definition

context

Syntax: Context Definition

continue

Syntax: Continue

defer

Syntax: Defer

else

Syntax: If, Inline If

enum

Syntax: Enum Definition

error

Syntax: Error

field

Syntax: Field Definition

for

Syntax: For, Implement an Interface, Method Declaration

function

Syntax: Function Declaration

global

Syntax: Define

if

Syntax: For, If, Inline If, Match Case

implement

Syntax: Implement a Macro, Implement an Interface

inject

Syntax: Inject

interface

Syntax: Interface Definition

let

Syntax: Let

local

Syntax: Define

match

Syntax: Match

method

Syntax: Method Declaration

reject

Syntax: Reject

return

Syntax: Return

set

Syntax: Set

struct

Syntax: Struct Definition

then

Syntax: If, Inline If, Match Case

type

Syntax: Type Definition

union

Syntax: Union Definition

yield

Syntax: Yield

Contextual words and word operators

Words the grammar gives meaning to only at particular spots (then/else in if, with in error), plus the operators spelled as words.

_

Syntax: Word Reference

and

Operators: a and b

as

Syntax: Argument Destructuring, For

Operators: a as b

await

Operators: await a

band

Operators: a band b

bor

Operators: a bor b

bxor

Operators: a bxor b

false

Syntax: Boolean Literal

iff

Operators: a iff b

in

Syntax: For

Operators: a in b

is

Operators: a is b

lambda

Syntax: Lambda

macro

Syntax: Implement a Macro

not

Operators: not a

or

Operators: a or b

shl

Operators: a shl b

shr

Operators: a shr b

skipping

Syntax: For

true

Syntax: Boolean Literal

until

Syntax: For

while

Syntax: For

with

Syntax: Error

xor

Operators: a xor b

Symbols and punctuation

Every piece of punctuation the grammar uses, and every builtin operator spelled with symbols (including their other spellings).

-

Syntax: Number Literal

Operators: a - b, -a

-%

Operators: a -% b

-|

Operators: a -| b

,

Syntax: Argument Destructuring, Arguments Declaration, Call Arguments, Enum Definition, For, List Literal, Tuple Literal

:

Syntax: Arguments Declaration, Const Definition, Context Definition, Field Definition, Function Declaration, Implement a Macro, Let, Method Declaration

:=

Syntax: Arguments Declaration, Call Arguments, Const Definition, Context Definition, Enum Definition, Field Definition, Inject, Let, Set, Struct Definition, Type Definition, Union Definition

!

Syntax: Call, Index Access

Operators: a ! b

!!

Operators: a!!

!?

Syntax: Call, Index Access

Operators: a !? b

!?.

Operators: a!?.b

!?()

Operators: a!?(b)

!?[]

Operators: a!?[b]

!.

Operators: a!.b

!()

Operators: a!(b)

![]

Operators: a![b]

!=

Operators: a != b

!>

Operators: a !> b

!|>

Operators: a !|> b

?

Syntax: Call, Index Access

Operators: a?

?!

Operators: a ?! b

??

Operators: a ?? b

?.

Operators: a?.b

?()

Operators: a?(b)

?[]

Operators: a?[b]

?>

Operators: a ?> b

?|>

Operators: a ?|> b

.

Syntax: Number Literal

Operators: a.b

..

Operators: ..a

...

Syntax: Argument Destructuring, List Literal

..<

Operators: a..<b

..=

Operators: a..=b

'

Syntax: String Literal

'''

Syntax: String Literal

"

Syntax: String Literal

"""

Syntax: String Literal

(

Syntax: Argument Destructuring, Attributes, Call, Enum Definition, Function Declaration, Implement a Macro, Lambda, Method Declaration, Symbol Literal, Tuple Literal

()

Operators: a(b)

)

Syntax: Argument Destructuring, Attributes, Call, Enum Definition, Function Declaration, Implement a Macro, Lambda, Method Declaration, Symbol Literal, Tuple Literal

[

Syntax: Argument Destructuring, Index Access, List Literal

[]

Operators: a[b]

]

Syntax: Argument Destructuring, Index Access, List Literal

{

Syntax: Argument Destructuring, Block, Brace Call, Enum Definition, Implement an Interface, Interface Definition, Match, Struct Definition, Union Definition

{{{

Syntax: Macro With Body

{}

Syntax: Block

}

Syntax: Argument Destructuring, Block, Brace Call, Enum Definition, Implement an Interface, Interface Definition, Match, Struct Definition, Union Definition

}}}

Syntax: Macro With Body

*

Operators: a * b

*/

Syntax: Comment

*%

Operators: a *% b

*|

Operators: a *| b

/

Operators: a / b

/*

Syntax: Comment

//

Operators: a // b

///

Syntax: Comment

&

Syntax: Context Reference

Operators: a & b

&&

Syntax: Struct Definition

#

Syntax: Macro Invocation, Macro With Body, String Macro

%

Operators: a % b

Syntax: Path Reference

^

Operators: a ^ b

⇔

Operators: a ⇔ b

+

Syntax: Number Literal

Operators: a + b, +a

+%

Operators: a +% b

++

Operators: a ++ b

+|

Operators: a +| b

÷

Operators: a ÷ b

×

Operators: a × b

<

Syntax: Call, Enum Definition, Function Declaration, Generic Instantiation, Interface Definition, Method Declaration, Struct Definition, Type Definition, Union Definition

Operators: a < b

<=

Operators: a <= b

=

Syntax: Set

Operators: a = b

≠

Operators: a ≠ b

==

Operators: a == b

>

Syntax: Call, Enum Definition, Function Declaration, Generic Instantiation, Interface Definition, Method Declaration, Struct Definition, Type Definition, Union Definition

Operators: a > b

>=

Operators: a >= b

¬

Operators: ¬a

|

Syntax: Union Definition

Operators: a | b

|>

Operators: a |> b

||

Syntax: Enum Definition

||>

Operators: a ||> b

~

Operators: ~a

∘

Operators: a ∘ b

√

Syntax: Root

∧

Operators: a ∧ b

∨

Operators: a ∨ b

≤

Operators: a ≤ b

≥

Operators: a ≥ b

⊻

Operators: a ⊻ b

0b

Syntax: Number Literal

0d

Syntax: Number Literal

0o

Syntax: Number Literal

0x

Syntax: Number Literal

λ

Syntax: Lambda

Attributes

Every attribute the language defines. Any other @word is inert metadata.

@app

Attributes: @app(mount: String = "#app")

@arg

Attributes: @arg(description: String, short: String? = undefined, alone: Unknown = undefined, separator: String = "")

@args

Attributes: @args(usage: String = "", about: String = "", autoShort: Boolean = true)

@async

Attributes: @async

@attributeMacro

Attributes: @bodyMacro @stringMacro @deriveMacro @attributeMacro @programMacro

@bench

Attributes: @bench(displayName: String, ..stages)

@bodyMacro

Attributes: @bodyMacro @stringMacro @deriveMacro @attributeMacro @programMacro

@component

Attributes: @component

@delete

Attributes: @get(path) @post(path) @put(path) @patch(path) @delete(path)

@deprecated

Attributes: @deprecated(message: String)

@derive

Attributes: @derive(interfaces: Array<Interface>)

@deriveMacro

Attributes: @bodyMacro @stringMacro @deriveMacro @attributeMacro @programMacro

@effects

Attributes: @effects(..contexts)

@entity

Attributes: @entity(table: String = "")

@get

Attributes: @get(path) @post(path) @put(path) @patch(path) @delete(path)

@inject

Attributes: @inject

@injectGlobally

Attributes: @injectGlobally

@injectLocally

Attributes: @injectLocally

@inline

Attributes: @inline

@js

Attributes: @js(module: String, name: String?) | @js(name: String?)

@main

Attributes: @main

@memoize

Attributes: @memoize

@native

Attributes: @native

@onBlockEnd

Attributes: @onError @onYield @onReturn @onBlockEnd

@onError

Attributes: @onError @onYield @onReturn @onBlockEnd

@onReturn

Attributes: @onError @onYield @onReturn @onBlockEnd

@onYield

Attributes: @onError @onYield @onReturn @onBlockEnd

@parallel

Attributes: @parallel(unsafe?)

@patch

Attributes: @get(path) @post(path) @put(path) @patch(path) @delete(path)

@phase

Attributes: @phase(phase: CompilePhase)

@post

Attributes: @get(path) @post(path) @put(path) @patch(path) @delete(path)

@programMacro

Attributes: @bodyMacro @stringMacro @deriveMacro @attributeMacro @programMacro

@pure

Attributes: @pure

@put

Attributes: @get(path) @post(path) @put(path) @patch(path) @delete(path)

@reads

Attributes: @reads(..contexts)

@require

@route

Attributes: @route(method: String, path: String)

@serve

Attributes: @serve(port: U16 = 8080, host: String = "localhost")

@singleton

Attributes: @singleton

@slow

Attributes: @slow

@sqlid

Attributes: @sqlid(autoincrement: Boolean = false)

@state

Attributes: @state

@stringMacro

Attributes: @bodyMacro @stringMacro @deriveMacro @attributeMacro @programMacro

@test

Attributes: @test(..stages)

@testHelper

Attributes: @testHelper(displayName: String)

@unit

Attributes: @unit @unit(definition: Unit, offset: F64 = 0.0)

@writes

Attributes: @writes(..targets)

Macros

Builtin macro namespaces, their members, and the embedded languages.

#builtin

Macros: #builtin

#builtin.functions

Macros: #builtin.functions

#builtin.implementation

Macros: #builtin.implementation

#builtin.implementations

Macros: #builtin.implementations

#builtin.interfaces

Macros: #builtin.interfaces

#builtin.intrinsic

Macros: #builtin.intrinsic

#builtin.operators

Macros: #builtin.operators

#builtin.primitiveTypes

Macros: #builtin.primitiveTypes

#builtin.structs

Macros: #builtin.structs

#comptime

Macros: #comptime

#comptime.braceCall

Macros: #comptime.braceCall

#comptime.call

Macros: #comptime.call

#comptime.definitionsWith

Macros: query the program

#comptime.program

Macros: the whole program

#comptime.typeof

Macros: #comptime.typeof

#context

Macros: #context

#CSS

Macros: CSS embedded language

#CSV

Macros: CSV embedded language

#format

Macros: string macro

#GLSL

Macros: GLSL embedded language

#HLSL

Macros: HLSL embedded language

#HTML

Macros: HTML embedded language

#HTTP

Macros: HTTP request embedded language

#JSON

Macros: JSON embedded language

#MARKDOWN

Macros: Markdown embedded language

#MSL

Macros: Metal Shading Language embedded language

#regex

Macros: string macro

#REGEX

Macros: regular expression embedded language

#runtime

Macros: #runtime

#runtime.braceCall

Macros: #runtime.braceCall

#runtime.call

Macros: #runtime.call

#runtime.typeof

Macros: #runtime.typeof

#SHELL

Macros: POSIX shell command embedded language

#SPIRV

Macros: SPIR-V assembly embedded language

#SQL

Macros: SQL embedded language

#SVG

Macros: SVG embedded language

#TOML

Macros: TOML embedded language

#VUE

Macros: Vue single-file component embedded language

#WGSL

Macros: WGSL embedded language

#YAML

Macros: YAML embedded language

Context values

Every value the language provides through the context.

&args

Context: &args: Array<String>

&cancellation

Context: &cancellation: Cancellation

&clock

Context: &clock: interface.Clock

&database

Context: &database: interface.Database

&env

Context: &env: interface.Environment

&fs

Context: &fs: interface.FileSystem

&hashSeed

Context: &hashSeed: U64

&heapAllocator

Context: &heapAllocator: interface.Allocator

&http

Context: &http: interface.HttpClient

&logger

Context: &logger: interface.Logger

&maxCallDepth

Context: &maxCallDepth: U64

&panicHandler

Context: &panicHandler: interface.PanicHandler

&random

Context: &random: interface.Random

&request

Context: &request: Request

&snapshots

Context: &snapshots: interface.SnapshotStore

&stderr

Context: &stderr: interface.OutputStream

&stdin

Context: &stdin: interface.InputStream

&stdout

Context: &stdout: interface.OutputStream

&stringNormalization

Context: &stringNormalization: (NFC | NFD | NFKC | NFKD)?

&timeZone

Context: &timeZone: TimeZone

Types and interfaces

Every builtin type and interface name.

Acre

Keyword Index

Keywords

Contextual words and word operators

Symbols and punctuation

Attributes

Macros

Context values

Types and interfaces

Functions