Flavors, classes, CLOS, and the Flavor Examiner

MIT CADR System 46

The historical source is the public System 46 snapshot at Git revision 8e978d7d1704096a63edd4386a3b8326a2e584af.

The System 46 tree preserves complete source for Describe Flavor. Its generated command lists and tags also establish Edit Methods, List Methods, Edit Combined Methods, and List Combined Methods, but the corresponding section source is absent. This page therefore does not project the later implementation details of those commands backward as System 46 fact.

Maintained LM-3 System 303

The runnable later release is backed by the maintained LM-3 System repository at Fossil check-in 4df393c68d7f083ce42d5c377039d26043cc18a9031ace28258dc97f4137eb91, tag system-303. This is public restoration work and is kept distinct from the historical System 46 snapshot.

The byte counts and hashes above are from the private read-only source copy made by the runtime session from that exact public check-in.

Licensed Genera 8.5 implementation

The Genera implementation observations use the locally purchased Open Genera 2.0 archive and the Genera 8.5 world it supplies. The source files remain ignored, are identified here only by release pathname, evacuated version, size, and hash, and are not linked or redistributed.

The intended public behavior is cross-checked against Symbolics's Program Development Utilities, Genera 8. The public manual and pinned source links were verified 2026-07-18.

CADR Flavors

System 46 represents a flavor with a named structure that records local and composed instance variables, component and dependent relationships, local method entries, initialization metadata, a package, and a composed select-method. DEFFLAVOR records the declaration. DEFMETHOD records methods; the source also supports wrappers and the usual before, primary, and after daemon pattern.

Composition is deliberately lazy. Creating an instance ensures that the flavor combination and method combination have been built, allocates an instance with an instance descriptor, establishes initial values, applies initialization keywords, and invokes initialization behavior. Redefining a method can selectively recompose the affected message; changing storage layout can leave existing instances attached to the old descriptor. Inspection is consequently not merely pretty-printing a declaration: it exposes computed component order and composed dispatch state.

VANILLA-FLAVOR supplies baseline printing, description, operation enumeration, and evaluation inside an instance unless :NO-VANILLA-FLAVOR is requested. DESCRIBE-FLAVOR reports direct components and dependents, any already-computed transitive components, instance layout, local methods by message and method type, automatic accessors, initialization metadata, arbitrary remaining properties, and the composed select-method when available.

The CADR entity/class facility is not CLOS

System 46's class.73 defines a separate older object facility:

• an entity instance is a closure over instance variables plus a class method symbol;
• the class method symbol's function cell contains a select-method;
• a class object is itself an entity, normally named by a symbol ending in -CLASS;
• redefining a class makes a new class method symbol, leaving older instances attached to their former class version; and
• a method local to one instance is implemented by creating a phantom subclass and transmuting that instance to it.

Its DEFCLASS, arrow-style message send, accessor generation, and class hierarchy are historically interesting, but they are neither ANSI Common Lisp DEFCLASS nor evidence that CLOS was installed on the CADR. ZWEI's List Methods deliberately searches this class hierarchy as well as the Flavors registry, which is why its manual says “classes and flavors.”

Genera New Flavors and CLOS

Genera's Flavors system retains components, mixins, instance variables, initializations, internal flavor functions, and combined handlers, but integrates them with named generic functions. An operation can be an explicit generic function, a traditional message, or a generic function declared compatible with a message. That is why the tools distinguish methods—the implementation view—from operations—the interface supported by an instance.

CLOS has a separate class precedence list, direct and effective slots, initargs, generic functions specialized on argument classes or objects, and effective methods. Genera's CLOS commands answer analogous questions, but their data types and algorithms are not aliases for Flavors. In particular, the manuals explicitly warn that CLOS and Flavors precedence algorithms can choose a different order when local constraints leave alternatives.

Complete release-bounded command lineage

There is no dedicated Flavor Examiner activity or System X registration in the inspected System 303 tree. These are editor tools. The lower-level DESCRIBE-FLAVOR function is also callable from Lisp, while ordinary DESCRIBE on the internal flavor record delegates to it.

Describe Flavor output and mouse behavior

System 46 and System 303 both show:

1. direct dependencies, direct inclusions, and direct dependents;
2. the computed full component list when available;
3. local and inherited instance variables and instance size;
4. local and inherited methods, grouped by defining flavor and operation;
5. before, primary, after, wrapper, and other method types;
6. generated getter/setter methods, initable variables, accepted init keywords, external access macros, and default initialization properties; and
7. unconsumed flavor properties.

System 303 improves the report rather than merely copying it. It composes the component list if necessary, handles arbitrary method types and :CASE suboperations, sorts several lists, wraps long lines, and uses package-aware printing. Flavor names and method function specifications are typeout items. Their menus can describe or edit the selected object; the default action normally enters the source-navigation path.

Possibilities navigation

All of the System 303 List commands use Zmacs's possibilities substrate. Each result line stores an executable object and a nesting level in the line property list, not just display text. The corresponding Edit command uses the same list but goes directly to definitions.

The combined-method command asks whether it should compose a handler whose methods are not yet composed. Its order is an implementation-derived approximation: wrappers, before methods, primary methods, after methods, then other method types. That order is valuable for navigation, but it is not a decompilation of the final combined function.

Mouse actions on semantic output

Flavor names, internal flavor records, method specifications, accessors, and even presented instances can translate into the flavor-name command family. Generic function records and method specifications can similarly translate into a generic function name. The same generated actions are installed for command-processor output and ZWEI output.

Click Right also exposes these as named menu actions rather than forcing the default gesture. The source contains a disabled attempted handler action for a generic function: unread command-processor arguments were not accepted by the substrate, so it is not counted as a working gesture.

Complete fixed menu

The first nine analysis entries invoke the Flavors commands. Function Arguments and Documentation are general development commands reused by the frame. Help can show the Examiner overview, interface, command summary, or one command's documentation. Clear Display asks for confirmation and clears the input and all three output histories. Refresh exists as a program command but is not a fixed menu entry in the inspected definition.

Left-clicking a menu command inserts its ordinary form into the command-input pane. Right-clicking inserts the command with editable keyword arguments. Typed command history remains scrollable. The frame's command table directly installs the ten Flavors commands plus editing, file, activity-selection, package, bug-report, and Help utilities; it does not inherit the entire global command table.

For a Flavors analysis command, the current result is written to the bottom-right history pane. Before the next result, the old current output is copied to the middle-right pane and the older result to the top-right pane, including its presentations and viewport position. A command outside the special analysis list uses a typeout window instead and is not added to that three-result comparison.

CADR findings

• Describe Flavor is computational: System 303 composes an uncomposed component list before showing it. A report can therefore populate cached flavor state.
• List Methods searches both the old class hierarchy and the Flavors registry. Treating every result as a flavor would be wrong.
• List Combined Methods may offer to compose a handler, then derives a navigation order from debugging metadata. It is not merely a text search.
• The possibilities buffer is executable navigation state stored on lines. Saving only its visible text would discard the actions and hierarchy.

Genera Flavors findings and limitations

• Indentation is capped at 40 percent of the output width; deeply nested trees deliberately reduce their indentation rather than running off the screen.
• Show Flavor Differences is explicitly experimental in the source and omitted from the frame menu even though it remains a usable CP and Zmacs command.
• In dependent-tree pruning, one predicate checks Initializations twice and omits Functions. With only :Functions requested, nonmatching branches can remain in the pruned traversal. This is a source-level behavioral defect, not a documented promise that the filter is exact.
• Detailed operation arglists for implicit generics and messages use a general heuristic rather than reconstructing the methods of the selected flavor.
• Requesting source from Show Flavor Handler calls a path whose own source comment says inherited combined methods are not returned. The schematic code should not be mistaken for a complete decompilation in that case.
• The frame's recent-result panes copy presentations as well as pixels/text. Older results remain semantic input to later commands.

Genera CLOS findings and limitations

• Show Class Initargs finalizes inheritance when necessary. Inspection can thus force a lazy class-finalization step.
• The implementation notes that Show Class Methods sorts by generic function but does not yet apply its preferred secondary ordering within each method group.
• Show CLOS Generic Function :Methods Detailed is accepted by the parser, but the inspected body treats it like any other true :Methods value; a former detailed-p distinction is commented out. The advertised choice does not produce a distinct detailed path in this version.
• :Brief superclass/subclass displays bypass the attached slot, initarg, and method matchers. The superclass command warns about some ignored match keywords, but this is not a general composable brief-plus-filter mode.

LM-3 System 303 Describe Flavor

Runtime observation: System E, Meta-X Describe Flavor, and TV:LISP-LISTENER produced this live report in the preserved System 303-0 band on 2026-07-18. The screenshot catches the first page at **MORE**; it establishes the visible breadth and pagination behavior, not that the first page is the whole report.

The report visibly showed direct components and one direct dependent, the entire computed component list, local and inherited instance variables, local and inherited methods grouped by contributing flavor, generated accessors, and initialization information. This matches the implementation's data flow. An exploratory Right click while the **MORE** pause was active caused no visible change and is not treated as proof against the source-defined item menu.

The ordered user-visible action sequence was: decline the boot time entry with Return; System E; Meta-X; type Describe Flavor; type TV:LISP-LISTENER; wait for output; capture; make the non-result exploratory Right click; and stop. No definition was edited and no world or public disk was saved.

Genera 8.5 Flavor Examiner

Runtime observation: Select X opened the Flavor Examiner, then three nonmutating commands inspected DW:PROGRAM-FRAME on 2026-07-18. The selected capture is published to establish the application's actual layout and semantic result rotation beside source/manual analysis; Symbolics retains interests in the licensed software, and inclusion implies no endorsement.

The initial frame visibly matched the source definition: the fixed thirteen-entry menu occupied the upper-left, a short built-in introduction and command prompt occupied the lower-left, and three empty result histories filled the right. The harness then entered, in order:

1. Show Flavor Components DW:PROGRAM-FRAME;
2. Show Flavor Instance Variables DW:PROGRAM-FRAME; and
3. Show Flavor Functions DW:PROGRAM-FRAME.

The first result displayed the full component chain down through FLAVOR:VANILLA. After the second command, that result moved to the middle-right history while the current instance-variable list appeared below it. After the third, the component result moved to the top, the instance-variable result to the middle, and the function list became current at the bottom. This directly confirms the three-generation rotation described by the implementation. It also confirms that Select X opens a dedicated frame rather than merely printing a report in the Listener.

Genera CLOS command surface

Runtime observation: after returning from the Flavor Examiner with Select L, the Listener accepted Show Class Superclasses Standard-Object and displayed the live CLOS precedence chain on 2026-07-18. The image is published to establish that the separate CLOS command surface is available in the base world; inclusion implies no Symbolics endorsement.

The result was CLOS:STANDARD-OBJECT, CLOS-INTERNALS::MESSAGE-PASSING-MIXIN, and T. This is intentionally a separate runtime observation from the Flavor Examiner: it confirms a CLOS command through the ordinary Command Processor and does not imply that CLOS classes are browsed in the Flavors-only frame.

Genera session provenance

The exact ordered input was Select X, the three Show Flavor commands above, Select L, and the Show Class command. No presented item was clicked, no source definition was opened or edited, and no object definition or world was saved.