From: Matthew Flatt <mflatt@cs.utah.edu>
To: plt-scheme@fast.cs.utah.edu
Date: Mon, 17 Sep 2001 09:08:52 -0600 (MDT)
Subject: 199.22

The exp-tagged code in CVS for MzScheme and MrEd is now version 199.22.

The changes are significant:

 * Changed `define-struct’ so that it can cooperate with other
   syntactic forms, such as `match’ and `shared’.

   In addition to the old bindings,

      (define-struct <id> (<field-id> ...))

   now binds <id> to expansion-time information about the declaration,
   and the sub-typing form is now

      (define-struct (<id> <super-id>) (<field-id> ...))

   where <super-id> is the <id> from a previous `define-struct’ ---
   not an expression that produces a structure type descriptor.

   The changes break old code in several ways:

     - The binding for <id> might collide with other definitions.

     - Sub-typing declarations must be changed, usually by deleting
       `struct:’.

   The new `define-struct’ is slightly less powerful than the old one,
   though in ways that are unlikely to matter. For example, the new
   form cannot extend a structure type descriptor that is passed into
   a procedure.

   The advantage of the change is that forms like `match’ and `shared’
   can work properly with structures. For example, given the
   declarations

     (define-struct a (x y))
     (define-struct (b a) (z))

   The expression

     (match .... [($ a pat) ....])

   is a syntax error, because the structure type `a’ has two
   fields. But

     (match .... [($ a pat1 pat2) ....])
     (match .... [($ b pat1 pat2 pat3) ....])

   both work, and the structure types need not be declared as
   "transparent" (through a dummy inspector).

   The `struct’ module export form exports the <id> binding as well as
   the old ones, so that sub-typing declarations and `match’ forms
   work across module boundaries.

   The `struct’ signature form for `unit/sig’ introduces
   expansion-time information into importing units that immitates that
   of a `define-struct’ declaration. The information is currently
   limited, in that subtyping relations are not exposed and the actual
   structure type may have more fields than declared in the
   signature. But `match’ works with the partial information, for
   example, matching on as many fields as declared in the signature.

 * Changed loading to distinguish normal loads from module loads.

   When `require’ triggers a load to get a module definition, the
   loaded file must contain a single `module’ expression with the
   expected name, otherwise a helpful error message is reported. (The
   constraint on the file shape was always specified, but not directly
   enforced.)

   In addition, `module’ in the loaded file is always mapped to the
   primitive `module’ form, independent of the `module’ binding of the
   current namespace. (Thus, loading a file from source reliably
   mimics loading a compiled version of the file, and vice-versa.)

   A load handler or load extension handler now takes two argument
   instead of one: the filename and the expected module name. The
   expected module name is either a symbol, indicating that a module
   declaration is expected, or #f, indicating that the file need not
   contain a module (though it may). If the expected name is a symbol,
   the handler is responsible for checking that the file actually
   contains a `module’ declaration, and for mapping the loading
   `module’ identifier to the primitive `module’ form.

   Inside MzScheme: an extension is now obliged to define
   scheme_module_name(), in addition to scheme_initialize() and
   scheme_reload(). The scheme_module_name() function should return a
   module name symbol if the extension declares a module, #f
   otherwise.

 * `define-syntax’ is now allowed within `class’ and `unit’ bodies,
   analogous to embedded `define-syntax’.  However, local macros in
   `class’ cannot currently expand to procedure expressions that serve
   as methods.

 * EXPERIMENTAL: Added `#cs’ and `#ci’ prefixes for controlling
   case sentivity during `read’. The sequence `#cs’ can be used as a
   prefix for any expression to make symbols within the expression
   case-sensitive.  The `#ci’ prefix similarly makes symbols
   case-insensitive. For example,

      #cs(Apple #ciBanana Coconut)

    is the same as

     (|Apple| |banana| |Coconut|)

    whether `read-case-sensitive’ is set to #f or #t.

    For example, `#cs’ can be used in front of a `module’ expression
    so that the module body is implemented in a case-sensitive
    variant of MzScheme:

     > #cs(module m mzscheme (define Foo 1) (define foo 2) (provide foo Foo))
     > (require m)
     > foo
     2
     > |Foo|
     1

 * Removed the cursor% constructor that takes a filename (it never
   worked on any platform), and added a constrcutor that takes image
   and mask bitmaps, 16x16 monochrome.

 * `unit/sig’ struct type changed to `signed-unit’ to aviod conflicts
   (though it’s not clear that the structure type needs to be exposed
   anymore, anyway).

 * Changed result of `identifier-binding’ in the module case. It’s now
   a list of four elements, including the "nominal" source module and
   its export name for the identifier.

 * Changed ’origin tracking so that starts with the empty and adds new
   identifiers to the front of the list. See the manual for details.

 * Added `cons-immutable’, `list-immutable’, and `list*-immutable’,
   and removed `pair->immutable-pair’.

 * Added `compiled-module-expression?’ and `module-compiled-name’.

The MzScheme, MzLib, MrEd, mzc, and Inside MzScheme doc bundles have
been updated. The MzLib documentation now includes complete
documentation for `match’.

Matthew