The record constructor Record creates a Maple record. Records are defined by their ``field'' names, each of which must be a Maple symbol. Two records are considered to be equal if they have the same field names and if, for each slot name n, the values of the fields named n in the two records are equal.

Like an Array, a record is a fixed-size collection of items but, like a table, individual items are addressable by name, rather than by a numeric offset.

Records are implemented in Maple as modules, all of whose variables are exported. The field names are just the module exports. Records are distinguished from modules, in general, by the presence of the record option.

Record takes one or more field specifiers as its arguments. A field specifier is a global name, a  expression whose first operand is a global name, or an equation whose left hand side is one of these two. For example, each of , ,  and  is a valid field specifier. The name part of the specifier is the `field name'' (a in these examples). A record having fields with the indicated names is returned. Field names cannot be repeated, and unevaluation (forward) quotes may be needed if the symbols used as field names happen to already be assigned values. If a field name has the same spelling as a local name within scope of a call to Record, then the  prefix will be needed on the field name to force the name to be bound globally. An equation is used as the field specifier to indicate an initial value for the corresponding record field. For example, the field a will be assigned the value  if the equation  is used.

To make it easier to construct records programmatically, the symbol in a record field specifier may also be passed to the Record constructor as a string. This avoids potential evaluation of field names that correspond to an assigned global variable.

As a special case, you can pass a single record argument to Record, which will copy it for you. (Note that the argument will normally need to be evaluated one level, since last-name evaluation applies to variables that have a record as a value.)

If the Record constructor function call is indexed, the indices must specify existing record(s). The new record will inherit all the field names of the specified records. Unlike the special case of a single record argument, indices that are variables with record values will automatically be evaluated.

A field specifier of the form  will elide the specified inherited field from the record being constructed.

The Record constructor function can be called with the indexed name Record[packed], which will produce a packed record.

Unlike a regular record, a packed record does not create a unique instance of each field name for each record instance. When working with thousands of similar records each with many fields, this can save a significant amount of memory and processing time.

Fields of packed records do not exhibit last-name evaluation. That is, the expression r:-a always produces a value, even if that value is a procedure, table, Matrix, Vector, or another record.

Similarly, it is not possible for a packed record field to have no value. The assigned function will always return true, and unassigning a packed record field will set its value to NULL instead.

When calling the Record constructor with one or more indices specifying existing records, the resulting record will automatically be a packed record if any of the prototype records were packed records.

This behaviour can be overridden, thus forcing the creation of non-packed records, by including the symbol record in the index of the Record constructor function.

You can use verify(...,record) to test the equality of two records.

Printing of records is governed by interface(max_record_depth). The setting of this interace option controls how deeply nested records are printed.

The Record command was updated in Maple 15.

The Record command is thread-safe as of Maple 15.

For more information on thread safety, see index/threadsafe.

receq := proc( a::record, b::record )
    description "test whether two records are equal";
    local    e;
    if { exports( a ) } = { exports( b ) } then
        for e in { exports( a ) } do
            if a[ e ] <> b[ e ] then
                return false
            end if
        end do;
        true
    else
        false
    end if
end proc: