Glossary

The terms these docs use, each with a short definition and a link to the page that explains it.

Async function: A function marked @async. Calling it returns a Promise at once, and inside it await pauses until another promise settles, letting other tasks run meanwhile. See Async.
Attribute: A @name, with optional arguments, written above a definition, statement, field or parameter to say what it's for - @main, @test, @get("/"). Any other name is plain metadata. See Attributes.
Block: Statements between { and }, each on its own line and indented two spaces further. Injections and defers belong to the block they're written in. See Block.
Body macro: A macro given raw text between {{{ and }}} - #SQL {{{ ... }}}. The Refingere parser skips the body, and the macro reads it. See Macros.
Chaining operator: A comparison-style operator that chains with others at the same precedence: a < b <= c means a < b and b <= c. See Operator Chain.
Component: A struct marked @component: a piece of a browser app with a render method, rendered again when one of its @state fields changes. The context interfaces' ready-made test replacements are also called components. See Servers and Browser Apps.
Compile time: While the program is being compiled, as opposed to while it runs. Macros and #comptime(...) code run then. See Compile-time Code.
Constraint: What a type parameter has to implement, written after it: T: Comparable. It decides what the generic code can do with values of T. See Interfaces.
Context value: A value read by name with &name and provided by code further up the call stack - &stdout, &clock, or one of your own. The only way code reaches the outside world. See Context.
Defer: A statement that runs an expression when the current block ends, however it ends. Attributes narrow it to some endings, such as @onError. See Resources and Memory.
Derive: Generating an interface implementation from a type's definition with @derive(Equatable, ToString), instead of writing it by hand. See Interfaces.
Destructuring: Taking a value apart into names as it's bound: let (a, b) := pair, function f({x, y}: Point). See Pattern Matching.
Elision: A bare ... in a list literal, standing for the elements left out between its neighbours - ["1", "2", ..., "15"]. See List Literal.
Embedded language: Another language's source written in a body macro - SQL, HTML, CSS, JSON, regular expressions and more - checked while compiling, with values inserted safely through #{ }. See Macros.
Enum: A type whose value is one of several named cases, each carrying nothing, values in order, or named fields. A tagged union. See Types.
Error union: A type written E ! T: an error of type E, or a value of type T. How a function says it can fail. See Errors.
Event loop: What runs @async code: a queue of tasks, run one at a time on one thread. When no task is due it sleeps &clock until one is, so a FixedClock makes waiting instant. See Async.
Generator: A function whose body contains yield. Calling it returns a lazy Iterator that runs the body a step at a time. See Functions.
Guard: An if condition after a match pattern, checked once the pattern matches: case n if n > 0 then. See Pattern Matching.
Implement block: implement Interface for Type { ... } - the bodies of an interface's members for one type, written separately from the type and visible in the whole project. See Interfaces.
Inject: Providing a context value for the rest of a block and everything called from it: inject clock := fixedClock. @inject, @injectLocally and @injectGlobally do it for a file, folder or project. See Context.
Interface: A named list of function declarations a type can promise to have. Used as a type for values of any implementing type, or as a constraint. See Interfaces.
Intrinsic: A single primitive operation the builtin types are built on, like adding two U64s - #builtin.intrinsic.ADD_U64_U64. See Intrinsics.
Lambda: A function without a name, written where it's used: λ(x) x * 2, or lambda(x) x * 2. See Functions.
Local: A top-level definition prefixed with local, visible only in its own file. global is the opposite: reachable from every folder by its path. See Files and Folders.
Macro: Code run while compiling, used with #name or as an attribute, that turns its input into code or a value in its place. See Macros.
Method: A function that belongs to a type and takes the value as its first parameter, self, called as value.name(). See Functions.
Overflow: An integer result that doesn't fit its type - an OverflowError for +, -, *, //, ^ and as; +%, -%, *% wrap around instead, and +|, -|, *| stop at the type's bounds. See Numbers and Overflow.
Path reference: A global definition named by its path in backticks - from the project root (`/storage/findOrder`) or from the current folder (`./reports/monthly`, `../storage/findOrder`). See Files and Folders.
Pattern: A shape a value is compared against in a match case - a literal, a type, an enum case, a struct or a tuple - binding names for its parts when it matches. See Pattern Matching.
Phase: The stage of compilation a macro runs at: Lex, Parse, Analyze or Typecheck. See @phase.
Policy: A plain context value that decides how builtin operations behave for the code under it - &hashSeed, &maxCallDepth and &stringNormalization - each with a default, and changed with inject. See Context.
Precedence: How tightly an operator binds, as a number - higher binds tighter, so * (80) applies before + (70). See Operators.
Project: The folder given to the compiler as root, and every .rfn file under it - one program. See Files and Folders.
Promise: A value that isn't ready yet - Promise<Type>, what an async function returns. It settles once, with a Type, and errors travel inside that value like anywhere else. See Promise.
Reject: A statement that removes the current block's own injection of a name, so reads see the value injected further out. See Context.
Route: A function marked @get, @post, ... or @route, answering HTTP requests for a method and path - it reads the request from &request and gives a Response. See Servers and Browser Apps.
Spread: ..xs inside a list literal, putting every element of xs in its place: [0, ..xs, 9]. See Collections.
String macro: A macro written directly against a string, with no space - #format"Hello, #{ name }!". The string is its input. See Macros.
Struct: A type made of named fields, built with Name{...}. Structs combine with && rather than inheriting - fields, implementations and methods. See Types.
Tuple: A fixed number of values of possibly different types, in parentheses: (1, "one"). See Collections.
Union: A type whose value is one of several member types - A | B, or named with union. Unlike an enum, it has no cases of its own: a match tells its members apart by type, with case String as s. See Types.