2.7 Object Types🔗ℹ

An object type is a kind of data type for opaque named values. Object types are similar to record types in that they both have an unordered set of fields and a keyword-based constructor. However, object types are intended for encapsulating behavior, not data. In support of this, object types have an automatic #:name field used to implement prop:object-name. Instead of printing their fields, instances of object types print like other named opaque values such as functions and ports and print only their names.

As a rule of thumb, if you want to simply bundle together data then use record types. But if you want to group together functions or other complex objects, and you don’t want to give users access to them, use object types. Examples of object types in Rebellion include converters, comparators, reducers, and transducers.

• constructor-id, which defaults to make-id — an object constructor that accepts one mandatory keyword argument for each field-id and one optional #:name argument, then constructs an instance with the given name. The name argument must be either an interned symbol or false (the default). If the name argument is false, then the constructed instance is anonymous and its printed representation will not include a name.

• 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 (including the automatically-added name field) — a field accessor function that returns the value for field-id when given an instance of the created type.

• accessor-id, which defaults accessor:id — an object 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.

Additionally, unless #:omit-root-binding is specified, the original id is bound to an object type binding for the created type.

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-object-implementation for more information about these parameters.

2.7.1 Object Type Information🔗ℹ

The optional predicate-name, constructor-name, and accessor-name arguments control the result of object-name on the functions implementing the type. If not provided, predicate-name defaults to name?, constructor-name defaults to make-name, and accessor-name defaults to accessor:name.

This function only constructs the information representing an object type; to implement the type, use make-object-implementation.

2.7.2 Object Type Descriptors🔗ℹ

The type descriptor for an object type contains two functions that implement the type:

• An object constructor that accepts one argument for each field of the object type and constructs an object instance.

• An object accessor that accepts an instance of the object type and an integer field index, then returns the value of the corresponding field.

These functions can be used to dynamically construct and inspect instances of arbitrary object 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 object: the per-field accessors created by define-object-type are merely convenient wrappers around this accessor.

2.7.3 Object Type Bindings🔗ℹ

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

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

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

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

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

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

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

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

• field ... — a pattern variable bound to the object’s field identifiers. This includes both the object type’s private fields and its name field.

• field-name ... — a pattern variable bound to the object’s field names, as quoted symbols. This includes both the object type’s private fields and its name field.

• field-keywords ... — a pattern variable bound to the object’s field names, as keywords. This includes both the object type’s private fields and its name field.

• field-accessor ... — a pattern variable bound to the object type’s per-field runtime field accessors. This includes accessors for both the private fields and the name field.

• private-field ... — a pattern variable bound to the object’s private field identifiers. The name field is not a private field.

• private-field-name ... — a pattern variable bound to the object’s private field names, as quoted symbols. The name field is not a private field.

• private-field-keyword ... — a pattern variable bound to the object’s private field names, as keywords. The name field is not a private field.

• private-accessor ... — a pattern variable bound to the object type’s per-field runtime private field accessors. This does not include an accessor for the name field.

• name-field — a pattern variable bound to the object’s name field identifier.

• name-field-name — a pattern variable bound to the object’s name field, as a quoted symbol.

• name-field-keyword — a pattern variable bound to the object’s name field, as a keyword.

• name-accessor — a pattern variable bound to the object type’s name field accessor.

2.7.4 Object Type Chaperones and Impersonators🔗ℹ