DrScheme Release Notes
----------------------

Current Release: 0.41.
Release Date: April 16, 1996.

The following is a list of differences between this release and the
previous one.

Highlights
----------

A mail alias has been created for reporting bugs.  Bug reports for
DrScheme (and other PLT software) should be sent to:

    plt-bugs@cs.rice.edu

The error messages in DrScheme have been improved and should now be more
descriptive of the problem.

Several changes to the MzScheme language affecting the class system,
exceptions and macros have been made in release 0.41.  Many of the new
features are incompatible with the old system.

Classes
-------

`make-class’ and `make-class*’ have been replaced with `class’ and
`class*’.  `class’ looks a lot like `make-class’, but there are some
important differences:

1. The initialization procedure of `make-class’ is gone.  Instead, in
   `class’, there is always an implicit `lambda’ (really something like
   an `opt-lambda’).  As a result, the arguments to `make-object’ can be
   used in the ivar initialization expressions.

2. All ivars are intialized in order, even across clauses.

3. A new kind of clause is available: `sequence’ clauses evaluate
   expressions without assigning them to ivars.

4. The scope of `super-init’ includes all of the clauses now.  (It used
   to be only the initialization procedure.)

5. apply-super-init is gone. Use (apply super-init ...) instead.

For example, this expression:

  (make-class c%
    (private y)
    (public [x (lambda () y)])
    (lambda (v)
      (set! y v)
      (super-init)))

can now be written:

  (class c% (v) ; (v) is the arg list for the implicit lambda
    (private [y v])
    (public [x (lambda () y)])
    (sequence
      (super-init)))

or even better:

  (class c% (y)
    (public [x (lambda () y)])
    (sequence
      (super-init)))

This expression:

  (make-class d%
    (public [x 5]))

translates to:

  (class d% args
    (public [x 5])
    (sequence
      (apply super-init args)))

Since this happens a lot, mzlib’s `macros.ss’ defines `class-asi’ (auto
super init):

  (class-asi d%
    (public [x 5]))

(Here, `make-class’ was simply changed to `class-asi’.)

Default expressions can be provided for `make-object’ arguments
(`opt-lambda’ style):

  (class x% (a [b (add1 a)] [c (lambda (x) b)])
    ...)

Each default value expression is not evaluated when an argument is
supplied. The scope of all argument variables includes all default value
expressions (i.e., like `letrec’, while `opt-lambda’ is like `let*’).

Exceptions
----------

Errors are now always signaled using exceptions. The `raise’ procedure
takes any value and invokes the current exception handler with that
value. All primitive errors invoke `raise’ with an instance of the
struct type `exn’. There is always a current exception handler, just as
there has previously been a current error handler in MzScheme.  (The
current error display and escape handlers are still used by the default
eception handler). A `with-handlers’ form provides ML-like syntax for
handling exceptions in a subexpression.

Macros
------

`defmacro’ and `letmacro’ have been replaced with `define-macro’ and
`let-macro’. The only difference is that the implicit `lambda’ must now
be explicit:

(defmacro when (test . body)
  `(if ,test
       (begin
         ,@body)))

becomes

(define-macro when
  (lambda (test . body)
    `(if ,test
         (begin
           ,@body))))

mzlib’s `compat.ss’ defines macros for `defmacro’ and `letmacro’.

Package Macro
-------------

The `package’ macro in mzlib’s "macros.ss" has been renamed to
`define-some’ to avoid confusion with DrScheme’s `make-package’ form.

Error Messages
--------------

The error messages from MzScheme have been revised.  Hopefully, the
syntax error messages will now be more helpful.