5.3 Structure Type Properties
Generic Interfaces provide a high-level API on top of
structure type properties.
A structure type property allows per-type information to be
associated with a structure type (as opposed to per-instance
information associated with a structure value). A property value is
associated with a structure type through the
make-struct-type procedure (see
Creating Structure Types) or through the #:property
option of struct. Subtypes inherit the property
values of their parent types, and subtypes can override an inherited
property value with a new value.
Creates a new structure type property and returns three values:
a structure type property descriptor, for use with
make-struct-type and struct;
a property predicate procedure, which takes an
arbitrary value and returns #t if the value is a
descriptor or instance of a structure type that has a value for
the property, #f otherwise;
a property accessor procedure, which returns the
value associated with the structure type given its descriptor or
one of its instances; if the structure type does not have a
value for the property, or if any other kind of value is
provided, the exn:fail:contract exception is raised unless a second
argument, failure-result, is supplied to the
procedure. In that case, if failure-result is a
procedure, it is called (through a tail call) with no arguments
to produce the result of the property accessor procedure;
otherwise, failure-result is itself returned as the
If the optional guard is supplied as a procedure, it is
called by make-struct-type before attaching the property to a
new structure type. The guard must accept two arguments:
a value for the property supplied to make-struct-type, and a
list containing information about the new structure type. The list
contains the values that struct-type-info would return for
the new structure type if it skipped the immediate current-inspector
control check (but not the check for exposing an ancestor structure
type, if any; see Structure Inspectors).
The result of calling guard is associated with the property
in the target structure type, instead of the value supplied to
make-struct-type. To reject a property association (e.g.,
because the value supplied to make-struct-type is
inappropriate for the property), the guard can raise an
exception. Such an exception prevents make-struct-type from
returning a structure type descriptor.
If guard is 'can-impersonate, then the property’s
accessor can be redirected through
impersonate-struct. This option is identical to supplying
#t as the can-impersonate? argument and is provided
for backwards compatibility.
The optional supers argument is a list of properties that are
automatically associated with some structure type when the newly
created property is associated to the structure type. Each property in
supers is paired with a procedure that receives the value
supplied for the new property (after it is processed by
guard) and returns a value for the associated property (which
is then sent to that property’s guard, of any).
The optional can-impersonate? argument determines if the
structure type property can be redirected through impersonate-struct.
If the argument is #f, then redirection is not allowed.
Otherwise, the property accessor may be redirected by a struct