accumulator A value that is updated on every pass through a loop, for instance in for/fold.
arity The number of input arguments accepted by a function, or the number of values returned by a function. Most commonly seen when you try to invoke a function with the wrong number of arguments: you will get an “arity error.”
association list A of . Used as a lightweight alternative to a . See also data structures.
boundary In the system, describes places where a contract can be applied. The most common contract boundaries are the module boundary (using contract-out) and the function boundary (using define/contract). See also contracts.
binding An association of a value with an . A binding can be made explicitly (e.g., with define) or implicitly (e.g., a require expression adds bindings to a program). A program cannot run unless every identifier has a binding, otherwise you get the famous “unbound identifier” error. See also identifiers.
calling site The place where a is invoked. See also macros.
character An integer-like data type—distinct from a string—that represents a single Unicode value.
coloring annotation Used by DrRacket to determine the syntax coloring for a chunk of code.
combinator In the contract system, a special set of helper functions used to build contracts.
compile time The stage of program evaluation when required are imported and are expanded, resulting in a . Compile time happens before .
composability The idea of making functions and data structures that are small, self-contained, and generic, and combining them to produce more complex behaviors. An important software-design principle in Racket, and generally.
continuation A function that encapsulates the location of an expression and its surrounding evaluation context. See also continuations.
contract An optional check on the input arguments or output values of a function. See also contracts.
control flow The path of evaluation within a program. For instance, ordinary are evaluated from the inside out. are evaluated from the outside in. allow control flow to jump from one point to another.
core syntactic form In a , a form that cannot be expressed in terms of more primitive forms. For a full list, see fully expanded programs in the Racket Reference.
datum The “literalized” version of an , usually created with quote or its equivalent, the ' prefix. The datum form of a single value is a single datum. The datum form of a parenthesized is a list of datums.
definition site The place where a is defined. As a result of , a macro retains the of its definition site, regardless of where it’s invoked. See also hygiene.
domain-specific language A tailored to the needs of a particular set of problems. The opposite of a . See domain-specific languages for examples.
ellipsis Does two things in a . First, when used after a in a , it greedily matches as many subsequent syntax objects as it can, and associates them with that pattern variable. Then, in a , it indicates that these matched elements should be handled the same way as the pattern variable. See also syntax patterns.
error An that’s raised when a problem occurs at . See also errors & exceptions.
evaluation The process of recursively reducing to yield a result. See also evaluation.
exception A message that immediately propagates upward through the chain of calling functions. Any of these functions can catch the exception and handle it, or let it continue upward. If it reaches the top, the program stops. Exceptions are typically used to handle , but can also be used to create alternative forms of . See also errors & exceptions.
exception handler A function that processes an exception, usually within a with-handlers expression. An exception handler might modify an exception, suppress it, or let it pass.
expander Used in a specific sense to mean the part of a Racket-implemented responsible for providing the initial for the code. It is, along with a , one of the two main parts of a Racket-implemented language. The term is also used in a general sense to mean the overall Racket subsystem that evaluates macros and produces a .
expression A program entity that can be evaluated to produce a value. Within Lisp languages, known as an . See also evaluation.
format string An argument provided to format and similar string-conversion functions that indicates how the other arguments should be converted to strings.
function A set of instructions that are not run until requested. Racket functions can take any number of and , and optionally a . Functions can also return any number of values. Functions can be named (if created with define) or anonymous (if created with lambda). See also functions.
functional programming A style of programming where are designed to be self-contained, operating only on their input arguments (rather than relying on ) and returning a value (rather than relying on ).
garbage collector The subsystem responsible for freeing blocks of memory no longer in use. The garbage collector runs automatically during a program. Frequently abbreviated as GC.
guard An expresssion that limits the iteration values of a loop, usually by testing the current iteration value with a . See also loops.
hash table A data structure that maps keys to values. Both the keys and values can be any kind of data. See also data structures.
here string Alternative string-input syntax that makes it easier to handle multiline strings and strings with special characters like ". See here strings in the Racket Reference.
hygiene The principle that adopt the of their (which is known in advance to the macro writer) rather than their (which is not). This eliminates the risk of name collisions between identifiers introduced by the macro and identifiers at the calling site. (A problem also known as identifier capture.) One can override hygiene by using an . See also the hygiene explainer.
identifier A name that can be to a value to produce a (for instance (define foo 42) makes a variable from the identifier foo). See also identifiers.
immutable Describes a data structure that can never be changed, like a pair. The opposite of . In , the use of immutable data structures helps enforce the broader policy of avoiding .
indenter A function used within DrRacket to indent lines of source code.
infix notation A nonstandard way of writing function expressions in Racket, with the function name between two dots, anywhere amidst the argument list (x1 . func . x2 x3). When a function name is written like this, it’s treated as if it appeared in the first position (func x1 x2 x3) i.e., as .
interposition points A set of special macros that wrap certain operations. See interposition points.
interned Refers to a data type like whose allocation and storage is specially managed by Racket so that each unique instance of that data type only appears once in memory. This means that interned values can be compared with the fastest comparison function (eq?) which relies on rather than value comparisons.
keyword argument A argument parsed by name rather than position. A keyword is prefixed with #:. See also functions.
lambda calculus Invented by Alonzo Church in the 1930s, the lambda calculus is a way of studying computable functions. In the 1950s, John McCarthy adapted the notation of lambda calculus to create the Lisp programming language. Racket is a descendant of Lisp, so the influence of this notation continues.
lexical context The set of defined at a certain point in a program. Every is associated with a lexical context that determines the meanings of variables in the code. This lexical context travels with the syntax object, ensuring that its variables have consistent meaning. See also hygiene.
lift A tool available during macro expansion that moves the result of a macro from its original location to somewhere higher in the program, often the top level of the enclosing module. See, e.g., syntax-local-lift-expression.
list The fundamental data structure of Racket. An ordered sequence of values. See also lists.
macro A that runs at , taking certain code as input and rewriting it to produce new code. Also known as a . See also macros.
metalanguage A Racket that can be chained to another to add features. It’s “meta” in the sense that it doesn’t do everything an ordinary language would. Rather, it does a few things, then passes the code along to the main language for the heavy lifting.
module The smallest organizational unit of code. All Racket code lives in a module. See also modules.
module language Racket lingo for a that uses the default , such as the br or racket languages. See also Module Languages in the Racket Guide.
package The basic unit of software distribution. See also packages.
parameter A special kind of function that approximates a global variable. See parameters.
path The location of a file on disk. See also paths.
pattern variable A named matcher within a or other pattern. See also syntax patterns.
phase A discrete stage in . See also and . See also evaluation.
port A generic interface for reading from, or writing to, a data source (like a string, device, or disk). Ports can be used incrementally—that is, you can read or write data a little at a time, rather than all at once. See ports in the Racket Reference.
preprocessor A used to layer extra functionality atop existing languages, such as the C preprocessor, which doesn’t look anything like C.
predicate A that takes any value and returns a Boolean. Generally used to test if a variable belongs to a certain class of items, like string? or list?. Commonly used with filter and . By convention, names of predicates usually end with ?.
programming language A notational system mutually intelligible to humans and computers. A programming language has two key ingredients: and . Within Racket, a programming language is implemented as a with two parts: a and an .
quasiquote Notation for making a that allows inner expressions to be selectively evaluated, and then either inserted or spliced into the surrounding list. See lists.
quasisyntax Similar to , but the result of each operation is a syntax object. See also quasisyntax.
recursion When speaking of , recursion is the idea of designing a function so that it completes its task by calling itself. When speaking of , recursion denotes a structure which can be nested indefinitely, for instance an . But these are two sides of the same coin, because a classic pattern of is using a recursive function to process a recursive data structure. See also recursion.
REPL Abbreviation for read–evaluate–print loop. A command line for evaluating Racket expressions. See also REPL.
rest argument An argument that captures the “rest” of the arguments passed to a function, after the and have been parsed. Used to make functions that can take any number of arguments, aka variadic functions.
sequence A data type that supports ordered retrieval of its elements. In practice, a sequence is not a distinct data type so much as an interface supported by other data types. For instance, , , and can all be used as sequences.
shadow When a implicitly overrides another binding that would otherwise be available. For example, all bindings outside a let expression are available within its body, but any identifiers bound at the top of the let will override them. For another example, if a binding is imported into a with require, and the module defines a binding with the same name, then the local binding takes precedence.
shape The internal nesting structure of an S-expression or set of S-expressions.
side effect Something that happens as a result of calling a function, other than a value being returned. In , side effects are used sparingly. of variables is a kind of side effect. Output functions like printf and displayln are side effects.
source-to-source compiler A that converts the of one language into the source code of another. All Racket-implemented languages are essentially source-to-source compilers from the source language to Racket. Also called a .
stack A data structure holding an ordered set of items that are added and removed from the same end (traditionally, these operations are known as push! and pop!). So named because it can be visualized as a vertical “stack” with the edits happening at the top. A Racket can be used as a stack.
statement A program entity that doesn’t return a value, like goto in BASIC. There are no statements in Racket, only .
submodule A that’s nested inside another module. Submodules can be nested to any depth. More importantly, loading a module does not automatically load its submodules, nor does loading a submodule automatically load its parent module. See submodules.
symbol A stringlike data structure that is . When converted to a , become symbols. See also stringlike types.
syntax This word is used in two ways. From a computer-science perspective, it refers to the surface of a . Within Racket (and within this book) it is refers to that represent chunks of program code. To distinguish the two, the first meaning is sometimes called . Within a Racket language, the implements the surface syntax.
syntax colorer Function used by DrRacket to apply colors to source code.
syntax context The program context of a , which includes and position within the . See also syntax objects.
syntax object A that represents program code, packaged with other metadata, such as and . Syntax objects are used primarily as the input and output format for . See also syntax objects.
syntax pattern A way of notating the of a syntatic form, used in for decomposing into their components and matching them to . See also syntax patterns.
syntax property A key–value pair attached to a . The key must be a symbol; the value can be anything. See also syntax objects.
syntax template A that appears within a definition or with-pattern form. Unlike an ordinary syntax object, a syntax template can refer to any defined . These references are automatically replaced with the underlying matched value. See also syntax patterns.
thunk A without arguments that wraps an expression to delay its evaluation. For instance, hash-ref optionally takes a thunk as input that will be evaluated only if the requested hash element isn’t found.
Turing complete Describes a that can be used to write every possible computer program. The is Turing complete, as is Racket. Many are not. But whether a language is Turing complete has no bearing on whether it is, in practical terms, useful. As Alan Perlis said: “Beware of the Turing tar-pit in which everything is possible but nothing of interest is easy.”
unbound An identifier that has no . A common problem in Racket programs is the “unbound identifier” error, which arises when not every identifier used in the program has a binding. See also identifiers.
unhygienic Describes a -created that’s deliberately introduced within a other than that of the macro itself (most commonly, the lexical context at the ). See also hygiene.
unit test A small, specific software test, often set up to run frequently & automatically during development. See also unit testing.
variable An that has been assigned a . See also identifiers.
vector A Racket data type that holds a sequence of values. Similar to a , but has better performance when random access to elements is needed. See also data structures.