From: Matthew Flatt <>
Subject: [plt-scheme] 299.7
Date: Tue, 11 May 2004 10:00:10 -0700

The v299-tagged code for MzScheme and MrEd in CVS is now version 299.7.
(The exp-tagged coded remains version 206.1.)

This is an incomplete release. MzScheme has changed significantly
inside, and I have not yet updated the "Inside MzScheme" manual. Also,
the optional arguments to `make-input-port’ are likely to change yet
again for 299.8. We’re close to having a nice system for CML-style port
reading, but it’s not quite right.

For Scheme programmers who stay away from custom input and output ports
(or at least the optional arguments), 299.7 is in good shape.

A complete 299.8 should be ready within a week.


 * Moved most of `(lib "")’ has moved to `(lib "")’.
   The MzLib documentation is not yet updated.

 * The `break-enabled’ procedure no longer corresponds to a parameter.

   Changing the break-enable state implies a check for a suspended
   break, and this check is incompatible with the design of parameters,
   including the tail evaluation of `parameterize’ forms.

   The new `parameterize-break’ form, `current-break-parameterization’
   procedure, and `call-with-break-parameterization’ procedure are the
   break analogues of various parameter constructs.

 * Related to the `break-enabled’ change: If a `with-handlers’ handler
   is called to handle an exception, the handler is not called in tail
   position with respect to the `with-handlers’ form. The body is still
   in tail position.

   The new `with-handlers*’ form tail-calls a handler, but without
   breaks disabled.

   (As you may recall, 299.6 created a small mess for `with-handlers’.
   In retrospect, the mess pointed to the more fundamental problem of
   trying to make `break-enabled’ a parameter.)

 * The `object-wait-multiple’ family of procedures has been renamed to
   the `sync’ family. (I used a long name originally because I thought
   this would be an obscure function. After absorbing CML, I now know

   More specifically, `object-wait-multiple’ is now `sync/timeout’. The
   `sync’ procedure omits the timeout argument.

   The "waitable" procedures have been renamed to "evt" procedures in
   general, often dropping "make-". "Evt" stands for "synchronizable
   event". Several new event-generating procedures have been added.
   The table below shows the old and new names.

   The `make-wrapped-waitable’ procedure has been split into
   `convert-evt’ and `finish-evt’. The former calls the wrapping
   procedure with breaks disabled, but not as a tail call with respect
   to the `sync’ call. The latter tail-calls the wrapping procedure,
   but without disabling breaks.

            Old                        New
            ---                        ---
            object-waitable?           evt?
            waitables->waitable-set    choice-evt
            make-channel-put-waitable  channel-put-evt
            make-semaphore-peek        semaphore-peek-evt
            make-wrapped-waitable      convert-evt or finish-evt
            make-guard-waitable        guard-evt
            make-nack-guard-waitable   nack-guard-evt
            make-poll-guard-waitable   poll-guard-evt
            thread-dead-waitable       thread-dead-evt
            thread-suspend-waitable    thread-suspend-evt
            thread-resume-waitable     thread-resume-evt


 * Changed `make-custom-input-port’ to `make-input-port’, and changed
   `make-custom-output-port’ to `make-output-port’. Many details for
   creating custom ports have changed. Perhaps the only high-level
   effect, for now, is that the `peek-byte’, etc. procedures are no
   longer prohibited from peeking past "special" values in an input

   The `make-output-port’ protocol will probably not change further in
   v300, but the optional arguments to `make-input-port’ will likely
   change in 299.8. Also, the new `read-bytes-avail!-evt’ event creator
   may disappear in 299.8, to be replaced with something more general.

 * Added `call-with-semaphore’ and `call-with-semaphore/enable-break’.
   Since they introduce a continuation barrier, these functions can be
   faster than a `semaphore-wait’--`dynamic-wind’ combination.

 * Case-sensitivity is enabled by default (for `read’ and when reading

 * MrEd and MrEd-based applications might be noticeably more responsive
   on platforms with lots of registers (Sparc, PPC). MzScheme’s
   implementation of continuation barriers has changed to avoid a
   jmpbuf copy, and I think these barriers are introduced most often
   for GUI callbacks.