Kawa, the Java-based Scheme system

Node:Record types, Next:Dynamic records, Previous:Objects Classes and Modules, Up:Objects Classes and Modules

The `define-record-type` form can be used for creating new data types, called record types. A predicate, constructor, and field accessors and modifiers are defined for each record type. The `define-record-type` feature is specified by SRFI-9, which is implemented by many modern Scheme implementations.

define-record-type type-name (constructor-name field-tag ...) predicate-name (field-tag accessor-name [modifier-name]) ... | Syntax

The form `define-record-type` is generative: each use creates a new record type that is distinct from all existing types, including other record types and Scheme's predefined types. Record-type definitions may only occur at top-level (there are two possible semantics for `internal' record-type definitions, generative and nongenerative, and no consensus as to which is better). An instance of `define-record-type` is equivalent to the following definitions: The type-name is bound to a representation of the record type itself. The constructor-name is bound to a procedure that takes as many arguments as there are field-tags in the `(`constructor-name`...)` subform and returns a new type-name record. Fields whose tags are listed with constructor-name have the corresponding argument as their initial value. The initial values of all other fields are unspecified. The predicate-name is a predicate that returns `#t` when given a value returned by constructor-name and `#f` for everything else. Each accessor-name is a procedure that takes a record of type type-name and returns the current value of the corresponding field. It is an error to pass an accessor a value which is not a record of the appropriate type. Each modifier-name is a procedure that takes a record of type type-name and a value which becomes the new value of the corresponding field. The result (in Kawa) is the empty value `#!void`. It is an error to pass a modifier a first argument which is not a record of the appropriate type. Set!ing the value of any of these identifiers has no effect on the behavior of any of their original values.

Here is an example of how you can define a record type named `pare` with two fields `x` and `y`:

         (define-record-type pare
           (kons x y)
           pare?
           (x kar set-kar!)
           (y kdr))

The above defines `kons` to be a constructor, `kar` and `kdr` to be accessors, `set-kar!` to be a modifier, and `pare?` to be a predicate for `pare`s.

         (pare? (kons 1 2))        --> #t
         (pare? (cons 1 2))        --> #f
         (kar (kons 1 2))          --> 1
         (kdr (kons 1 2))          --> 2
         (let ((k (kons 1 2)))
           (set-kar! k 3)
           (kar k))                --> 3

The Kawa compiler creates a new Java class with a name derived from the type-name. If the type-name is valid Java class name, that becomes the name of the Java class. If the type-name has the form `<`name`>` (for example `<pare>`), then name is used, if possible, for the Java class name. Otherwise, the name of the Java class is derived by "mangling" the type-name. In any case, the package is the same as that of the surrounding module.

Kawa generates efficient code for the predicate-name, accessor-name, and modifier-name functions. The constructor-name currently compiles into code using run-time reflection, but hopefully that will get fixed.