2.3 Record Types🔗ℹ

A record type is a kind of data type for composite values that contain an unordered set of named fields. The definition of each record type declares how many fields it has and what their names are. Constructing an instance of a record type requires passing a keyword argument for each field to the type’s constructor. Record types are useful when a fixed number of different pieces of data together represent a single logical thing, and there isn’t an obvious order to those pieces.

• constructor-id, which defaults to constructor:id — a record constructor that accepts one mandatory keyword argument for each field-id and returns an instance of the created type.

• predicate-id, which defaults to id? — a predicate function that returns #t when given instances of the created type and returns #f otherwise.

• id-field-id for each field-id — an accessor function that returns the value for field-id when given an instance of the created type.

• accessor-id, which defaults accessor:id — a record accessor that accepts an instance of the created type and an integer indicating which field to access, then returns the value of that field.

• descriptor-id, which defaults to descriptor:id — the type descriptor for the created type.

• pattern-id, which defaults to pattern:id — a match expander that accepts one optional keyword and subpattern pair for each field and deconstructs instances of the created type, matching each field with its corresponding subpattern (if a subpattern for that field is given).

Additionally, unless #:omit-root-binding is specified, the original id is bound to a record type binding for the created type. The binding behaves like pattern-id when used in match patterns and like constructor-id when used as an expression. Use #:omit-root-binding when you want control over what id is bound to, such as when creating a smart constructor.

The prop-maker-expr is used to add structure type properties to the created type, and inspector-expr is used to determine the inspector that will control the created type. See make-record-implementation for more information about these parameters.

2.3.1 Record Type Information🔗ℹ

2.3.2 Record Type Descriptors🔗ℹ

Record types are implemented using structs, where the fields of the struct are always sorted by name. The type descriptor for a record type contains two functions that implement the type:

• A record constructor that accepts a mandatory keyword argument for each field of the record type and constructs a record instance.

• A record accessor that accepts an instance of the record type and an integer field index, then returns the value of the corresponding field. Record fields are always sorted alphabetically, and the field index corresponding to a given field name can be retrieved from the record type using the record-type-fields keyset.

These functions can be used to dynamically construct and inspect instances of arbitrary record types at runtime, assuming the type’s descriptor is initialized. Note that the descriptor contains a single accessor function that can access any field in the record: the per-field accessors created by define-record-type are merely convenient wrappers around this accessor.

2.3.3 Record Type Bindings🔗ℹ

A record type binding is a type binding for a record type. Record type bindings contain compile-time information about the record type’s name and fields, as well as runtime bindings for its predicate, type descriptor, and other runtime components. To extract a record type binding bound by define-record-type, use the record-id syntax class.

• type — an attribute bound to a compile-time record-type? value describing the type.

• binding — an attribute bound to the compile-time record-binding? value extracted from the matched identifier.

• name — a pattern variable bound to the record type’s name, as a quoted symbol.

• descriptor — a pattern variable bound to the record type’s runtime type descriptor.

• predicate — a pattern variable bound to the record type’s runtime type predicate.

• constructor — a pattern variable bound to the record type’s runtime record constructor.

• accessor — a pattern variable bound to the record type’s runtime record accessor.

• field ... — a pattern variable bound to the record’s fields, as plain identifiers.

• field-name ... — a pattern variable bound to the record’s field names, as quoted symbols.

• field-keyword ... — a pattern variable bound to the record’s field names, as keywords.

• field-accessor ... — a pattern variable bound to the record type’s per-field runtime field accessors.