Macros

The default operator table.

See Builtin Operators.

The primitive types.

See Builtin Types.

The builtin generic interfaces.

See Builtin Types.

The builtin structs.

See Builtin Functions.

The free functions, and the methods of each builtin type.

See Builtin Functions and Builtin Types.

The builtin interface implementations.

The primitive number and Boolean operations - #builtin.intrinsic.ADD_U64_U64(a, b). See Intrinsics.

Ready-made implementations of the context interfaces, to inject in place of a builtin value - inject clock := #builtin.implementation.FixedClock.new(someInstant). See Context.

the endless count 0, 1, 2, ... - the one unbounded sequence every open-ended loop is built on

size bytes from &heapAllocator, aligned to alignment - the address of the first

gives back a block allocate handed out, by its first address

where a value is stored

reads a T from memory

writes a T to memory

correctly rounded decimal-to-binary conversion - the one number literals go through (T is F32 or F64)

the shortest digits that parse back to the same value, or exactly precision decimals, correctly rounded

the General_Category, "Lu" - from UnicodeData

a binary Unicode property, "ID_Start" - from the Unicode property tables

full case mapping - some code points map to several - from UnicodeData and SpecialCasing

lowercase - some code points map to several

where each extended grapheme cluster starts - from the segmentation tables (UAX #29)

canonical / compatibility (de)composition - from the normalization tables (UAX #15)

parses a pattern (ECMAScript syntax; flags "i", "m", "s", "u", "x") into a backtracking program

runs a program on text from start (only at start itself when anchored) - each group's span in code points, group 0 the whole match; undefined when nothing matches

the program's named groups, each with its group number

zlib (RFC 1950) - the DEFLATE engine PNG images are stored with

zlibCompress the other way - a ParseError for data that is not zlib

the unsigned integer width bytes (at most 6) wide at at - most significant first when big

value (below 2^48) written width bytes wide at at - most significant first when big

width x height pixels in a layout - RGBA, RGB, BGRA, BGR, gray, gray and alpha, 16-bit samples, 1- to 8-bit palette indices and grays, 5-6-5 and 5-5-5 - from offset, as RGBA: each row stride bytes, the bottom one first when bottomUp; palette's RGBA quads for the indices, key the one transparent sample value (-1 for none) - undefined when the data runs short

RGBA pixels written in a layout - each row stride bytes, the bottom one first when bottomUp

1 when any alpha isn't 255, 2 when any pixel isn't gray, 4 when any alpha isn't 0 or 255, 8 when any isn't 0

count RGBA pixels, each the color 0xRRGGBBAA

the w x h RGBA pixels at x, y of an image width wide

RGBA pixels mirrored left to right when horizontal, top to bottom otherwise

RGBA pixels turned clockwise 1 to 3 quarter turns

RGBA pixels scaled - nearest neighbour, or smooth: averaged when shrinking, bilinear when growing, color weighted by alpha

source's RGBA pixels drawn over target's with its top-left at x, y - clipped, blended source-over

PNG rows, each with the filter that makes its bytes smallest before it

PNG's filtered rows from offset, undone - undefined when a filter isn't one or they run short

an interlaced PNG's pass (0 to 6), as RGBA, put where it goes in the whole image's

count RGBA pixels as QOI chunks, and QOI's end marker

count RGBA pixels from QOI chunks at offset - undefined when they run short

count pixels of bpp bytes each as TGA's run-length packets

count pixels of bpp bytes each from TGA's run-length packets at offset - undefined when they run short

palette indices LZW-coded as GIF does, in its sub-blocks

count palette indices from GIF's LZW sub-blocks at offset - what's missing left 0

count RGBA pixels as indices into a palette of at most maxColors - each color its own when there are few enough, otherwise a median cut, Floyd-Steinberg dithered across rows width wide when dither; alpha under 128 transparent: [palette, indices, the transparent index or -1]

baseline JPEG's entropy-coded scan of RGBA pixels - YCbCr (Y alone when gray), 4:2:0 when subsample; quant two tables of 64 (natural order), huffman four tables (each 16 counts and its values)

one JPEG scan - baseline or progressive - added to coeffs (16-bit), its data at offset: where it ends, or -1 when it uses a Huffman table there isn't

a JPEG's RGBA pixels from all its coefficients - dequantized, inverse-transformed, upsampled as libjpeg does, made RGB (transform 1 YCbCr, 0 RGB or CMYK, 2 YCCK)

RGBA as planar YCbCr (BT.601, limited range; gray full range): Y, then Cb, then Cr - mode 0 4:2:0, 1 4:2:2, 2 4:4:4, 3 Y alone

planar YCbCr at offset, as RGBA - undefined when the planes run short

count samples stored in an encoding - 8-bit unsigned and signed, 16-, 24- and 32-bit either endian, floats and doubles either endian, mu-law, A-law - from offset, as 32-bit floats; undefined when short

32-bit float samples stored in an encoding - rounded and clamped; G.711 as ffmpeg writes it

every float sample times gain

source's float samples times gain added to target's from sample at - as far as target goes

float samples of from channels as to channels - averaged to 1, 1 copied to all, otherwise each its own

each channel's float samples at toRate instead of fromRate - windowed sinc, 16 zero crossings a side

the largest magnitude of any float sample - 0 for none

numbers as 32-bit float samples

32-bit float samples as numbers

FLAC frames of float samples as bits-bit integers, blockSize a channel each - the smallest of CONSTANT, VERBATIM, FIXED and LPC for each, mid/side when it helps: [the frames, the smallest frame's size, the largest's]

the float samples of FLAC frames from offset - at most total a channel when it's more than 0; undefined when there are no frames there

Evaluate the given expression at compile time and inline its result.

Evaluate the given block at compile time and inline its result.

Resolve to the expression's statically known type, computed at compile time.

where the current call was written, when locations are kept - "src/main.rfn:12:5"

the name as written, with generics - "Array"

the type written as name - "Point", "Shape.Circle" - from the same tables

its type arguments - [U8] for Array

field names and types, in declaration order - empty unless a Struct or Tuple

cases or members, in declaration order - empty unless an Enum or Union

bytes a value occupies

the same type, with the same generics

the type checker's own rule - a from-value fits where a to is expected

there's an implement interface for type in scope

the name it was declared under - "Comparable"

each required member's name and type

every type with an implement block for it in scope

the same interface, with the same generics

the name it was defined under - undefined for a Lambda

its own type, parameters and result included

how many parameters it takes

it's marked @pure

a new function with the first argument fixed, taking the rest - it needs the argument list's shape

a chain of one-argument functions, one per parameter

the same function with its first two parameters swapped

Defer evaluation of the given expression to runtime, even if it could be computed at compile time.

Defer evaluation of the given block to runtime.

Resolve to the value's actual type as observed at runtime, rather than its statically known type.

ends the program with error, printing it and its trace() to &stderr - past &panicHandler, which is what the builtin one (AbortingPanicHandler) comes down to

which case an enum value is

the case's payload, positionally - a struct-like case's fields in order, empty for a unit case

a struct value's fields, in declaration order - or an enum case's, named as construct takes them ("0", "1", ... for a tuple case), so construct(variantOf(v), fieldsOf(v)) makes v again

fieldsOf's values alone, in the same order - a struct's fields, an enum case's payload - without making the Map

a value of type built from its fields by name - a missing or unknown field is an Error. An enum case's type is named with its enum, as variantOf gives it, and a tuple case's values are named "0", "1", ...

the field at a position

a tuple of both values' fields, a's first

jumps to f's code with args spread into its parameters

the same code - and for a Lambda the same captured values, for a Method the same self

the value a Method was read from - a in a.method

a Method's code as a Function taking self as its first argument

a Lambda's captured variables, by name, as they are now

queues task on the event loop, to run once &clock.now() reaches at. Tasks run one at a time, in the order they came due; with none due, the loop calls &clock.sleep until the next one is. A web page can't wait: there the page's own timers run the system clock's tasks, and the program goes on meanwhile

queues task on the event loop, to run with the time, in milliseconds, once the display draws its next frame - a web page's; anywhere else once 16 ms have gone on &clock

task kept for JavaScript to call back - a listener's events, a JsValue.callback's calls, a JavaScript promise settling - by the number this gives, which the host is told. It runs on the event loop, with what JavaScript hands it, and what it gives goes back; then the tasks that's made ready run, and an @app's components it changed render again

the task listen kept under number forgotten - JavaScript calling it does nothing from then on

runs the event loop until done() is true - aborts when nothing's left to run and done() still isn't

work(..arguments) started on another of the host's threads: the arguments copied there, and the promise settled with the result copied back once the loop sees it done - undefined when the host has no thread to spare, or one of them can't be copied (see Promise.parallel)

the same with the caller's context values copied to the thread too - Promise.parallelUnsafe's

a copy of value sharing nothing with it - what goes to another thread

value kept where every thread of the program reaches the same one - what SharedMap, Channel and SharedCounter are made with; handed to a thread, it's itself there, not a copy

f run with `value` (one shareAcrossThreads gave) locked - no other thread gets it until f ends; a thread that has it locked can lock it again

waits until `value` (one shareAcrossThreads gave) is changed by another thread, or `ms` milliseconds pass - forever when negative

A SQL statement as a typed, prepared query.

Produces

Query<Row> - a prepared statement, run through the database connection in context; run() gives a Table<Row>

Checked

A SELECT reading one @entity struct's table selects only its columns - Row is then that struct, when every field that isn't optional is selected. #SQL<Row> {{{ ... }}} names Row for any other query - a join, COUNT(*). Otherwise each row is a Map of its columns.

#{ }

A bound parameter (? / $1), never text spliced into the statement - so a value can't change the query's shape, and SQL injection can't happen.

An HTML fragment as a value, built safely from data.

Produces

Html - a document fragment, rendered by its toString()

Checked

The markup is well-formed: every tag closes, in order, and attributes are quoted.

#{ }

Escaped text in a text position; an escaped, quoted attribute value in an attribute position; spliced in whole when the value is itself Html - so nesting fragments works, and nothing else can inject markup. In an event attribute (onclick, oninput, ...) the value is a lambda, called when the event fires, with the event if it takes an argument - it only runs in a browser app, and toString() leaves it out. A component instance renders in place.

A Vue single-file component - template, script and style - written inline.

Produces

Component - a Vue component definition, ready to register or mount

Checked

The template, script and style blocks each parse, and every name the template uses is defined by the script. Props are typed from the script's own defineProps.

#{ }

Only in the script block, as a constant baked into the component when it's built. The template keeps Vue's own {{ }} interpolation for the component's reactive state - the two never clash, since #{ } isn't Vue syntax.

A CSS stylesheet as a value.

Produces

Stylesheet - parsed rules, rendered by toString()

Checked

The stylesheet parses, and every property is a known CSS property.

#{ }

A single CSS value (a length, a color, a quoted string) - never a selector, property name or rule, so a value can't add rules of its own.

A WGSL shader for the GPU, as a value - see Graphics on the GPU.

Produces

Wgsl - a shader's source, what Gpu.shader compiles

Checked

Its brackets - ( ), [ ] and { } - balance. The GPU compiles the rest when the shader is made, and reports what doesn't on the host's console.

#{ }

The value's text - a number as it's written, so a constant can be shared with Refingere - or, when the value is itself Wgsl, its source spliced in whole, so a shader can be put together from pieces.

A GLSL shader, as a value - one stage per shader, as GLSL writes it.

Produces

Glsl - an OpenGL or Vulkan shader's source

Checked

Its brackets - ( ), [ ] and { } - balance. The rest is compiled by whatever takes the shader: a browser's WebGPU only takes WGSL, so a Glsl is for a host whose GPU reads GLSL, or for a tool that turns it into SPIR-V.

#{ }

The value's text - a number as it's written - or, when the value is itself Glsl, its source spliced in whole, so a shader can be put together from pieces.

An HLSL shader, as a value.

Produces

Hlsl - a Direct3D shader's source

Checked

Its brackets - ( ), [ ] and { } - balance; the shader compiler that takes it checks the rest.

#{ }

The value's text - a number as it's written - or, when the value is itself Hlsl, its source spliced in whole, so a shader can be put together from pieces.

A Metal shader, as a value.

Produces

Msl - a Metal shader's source

Checked

Its brackets - ( ), [ ] and { }, so [[ ]] attributes too - balance; Metal's compiler checks the rest.

#{ }

The value's text - a number as it's written - or, when the value is itself Msl, its source spliced in whole, so a shader can be put together from pieces.

A SPIR-V module in its assembly text, as a value.

Produces

Spirv - a SPIR-V module, in the assembly text spirv-as reads

Checked

Every line is an instruction - %id = OpName ... or OpName ... - a ; comment, or blank. What the instructions mean is checked by the tool that assembles it.

#{ }

The value's text - a number as it's written - or, when the value is itself Spirv, its source spliced in whole, so a shader can be put together from pieces.

An SVG image as a value, built safely from data.

Produces

Svg - a vector image, rendered by its toString()

Checked

The markup is well-formed XML with an <svg> root, and every element and attribute is one SVG defines.

#{ }

As in #HTML: escaped text in a text position, an escaped, quoted value in an attribute position, and spliced in whole when the value is itself Svg. An Svg placed in #HTML is inline SVG.

A JSON document as a typed value, parsed at compile time.

Produces

Json - the parsed document, with the literal's own shape as its type

Checked

The document parses - a trailing comma or an unquoted key is a compile error, not a runtime one.

#{ }

The value serialized as JSON - a string quoted and escaped, a struct as an object, an array as an array.

A YAML document as a typed value, parsed at compile time.

Produces

the parsed document as a constant, with the literal's own shape as its type - a mapping is a struct with its keys as fields, a sequence an Array

Checked

The document parses, no mapping has the same key twice, and indentation uses spaces only. Scalars are read with YAML 1.2's core schema, so no and on stay strings.

#{ }

The value as a YAML flow node - a string quoted and escaped, an array as [...], a struct as {...} - so a value can't add keys or change the indentation around it.

A TOML document as a typed value, parsed at compile time.

Produces

the parsed document as a constant, with the literal's own shape as its type - a table is a struct with its keys as fields, an array an Array, a date-time an Instant

Checked

The document parses as TOML 1.0, and no key or table is defined twice.

#{ }

A TOML value - a string quoted and escaped, an array as [...], a struct as an inline table. Only in a value position, never a key or a table header.

A CSV table as a typed value, parsed at compile time.

Produces

Table<Row> - the header names the columns, which become Row's fields

Checked

The data parses as RFC 4180 CSV, the header's names are distinct, and every row has as many fields as the header. Each column's type is the narrowest that fits every value in it - S64, F64, Boolean, else String - optional when a field is empty.

#{ }

One field, quoted and escaped when it needs to be - a comma, quote or newline in the value can't add a column or a row.

A regular expression compiled at compile time. Flags are written inline, at the start of the pattern: (?i). A short one fits in a string instead: #regex"...".

Produces

Regex - compiled once, when the program compiles

Checked

The pattern compiles - so a bad pattern is a compile error rather than the ParseError Regex(pattern) returns - and named groups become typed fields of each Match.

#{ }

The value's text matched literally, as Regex.escape would make it.

Markdown rendered to HTML when the program compiles.

Produces

Html - the rendered document, the same type #HTML makes

Checked

The document parses as CommonMark, and any HTML inside it is well-formed.

#{ }

Escaped text - a value can't start a heading, a list or a link of its own.

A shell command line, with arguments passed safely.

Produces

Command - not run until run(), which goes through the process context

Checked

The command line parses: quotes balance, and pipes and redirections are complete.

#{ }

One quoted argument, whatever it contains - spaces, quotes or ; can't split it or start a second command.

An HTTP request - its method, URL, headers and body - written as it goes over the wire.

Produces

HttpRequest - not sent until send(), which goes through &http and gives a Promise<IOError ! Response>

Checked

The request line is a method and a URL - POST https://..., or the URL alone for a GET - the URL starting with http://, https://, / or a placeholder; every line up to the first blank one is a header, Name: value. What follows the blank line is the body, its indentation taken off.

#{ }

In the URL's path or query, the value's text percent-encoded - a /, ?, & or space can't change where the request goes. Before the path (#{ base }/todos) it's text as it is. In a header's value, text, a line break turned into a space so it can't start another header. A placeholder that's the whole body is the body itself - Bytes stay bytes, Json is its JSON text; in the middle of a body, its text.

Text with values in it: the string, with each #{ expression } replaced by that value's text. The same as joining the pieces with ++ and toString(), without writing them out - #format"#{ n } items" is n.toString() ++ " items".

Produces

String

Checked

Every placeholder is a valid expression, and its type implements ToString - a value that can't be turned into text is a compile error, not a runtime one.

#{ }

The value's own toString(). For a particular form, call a method inside the placeholder: #{ price.toString(2) } for two decimals, #{ n.toString(16) } for hexadecimal, #{ name.padEnd(10) } for a column.

A short regular expression, written as a string. The string's own escapes still apply, but one it doesn't know - \d, \b, \. - is kept as written, so a pattern rarely needs its backslashes doubled. Flags go inline, at the start of the pattern: (?i), from i, m and s. Matching is always by code point. For a long pattern, or one full of quotes, use #REGEX {{{ }}}, which takes the body as written.

Produces

Regex - compiled once, when the program compiles

Checked

The pattern compiles, each placeholder counted as literal text - so a bad pattern is a compile error rather than the ParseError Regex(pattern) returns.

#{ }

The value's text matched literally, as Regex.escape would make it.