This directory and its subdirectories contains software written by Ken
Haase.  The code includes a set of SCHEME utilities and TYPICAL, a
type system/representation language describe in MIT-TR-902.  All of
this is implemented in a minor superset of RRRS scheme; the superset
implements a few simple environment probing functions and (more
critically) an interface to primitives for implementing infinite
length bit strings.

The directory `plus' contains the extensions to C-Scheme and Jon Reeses
PSEUDOScheme implementation of SCHEME in Common LISP.  They should be
used as models for transport to other SCHEME dialects.  The file
bits.c in the `plus' directory also contains the C implementation of
CScheme's bit-string operations.  These maybe useful in porting to
C-based implementations.

The directories `utility' and `typical' contains some SCHEME utilities
and the type system TYPICAL (which uses these utilities).  Each of
these contains a file utility.scm or typical.scm which (for C-Scheme)
loads the relevant files in these packages (in the appropriate order).
These relevant files are stored in binary form for C-Scheme; the files
utility.mak and typical.mak construct these binaries by invoking SF
(and maybe, in the future, the compiler).

The `utility' directory contains the following files of interest:

*   mapfcns.scm
    This defines a variety of useful structure mapping functions for
    iterating over trees or lists which collating or collection
    results in various ways.

*   printout.scm
    This file implements an expression-based formatted printer; it is
    intended to replace facilities like Common LISPs FORMAT and uses a
    cleaner expressional format for specifying items and their
    display.  It is also extensible by the user in a straightforward
    way.

*   switches.scm
    Implements a facility for user-settable switches.  TYPICALs
    tracing, debugging facilities are enabled or disabled by such 
    switches.

*   mutable.scm
    Implements a facility for MUTABLE procedures which implement
    modifiable mappings from sets of objects to sets of objects.

*   tuple.scm
    Implements hash-consing for lists.  Essentially, it guarantees
    that (EQ? (TUPLE 'X 'Y 'Z) (TUPLE 'X 'Y 'Z)).

The `typical' directory contains the following files of interest:

*   typical.scm
    Defines the type system/representation package TYPICAL, which
    provides a combinator language for defining LISP predicates which
    places those predicates in a lattice of predicate subsumption.  It
    also does a lot of other things, most of which are documented in
    MIT-TR-922. 

*   test-suite.scm
    A test suite for TYPICAL.

*   class.scm
    Implements a `classifer' in TYPICAL (also described in MIT-TR-922)
    which takes a SCHEME object and runs procedures attached to its
    location in the lattice of known predicates.

*   df.scm
    Implements an `intelligent' description interface which determines
    relevant properties of an object based on its position in the
    lattice of known predicates.

*   ef.scm
    Implements an `intelligent' inspection interface which determines
    relevant properties and commands for an inspected object based on
    its position in the lattice of known predicates. 

In the future, an implementation of CYRANO (an automated discovery
program) will be made part of this release.




