Version 8.7, October 2022
Use Unicode 14.0 for character and string operations
Add grapheme operations, such as `string-grapheme-count`
CS: Add support for RV64G (RISC-V)
Add `(#%declare #:require=define)` to disable shadowing by definitions
Other bug repairs and other changes noted in the documentation

Version 8.6, July 2022
Change build to use Zuo
Add `equal-always?`
Add stencil vectors
Add support for Arm64 Windows
Other bug repairs and other changes noted in the documentation

Version 8.5, April 2022
Add a `-y`/`--make` flag to automatically create/update ".zo"s
Add error-message realms
Add `read-syntax-accept-graph`
Change `make-temporary-file` to have keyword arguments
Change `for` to support `#:splice` clauses
Enable user-specific adjustment of an installation name
Racket CS: support pb backend
Other bug repairs and other changes noted in the documentation

Version 8.4, January 2022
Add `file-or-directory-stat`
Expander: add "portal" syntax
Add `#%terminal` primitive module for editor support; using this,
 "xrepl" and "expeditor" provide an improved REPL by default
Change `set/c` to support random generation
CS: faster multiplication and division for some numbers
Other bug repairs and other changes noted in the documentation

Version 8.3, October 2021
Expander: remove syntax arming and disarming in favor of a simpler
 system of protected syntax operations
Expander: change internal-definition contexts to have an
 outside-edge scope and track their own use-site scopes
Expander: add `require` and `provide` support for binding spaces
Expander: don't propagate "original" from macro input to output,
 which restores the intended behavior as it worked before v7.0
Windows: repair single-instance executable mode
Windows: fix path handling to treat `*` and `?` as special
Change `unzip` to report errors for ill-formed archives, instead
 of silently ignoring certain errors
Add `error-syntax->string-handler`
Places: use `current-directory` value in created place
Other bug repairs and other changes noted in the documentation

Version 8.2, July 2021
CS: faster exact-rational arithmetic
Improve support for layered and tethered installations
Fix CS cross compilation and add documentation reference to
 the "raco-cross" package
Add `most-positive-fixnum` and `most-negative-fixnum`
CS: support for nonatomic allocation via ffi/unsafe
Other bug repairs and other changes noted in the documentation

Version 8.1, April 2021
Add ephemeron hash tables
Add support for "git+https://" packages sources
Changed Git package references to default to repo-indicated
 default branch (HEAD, roughly) instead of "master"
CS: compiler improvements, especially related to structures
Unix-style installation puts ".zo" files in "lib" instead
 of "share", since they're platform-specific for CS
CS: cross-compilation support in `raco exe`
CS: faster multiplication and division for very large numbers
ffi: added ffi/os-async-channel and support for callbacks
 that can raise exceptions on CS
Other bug repairs and other changes noted in the documentation

Version 8.0, January 2021
Racket CS is now the default variant of Racket
Add support for Apple Silicon Mac OS (AArch64)
Improve Racket CS parallel GC, improve various optimizations,
 improve weak `equal?`-based hash tables, improve hash-code
 calculations, add direct support for flvectors, and reduce
 the size of generated code by 10-30%
Add `#:unsafe` for `#%declare` in a module
Add 'os* and 'arch modes to `system-type`
Add `fx{+,-,*,lshift}/wraparound`
Fix `normal-case-path` on bad encodings, which previously could
 cause a corrupted preferences file to disable DrRacket
Other bug repairs and other changes noted in the documentation

Version 7.9, October 2020
Improve Racket CS place-local allocation, add parallel GC,
 and merge Chez Scheme GC support for incremental promotion
Change stack traces to suppress built-in functions
Use XDG filesystem conventions by default on Unix
Bug repairs and other changes noted in the documentation

Version 7.8, July 2020
Add unboxed flonum arithmetic to Racket CS
Add Racket CS improved GC accounting and 'incremental mode
Add Racket CS AArch32 and AArch64 support, including
 places/futures (which are not available in BC)
Bug repairs and other changes noted in the documentation

Version 7.7, April 2020
Add support for embedding Racket CS in other applications
Switch Racket CS immutable hash table to HAMTs, based on
 stencil vectors in the Chez Scheme
Bug repairs and other changes noted in the documentation

Version 7.6, January 2019
Bug repairs and other changes noted in the documentation

Version 7.5, November 2019
Re-license Racket code as well as most C code under a permissive
 license; see LICENSE for more details
Bug repairs and other changes noted in the documentation

Version 7.4, July 2019
Disabled single-flonum reading by default and added
 `read-single-flonum` and `single-flonum-available?`
Bug repairs and other changes noted in the documentation

Version 7.3, May 2019
Bug repairs and other changes noted in the documentation

Version 7.2, January 2019
Bug repairs and other changes noted in the documentation

Version 7.1, October 2018
Added sha1-bytes, sha224-bytes, and sha256-bytes
Bug repairs and other changes noted in the documentation

Version 7.0, July 2018
Replace the macro expander with a new, Racket-implemented expander
Add an initial implementation of Racket on Chez Scheme (in the
 source distribution)
Bug repairs and other changes noted in the documentation

Version 6.12, January 2018
Bug repairs and other changes noted in the documentation

Version 6.11, October 2017
Bug repairs and other changes noted in the documentation

Version 6.10, July 2017
Extract OS adapters to the "rktio" library
Bug repairs and other changes noted in the documentation

Version 6.9, April 2017
Bug repairs and other changes noted in the documentation

Version 6.8, January 2017
Bug repairs and other changes noted in the documentation

Version 6.7, October 2016
Bug repairs and other changes noted in the documentation

Version 6.6, July 2016
Bug repairs and other changes noted in the documentation

Version 6.5, April 2016
Bug repairs and other changes noted in the documentation

Version 6.4, January 2016
Changes noted in the documentation, including support for
 incremental garbage collection
Performance improvements and bug repairs

Version 6.3, October 2015
Bug repairs and other changes noted in the documentation,
 including substantial changes to the macro expander

Version 6.2, April 2015
Bug repairs and other changes noted in the documentation

Version 6.1.1, October 2014
Bug repairs and other changes noted in the documentation

Version 6.1, July 2014
Changed use-before-definition to be an error instead of producing
 an #<undefined> value
Removed the mzlib/class100 library

Version 6.0.1, April 2014
Moved detailed-change recording to documentation

Version 6.0, January 2014
Packages & collections: ----------
 Reorganized collections into packages
 Added 'config-dir mode for find-system-path
 Added PLTCONFIGDIR environment variable and -G/--config flag
 Removed -C/--links command-line flag
 Added links-file and links-search-dirs to config, enabling
  a search path of installation-wide link files, as well
  as pkgs-dir and pkgs-search-dirs
 Changed link-file handling to separate "user" and "shared" modes;
  removed 'links-file mode for find-system-path, PLTLINKSFILE
  environment variable, and -C command-line argument
 Removed "shared" links and package scope
 Add current-library-collection-links, find-library-collection-links
 Changed module search to use current-library-collection-paths
  before collection link files by default
 Changed use-user-specific-search-paths and use-collection-link-paths
  to affect only find-library-collection-paths and
  find-library-collection-links
 Added "share" directory, moved "pkgs" there
 Base user directoy paths on an installation name instead
  of the Racket version string
Runtime: ----------
 Added ARM support to JIT
 Added #%declare
 Cross-phase persistent modules must be declared with
  (#%declare #:cross-phase-persistent)
 Add configure-runtime submodule support, and changed
  racket/base to introduce a configure-runtime submodule
 Removed memq, memv, and member from #%kernel
Filesystem and environment variables: ----------
 Changed initialization of current-directory to use PWD
 Added current-environment-variables, environment-variables-ref,
  environment-variables-set!, environment-variables-names,
  environment-variables-copy, bytes-environment-variables-name?,
  string-environment-variables-name?, environment-variables?,
  and make-environment-variables
 Added current-directory-for-user, srcloc->string
 Added filesystem-change-evt, filesystem-change-evt?, and
  filesystem-change-evt-cancel
 Added 'fs-change mode to system-type
 Move explode-path from racket/path to racket/base
 Changed read-on-demand-source to support #t
 Added current-module-path-for-load, exn:fail:syntax:missing-module, 
   exn:fail:filesystem:missing-module, prop:exn:missing-module,
   exn:missing-module?, and exn:missing-module-accessor
 Changed string->path-element and bytes->path-element to raise an
  exception for an empty [byte-]string argument
 Changed path-replace-suffix to raise an exception when a path element
  would be made empty
 Changed syntax-local-lift-context to distinguish top-level environments
Datatypes: ----------
 Added hash-clear, hash-copy-clear, hash-clear!, and hash-empty?
 Allow hash table chaperones and impersonators to support efficient
  hash-clear and hash-clear!
 Added path<?, symbol<?
 Added flrandom and unsafe-flrandom
 Added chaperone-channel and impersonate-channel
 Removed restriction against handle-evt? arguments to wrap-evt,
  handle-evt. and chaperone-evt
 Added identifier-binding-symbol
 Changed equal? to work on module path index values
 Added call-with-default-reading-parameterization
Commands: ----------
 Changed ".plt" file unpacking to require certain literal S-expression
  patterns, instead of evaluating S-expressions from the archive
 raco link: -u/--user mode installs a version-specific link,
  added -s/--shared for user-specific, all-version links
 raco setup: added --no-pkg-deps and --fix-pkg-deps
 raco pkg install: --link is default for directory source; added
  --copy
 raco pkg install: changed to install the current directory as a link
  when no arguments are provided; added --pkgs
Libraries: ----------
 racket/base: added an equality checking argument to member
 racket/class: fixed a bug in is-a? that changes its behavior 
  slightly: in the past it could return #f when the second argument
  was invalid; now it signals an error
 racket/file: make-directory* never fails on existing directories
 racket/file: added call-with-atomic-output-file
 racket/file: changed {copy/delete}-directory/files to raise
  "not dir or file" as exn:fail:filesystem
 racket/contract: added channel/c, added #:chaperone specification
  in struct/dc, added immutable hashes to printable/c, added 
  #:omit-constructor to contract-out, misc improvements to opt/c
 racket/contract: added channel/c
 racket/serialize: changed serializable-struct, etc. to provide
  deserialized-info:... through a derialized-info submodule
 racket/sandbox: added sandbox-make-environment-variables
 racket/sandbox: added with-limits
 racket/runtime-path: added runtime-require
 racket/runtime-path: added version support to 'so form
 racket/runtime-path: special handling for paths that
  correspond to collection-file-path results, instead of
 paths that are relative to the main "collects"
 racket/class: fixed is-a? so that it always signals an error when
  its second argument is not a class or interface
 racket/rerequire: added
 racket/require-syntax: added syntax-local-require-introduce
 racket/path: added shrink-path-wrt
 racket/provide-syntax: added syntax-local-provide-introduce
 racket/place: allow keywords as place messages
 racket/system: add a #:set-pwd? argument to system, etc., which
  makes them set PWD by default
 syntax/unsafe/for-transform: added
 setup/setup: changed setup to return a boolean
 setup/dirs: added find-config-dir
 setup/path-to-relative: added <pkg> results
 setup/dirs: added find-share-dir, find-user-share-dir, and more
 setup/infotab: removed string-constants require as an allowed form
 setup/collects: added
 setup/collection-name: added
 pkg/path: added, re-exported by pkg/lib
 net/url: add support for HTTP/1.1 connections
 net/url: add Host: and Content-Length: headers to HTTP requests 
  (if they are not already included)
 xml: added a #:insert-newlines? argument to write-xexpr
 ffi/unsafe: added array-type and in-array
 ffi/unsafe/objc: add -A and +A method modes
 mrlib/terminal: new library

Version 5.3.4, April 2013
Added extflonums
Added file-truncate
Added impersonate-ephemeron
Added 'so-mode mode for system-type
Changed syntax-case, etc. to support box patterns
Change sync, wrap-evt, and handle-evt to support multiple
 evt results
Added port-counts-lines?
Added cross-phase persistent module inference and instantiation
 and module-compiled-cross-phase-persistent?
racket/kernel: removed #%top-interaction
racket/kernel/init: added
racket/extflonum: added
racket/unsafe/ops: added extflonum operations
racket/date: changed current-date to provide nanoseconds,
 added date*->seconds
racket/udp: added multicast support: udp-multicast-join-group!,
 udp-multicast-leave-group!, udp-multicast-interface,
 udp-multicast-set-interface!, udp-multicast-set-loopback!,
 udp-multicast-loopback?, udp-multicast-set-ttl!,
 udp-multicast-ttl, and added reuse? argument to udp-bind!
ffi/unsafe: changed ffi-lib to use (system-type 'so-mode)
ffi/unsafe: added _size, _ssize, _ptrdiff, _intmax, _uintmax
ffi/vector: added f80vectors
compiler/zo-structs: added flags field to mod
slideshow: added interactive
slideshow/balloon: added balloon-enable-3d
slideshow/pict: added color% objects to text-style/c
scribble: 'toc-hidden style on a part no longer hides ToC
 entries for sub-parts when rendering as HTML
scribble/manual: added #:id option to defthing
scribble/srcdoc: added begin-for-doc, struct-doc, and struct*-doc
 added #:omit-constructor argument to defstruct and defstruct*
scribble/eval: extended make-base-eval to be more like
 make-evaluator
scribble/latex-properties: added command-extras
scriblib/figure: add #:continue? option
syntax/datum: Changed datum-case to support box patterns
racket/gui/base: moved warp-pointer from canvas<%> to
 window<%> and restored its functionality
racket/gui/base: changed menu-bar% get-frame method to
 return 'root for root menu bar
syntax-color: added special support for dont-stop values;
 this change is backwards incompatible for code that calls
 lexers and may call unknown lexers
syntax-color/racket-lexer: added 'hash-colon-keyword 
 (which also affects syntax-color/scheme-lexer,
  syntax-color/module-lexer, and syntax-color/scribble-lexer)
srfi/19: made compatible with date* structs, produces
 lax-date struct for backwards compatibility

Version 5.3.3, February 2013
No changes

Version 5.3.2, January 2013
Changed case to use equal? instead of eqv?
Changed log-message to support a name argument
Changed the synchronization result of a log receiver to include an
 event name
Added exn:fail:filesystem:errno and exn:fail:network:errno
Added phantom byte strings
Added 'word mode to system-type
Added arguments to impersonate-prompt-tag and chaperone-prompt-tag
 to support interposition on non-composable continuation results
Add #fx() and #fl() reader forms for flvectors and fxvectors
racket/unsafe/ops: added unsafe-cons-list
racket/gui: added get-current-mouse-state, and added
 display-changed to frame%
racket/serialize: fxvectors and flvectors are serializable
racket/net: added uri-path-segment-unreserved-encode
racket/url: added current-url-encode-mode
racket/date: fixed 'iso-8601 date formatting
scribble/tag: added
scribble/base: added make-section-tag, taglet?
r5rs, r6rs: fixed case and cond to disallow internal definitions
 in clauses
ffi/com: added com-get-property*
file/untar: added
file/untgz: added
file/unzip: added
compiler/zo-structs: generalize flonum? field to type
 field in localref, let-one, and fun 
compiler/zo-structs: added a constantness field to module-variable

Version 5.3.1, October 2012
Changed make-log-receiver to accept a logger name as an
 event filter
Addded define-logger
Changed -W, -L, PLTSTDERR, and PLTSYSLOG to support log
 filters of the form "<level> <name>=<level> ..."
Changed log-error, etc., to support format mode
Changed case to dispatch in logarithmic time
Added racket/format, which is re-exported by racket
Added #:break and #:final clauses to for forms
Added exn:break:hang-up and exn:break:terminate, added
 extra argument to break-thread and place-break, and
 redirect SIGTERM and SIGHUP as breaks
Add #:fill option to for/vector, for*/vector, for/flvector,
 for*/flvector, for/fxvector, and for*/fxvector
Added PLTCOMPILEDROOTS and --compiled/-R command-line flag
Added reroot-path
Changed a thread's initial prompt to use the default handler
 (instead of accepting and ignoring abort arguments)
ffi/unsafe: added cpointer-gcable?
racket/class: added dynamic-get-field and dynamic-set-field!
racket/set: added set-first and set-rest, sets are streams
racket/require-transformer: an import's module path can be syntax
scribble/base: add items/c
scribble/decode: add spliceof
syntax/for-body: added

Version 5.3, August 2012
Added submodules, including module*
Changed the format of error messages
Added raise-argument-error, raise-result-error,
 raise-arguments-error, raise-range-error
Added impersonate-continuation-mark-key,
 chaperone-continuation-mark-key, make-continuation-mark-key,
 continuation-mark-key?, impersonate-prompt-tag, and
 chaperone-prompt-tag
Added progress-evt?, thread-cell-values?, prefab-key?,
 semaphore-peek-evt?, channel-put-evt?
Fixed handle-evt to disallow a handle-evt
Added variable-reference->module-path-index
Added syntax-local-submodules, module-path-index-submodule,
 and module-compiled-submodules
Changed module-path-index-join to support a submodule argument
Changed module-path? to report #t for paths
Changed resolved module paths to allow lists that represent
 submodule paths; see the revised contract on resolve-module-path-name
Changed the module name resolver protocol so that a module declaration
 always triggers a notifification, and a notification supplies
 a source namespace (i.e., an extra argument) for attaches
Changed the load/use-compiled handler protocol to subpport a submodule
 module
Changed current-write-relative-directory to support a pair
 of paths: relative-to and base
Changed local-expand to not add core forms if the stop list has
 just module*
Changed modules instantiation so that requires are instantiated
 in the order that they are required
Changed #lang for most languages so that it cannot be nested;
 this change is within syntax/module-reader and applies to
 racket, racket/base, and more
Added relative-in
Added box-cas!
Changed contract on date second field to disallow 61, since
 leap seconds never appear more than once per minute
Changed guarantee of portability of current-seconds
 and file-or-directory-modify-seconds
Changed impersonate-struct so that accessor impersonation
 works only if the field is accessible via the current impersonator
 or a mutator for the same field is also impersonated
Added racket/future to re-exports of racket
racket/contract: added procedure-arity-includes/c, prompt-tag/c,
 and continuation-mark-key/c
racket/control: added call/prompt, call/comp, abort/cc and
 allow #:tag argument for % and f-control
racket/future: handle internal stack overflow without
 necessarily blocking on process 0; added 'overflow and
 'start-overflow-work log events
racket/list: added optional arguments to add-between, including
 #:splice?, #:before-first, #:before-last, and #:after-last
racket/math: added degrees->radians, radians->degrees, nan?,
 infinite?, exact-round, exact-floor, exact-ceiling, exact-truncate
racket/flonum: added flexpt
racket/unsafe/ops: added unsafe-flexpt
ffi/unsafe: changed ffi-lib to open libraries in local mode by
 default; integer-type bounds are now consistently checked; 
 added prop:cpointer
racket/draw: added record-dc%, make-color, make-brush, and 
 make-pen; treat a face as a Pango font description
 only when it contains a comma
racket/gui: changed open-output-text-editor to by default deliver 
 content via the current eventspace's handler thread; also
 added an #:eventspace optional argument
ffi/com: added
mysterx: removed ActiveX support plus com-add-ref and 
 com-ref-count; use ffi/com, instead
compiler/zo-structs: added a context field to all-from-module,
 added a cancel-id field to phase-shift, added pre-submodules 
 and post-submodules field to mod, changed name field to allow
 a list of symbols
racket/sandbox: added sandbox-propagate-exceptions; added
 sandbox-gui-enabled and sandbox-make-namespace; deprecated gui?,
 which is no long used internally; changed the default for
 sandbox-namespace-specs to sandbox-make-namespsace
racket/cmdline: add #:ps for command-line
slideshow/start: run a `slideshow' or `main' submodule, if any
scribble/eval: added eval:result and eval:results
racket/system: improved error messages by replacing memv expressions
 with string-no-nuls? and bytes-no-nuls?

Version 5.2.1, January 2012
Changed I/O scheduling to use epoll()/kqueue() when available
Cross-module inline trivial functions, plus map, for-each,
 andmap, and ormap; 'compiler-hint:cross-module-inline hint
Intern numbers, characters, strings, byte strings, and regexps in
 read and datum->syntax
Added datum-intern-literal
Regexps are `equal?' when they have the same source [byte] string
 and mode
Added pseudo-random-generator-vector?
Added port-closed-evt
Generalized gcd and lcm to work on rationals
Added module-predefined?
Added optional #:fail argument to collection-file-path and
 collection-path
Changed the racket -k command-line flag
racket/class: added send/keyword-apply and dynamic-send
racket/draw: added get-names to color-database<%>
mzlib/pconvert: added add-make-prefix-to-constructor parameter,
 which changes the default constructor-style printing in DrRacket
 to avoid a make- prefix; the HtDP languages set the parameter to #t
at-exp, scribble: dropped distinctness of @{}-introduced newline strings
racket/draw: add text-outline to dc-path%
net/mime: allow any subtype in input; made exception structs a
 subtype of exn:fail
compiler/zo-structs: added inline-variant
racket/stream: added stream constructor
racket/draw: treat a face as a Pango font description

Version 5.2, November 2011
Generalized begin-with-syntax to allow phase-N definitions,
 both variable and syntax, within a module for all N >= 0;
 removed define-values-for-syntax from fully expanded forms;
 added begin-with-syntax to fully expanded forms
Changed the location-creation semantics of internal definitions
 and letrec-syntaxes+values (to make them more let-like)
Added support for the collection links file, including
 (find-system-path 'links-file) and the raco link command
Added exn:fail:syntax:unbound
Added date*, which extends date to include nanoseconds and a 
 time zone name
Changed seconds->date to accept a real number return a date*
Added set-port-next-location! and changed the default prompt 
 read handler to use it when input and output ar terminals
Changed syntax-local-module-defined-identifiers to return
 a table for all phases instead of just two values
Add syntax-transforming-module-expression? and
 variable-reference->module-base-phase
Added variable-reference->module-declare-inspector, which allows
 a macro or other syntax tool to get the enclosing module's
 declaration-time inspector for taint operations
Added syntax-shift-phase-level
Removed built-in support for Honu reading and printing
racket/unsafe/ops: added unsafe-list-ref and unsafe-list-tail
ffi/unsafe: added support for C arrays and unions
ffi/unsafe: changed define-cstruct to use an interned symbol tag,
 which means that it is not generative
racket/place: added place* and dynamic-place* to specify the input, 
 output, and error ports to use for a new place
racket/place: cpointers, file-stream ports, and TCP ports can be
 sent across place channels
racket/gui: moved set-icon method from frame% to
 top-level-window<%>
racket/gui: removed unsupported MDI styles and method
errortrace: with-mark and make-st-mark now take a phase level
compiler/zo-structs: removed def-for-syntax, added
 seq-for-syntax, changed some mod fields, added field to
 def-syntaxes
net/url: added support for redirections to get-pure-port
planet: made the planet module-name-resolver thread-safe, and
 fixed planet to use already-downloaded .plt files (when present)
framework: the finder get-file and put-file dialogs no 
 longer normalize their results
framework: added to the testing library so that tests can be
 run when ignoring focus information from the underlying OS
compiler/cm: added support for using more powerful 
 security-guards when writing to the filesystem
mrlib/include-bitmap: adjust include-bitmap so it does not 
 write to the filesystem
Removed the Racket-to-C compiler: raco ctool -e/-c, mzc -e/-c,
 compile-extensions, compile-extensions-to-c, compile-c-extensions,
 compiler/cffi, compiler/comp-unit,  compiler:inner^, and most 
 options in compiler/option
The The `lazy' language is now based on `racket' instead of `mzscheme'.
 Specifically, it now uses modern `require's and `provide's.

Version 5.1.3, August 2011
No changes

Version 5.1.2, August 2011
Replaced syntax certificates with syntax taints:
 Added syntax-tainted?, syntax-arm, syntax-disarm, syntax-rearm,
  syntax-taint, and syntax-protect
 Changed syntax-recertify and syntax-local-certifier to
  have no effect on the target syntax object
 Changed syntax-rules and syntax-id-rules to use
  syntax-protect implicitly
 Changed the way inspectors are associated to syntax objects
  and variable references in compiled code
Changed "sequence" to include exact nonnegative integers
Added #:unless clause to for
Changed procedure-arity-includes? to report #f for keyword-requiring
 procedures by default
mzlib/contract: removed (undocumented) exports:
  chaperone-contract-struct?
  contract-struct-first-order
  contract-struct-name
  contract-struct-projection
  contract-struct-stronger?
  contract-struct?
  flat-contract-struct?
  make-opt-contract/info
  opt-contract/info-contract
  opt-contract/info-enforcer
  opt-contract/info-id
  synthesized-value
  unknown?
Changed assoc to accept an optional equality predicate
racket/function: added identity, thunk, thunk*, compose1
racket/require: added multi-in
slideshow/pict: added rotate function, and added sxy anf syx
 fields to a child structure
compiler/zo-struct: removed certificate structures; changed
 wrapper to have a tamper-status field instead of certs;
 added toplevel-map field to lam

Version 5.1.1, May 2011
Enabled single-precision floats by default
Added single-flonum?
Changed eqv? so that inexacts are equivalent only when they
 have the same precision
Changed file-or-directory-permission to add 'bits mode
 and permission-setting mode
Added special treatment of void as an 'inferred-name property
Removed the "MrEd" compatibility executable under Windows
 and Mac OS X, but the "mred" compatibility script remains
racket/gui: added multi-column support to list-box%
racket/gui: added scrollbar support to panel%, vertical-panel%,
 and horizontal-panel%
racket/gui: added 'wheel-left and 'wheel-right events
racket/file: add user-read-bit, etc.
racket/contract: removed the following (undocumented) exports:
  build-flat-contract
  chaperone-contract-struct?
  contract-struct-first-order
  contract-struct-name
  contract-struct-projection
  contract-struct-stronger?
  contract-struct?
  contracted-function
  contracted-function-ctc
  contracted-function-proc
  contracted-function?
  first-order-get
  first-order-pred?
  first-order-prop
  flat-contract-struct?
  flat-get
  flat-pred?
  flat-prop
  make-opt-contract/info
  name-get
  name-pred?
  name-prop
  opt-contract/info-contract
  opt-contract/info-enforcer
  opt-contract/info-id
  proj-get
  proj-pred?
  proj-prop
  stronger-get
  stronger-pred?
  stronger-prop
  struct:contracted-function
  synthesized-value
  unknown?

Version 5.1, February 2011
Renamed "proxy" to "impersonator"
Added current-get-interaction-input-port, which enables
 racket/gui events to be dispatched while a REPL is blocked
Changed equal? to equate C pointers when they refer to the 
 same address
Internal: weak boxes are cleared before non-will-like
 finalizers; use late-weak boxes to get the old behavior

Version 5.0.2, October 2010
Changed body of `when', `unless', `cond' clauses, `case'
 clauses, and `match' clauses to be internal-definition contexts
Swapped unsafe-vector*-ref with unsafe-vector-ref, etc.
Added ->i to the contract library, improved ->*, adding #:pre and
 #:post, as well as making the optional arguments clause optional.
Added #true and #false, and changed #t/#T and #f/#F to
 require a delimiter afterward
Added print-boolean-long-form
Added read-accept-lang, which is set to #t when 
 reading a module
Added flonum?
Changed continuation-marks to accept a #f argument
 to produce an empty set of marks
Added fxvectors
Added unsafe-{s,u}16-{ref,set!}
Added prop:proxy-of
Added proxies to go with chaperones, and renamed chaperone property
 as proxy property; beware that the word "proxy" will change in
 a future version, perhaps to "impersonator"
Added collection-file-path and collection splicing at the file
 level

Version 5.0.1, July 2010
Continuation barriers now block only downward continuation jumps
 and allow escapes through full continuations
Changed internal-definition handling to allow expressions mixed
 with definitions
Added support for subprocesses as new process groups
Added support for best-effort termination of subprocess by a
 custodian
Added flreal-part, flimag-part, make-flrectangular, and unsafe
 variants
Added fl->eact-integer, fl->fx, and unsafe-fl->fx
Added #:async-apply option to _fun
Added chaperone-evt
Added identifier-prune-to-source-module
Changed apply binding to enable lower-level optimizations
Upgraded to libffi 3.0.9+

Version 5.0, May 2010
Changed the core executable from mzscheme to racket
Changed paths like the preferences file to use "racket" instead
 of "mzscheme" or "plt-scheme"
Changed default value printer to use quasiquote style
The language of a program's main module can specify run-time
 configuration actions, such as setting the default printer's
 style
Changed regexp-match* et al. to make ^ matching relative to the
 original string (not substrings for matches after the for) and to
 allow empty matches in all positions except immediately after an
 empty match
Changed regexp-match and other functions to allow a path as
 an input
Added chaperones

Version 4.2.5, March 2010
Added scheme/future, enabled by default on main platforms
Changed module to wrap each body expression in a prompt
Changed define-cstruct to bind type name for struct-out, etc.

Version 4.2.4, January 2010
Added scheme/flonum and scheme/fixnum
Extended scheme/unsafe/ops
Changed JIT to support unboxed local binding of known-flonum
 arguments to unsafe-fl functions
Changed JIT to inline numeric ops with more than 2 arguments
Added #:save-errno option for foreign-function types
Added module->imports and module->exports

Version 4.2.3, November 2009
Changed _pointer (in scheme/foreign) to mean a pointer that does not
 refer to GCable memory; added _gcpointer
Added scheme/vector

Version 4.2.2, September 2009
Added scheme/unsafe/ops
Added print-syntax-width
Added file-or-directory-identity
Inside: embedding applications should call scheme_seal_parameters
 after initializing parameter values (currently used by Planet)

Version 4.2.1, July 2009
Added string->unreadable-symbol and symbol-interned?
Added syntax-local-lift-provide
Added syntax-local-lift-values-expression
Added identifier-prune-lexical-context and quote-syntax/prune

Version 4.2, May 2009
Changed visiting of modules at phase N to happen only when compilation
 at phase N starts
Changed expander to detect a reaname transformer and install a
 free-identifier=? syntax-object equivalence
Changed provide to convert an exported rename transformer to its
 free-identifier=? target
Added 'not-free-identifier=? syntax property to disable free-identifier=? 
 propagation through a rename transformer
Added prop:rename-transformer and prop:set!-transformer
Fixed scheme/local so that local syntax bindings are visible to later
 local definitions
Changed current-process-milliseconds to accept a thread argument
Added hash-hash-key?, hash-ref!
Added in-sequences, in-cycle

Version 4.1.5, March 2009
Allow infix notation for prefab structure literals
Change quasiquote so that unquote works in value positions of #hash
Change read-syntax to represent #hash value forms as syntax
Added bitwise-bit-field

Version 4.1.4, January 2009
Changed memory accounting to bias charges to parent instead of children
Changed function contracts to preserve tail recursion in many cases
Added scheme/package, scheme/splicing, ffi/objc
Added exception-backtrace support for x86_84+JIT
Added equal?/recur
Added equal<%> and interface* to scheme/class
Added procedure-rename
Added extra arguments to call-with-continuation-prompt
Added extra argument to raise-syntax-error
Added compile-context-preservation-enabled
Added syntax-local-lift-require
Added internal-definition-context-seal, which must be used on an
 internal-definition context before it's part of a fully expanded form
Added syntax-local-make-delta-introducer
Changed make-rename-transformer to accept an introducer argument that
 cooperates with syntax-local-make-delta-introducer
Added internal-defininition-context?
Added identifier-remove-from-defininition-context

Version 4.1.3, November 2008
Changed scheme to re-export scheme/port
In scheme/port: added 
Added call-with-immediate-continuation-mark
In scheme/port: added port->string, port->bytes, port->lines
 port->bytes-lines, display-lines, [call-]with-input-from-{string,bytes},
 and [call-]with-output-to-{string,bytes}
In scheme/file: added file->string, file->bytes, file->lines,
 file->value, file->bytes-lines, write-to-file, display-to-file,
 and display-lines-to-file
Added variable-reference? and empty #%variable-reference form
Extended continuation-marks to work on a thread argument

Version 4.1.2, October 2008
Changed binding of identifiers introduced by unit signatures
 to take into account the signature use's context
Added make-syntax-delta-introducer
Changed continuation-marks to accept a thread argument
Added eqv-based hash tables
Added hash-update and hash-update!
Changed -X and -S to complete directory relative to pwd, and
 changed -S to add after main collects

Version 4.1.1, October 2008
Added read-language
Added module-compiled-language-info, module->language-info,
 and 'module-language property support

Version 4.1, August 2008
Changed namespaces to have a base phase; for example, calling
 eval at compile-time uses a phase-1 namespace
Added logging facilities: make-logger, etc.
Added "inheritance" to structure type properties, and change
 prop:procedure from scheme/base to better support keywords
Added bitwise-bit-set?
Added in-value

Version 4.0, June 2008
>> See MzScheme_4.txt

Version 372, December 2007
Added syntax-local-lift-context
Added #lang
Added require-for-label, provide-for-syntax, provide-for-label,
 identifier-label-binding, module-label-identifier=?

Version 371, August 2007
Added hash-table-iterate-{first,next,key,value}
Added keyword<?
Added make-derived-parameter
Added make-sibling-inspector
Added graph? argument to read[-syntax]/recursive
Added read-accept-infix-dot
Changed #!<space> and #!/ to general comment forms
Added continuation?
Added continuation-prompt-tag?
Inside MzScheme: GC_{malloc,free}_immobile_box
foreign.ss: added {malloc,free}-immobile-box

Version 370, May 2007
Memory management:
 Default build uses 3m instead of CGC
 Added custodian boxes and custodian-memory-accounting-available?
 Added initial custodian argument to custodian-require-memory
Exceptions:
 Removed current-exception-handler and initial-exception-handler
 Added uncaught-exception-handler
 Default error escape handler aborts to default continuation
  tag with the void procedure
 Added call-with-exception-handler
 Changed read-eval-print-loop and the default load handler to wrap
  each evaluation with a prompt and with #%top-interaction
 Changed top-level begin to insert a prompt around each sub-expression
  except the last
 Added #%top-interaction and #%expression
 Changed make-exn to automatically convert a mutable message string
  to an immutable string
Units:
 New unit system provided by MzLib's "unit.ss"
Ports and pathnames:
 Added prop:input-port and prop:output-port
 Added support for manipulating filesystem paths that work on 
  other platforms
 Added string->path-element and path-element->string
 Changed path->directory-path, simplify-path, and split-path to include
  a trailing path separator even when the result would be a directory
  path without it
 Changed simplify-path for Windows paths to replace / with \
 Changed current-directory to apply path->directory-path to given paths
 Added reset?, start-, and end-index arguments to get-output-bytes
 Added port-closed?
 Added optional argument to tcp-addresses to get port numbers
Syntax and loading:
 Default load handler enables #reader (even when not reading a module)
 Added module-path-index-resolve
 Added syntax-local-expand-expression
 Changed dyanmic-require to expand requests for exported syntax
  bindings
 Added an argument to syntax-local-certifier indicating whether the
  generated procedure attaches active or inactive certificates
 Changed macro expansion of bound identifiers so that `local-expand'
  works with an empty stop list
 Module top-level enforces initial categorization of expressions
  versus other forms
 Changed H-expression parsing to represent angle brackets specially
Misc:
 Changed print-struct default to #t instead of #f
 Added parameterize*
 Added 'gc and 'so-suffix flags for system-type
 Added vector->values
 Changed char-whitespace? to produce #t for #\u0085
 Added -p, -P, and -Q command-line options
 Added procedure-struct-type?
 Added system-idle-evt
 Fixed mzc --exe to work with C-implemented extension modules
MzLib:
 serialize.ss: Path includes the path's convention
 foreign.ss: Added ptr-add, memmove, memcpy, and memset
 runtime-paths.ss: Cooperates with mzc --exe
Inside MzScheme:
 Use SCHEME_INPUT_PORTP() instead of SCHEME_INPORTP()
     SCHEME_OUTPUT_PORTP() instead of SCHEME_OUTPORTP()
     scheme_input_port_record() instead of cast to Scheme_Input_Port*
     scheme_output_port_record() instead of cast to Scheme_Output_Port*
 Added scheme_set_type_equality() with help from Dimitris Vyzovitis
 Added XFORM_START_SKIP, etc.

Version 360, November 2006
Continuations:
 Added delimited continuations: call-with-continuation-prompt,
  call-with-composable-continuation, etc.
 Changed call-with-escape-continuation so that its argument is
  no longer applied in tail position (reverses a change in v350)
Regexps:
 Added case-insensitive mode, multi-line mode, lookahead, lookbehind, 
  non-backtracking, and conditionals to regexp language
 Added pregexp, byte-pregexp, and #px..., which includes numeric
  quantifiers, backreferences char classes, and Unicode predicates
 Added regexp-match?, pregexp?, and byte-pregexp?
 Improved [p]regexp performance
Filesystem:
 Unix and Mac OS X: Changed path operations to use "./~..." as an
  encoding for a relative path "~..."
 Changed simplify-path to always normalize path separators,
  preserve syntactic directoryness, and remove \\?\ from
  Windows paths when possible
 Added path-element->bytes and bytes->path-element
 Changed make-file-or-directory-link to not expand the link
  content, and changed make-security-guard to have a separate
  link guard procedure
Misc:
 Removed write-image-to-file and read-image-from-file
 ormap and andmap now tail-apply a given function for the 
  last list element(s)
 eval evaluates its argument in tail position
 Improved compilation of call-with-values and an immediate
  lambda argument to avoid closure creation
 Added raise-arity-error
 Changed bytecode compiler to perform more closure conversion
  and lifting
 Changed local-expand; #f stop list means expand only immediate
MzLib:
 class.ss: added inherit/inner and inherit/super, to eventually
  replace rename-super and rename-inner;
  added member-name-key=?

Version 352, July 2006
Minor bug fixes

Version 351, July 2006
Changed hash-table-get to accept a non-prcedure third argument as
 a default value (instead of requiring a thunk)
Changed the module name resolver protocol so that the resolver is
 required to accept 1, 3, and 4 arguments; the new 4-argument mode
 supports resolving a module path without loading the module
Changed syntax/loc to not adjust location information for a
 template that contains only a pattern variable
MzLib: Added define-member-name, member-name-key, and 
 generate-member-key to class.ss
Added syntax-local-lift-moule-end-declaration
Changed namespace-attach-module and namespace-unprotect-module
 to accept quoted module paths, instead of only symbolic names
Fixed avoidable overflow and underflow in magnitude and / for
 inexact complex numbers
Fixed bug in continuation sharing
Improved 3m performance
Upgraded to gc 6.7

Version 350, June 2006
JIT compiler:
 Added just-in-time native-code compiler with a new eval-jit-enabled
  parameter
 Added compile-enforce-module-constants parameter; the default is #t,
  which effectively prohibits redeclaraing modules or changing
  variable bindings through module->namespace
 Added function inlining, and fixed constant propagation and folding 
  in bytecode compiler
Stack trace:
 Added a "stack trace" to the default error display
 Added exn:fail:user and raise-user-error
Installation and executables:
 Changed installation process to support more configurable directory
  structure
 Dropped PLTHOME, and instead added support to embed a path to the
  main "collects" directory within the executable
 Changed style of executables generated by mzc --[gui-]exe under
  Unix; for old-style executables, use --orig-exe, or use --exe-dir 
  to package the executable
 Added 'run-file, 'collects-dir, and 'orig-dir modes to find-system-path
 Changed initial program binding to the result of find-system path
  with 'run-file instead of 'exec-file
 Added use-user-specific-search-paths parameter, -U flag
Continuations:
 For nested captured continuations, the shared continuation tail is
  represented by shared data
 The body of let/cc and the procedure passed to call/ec are
  evaluated/called as a tail expression/call
 Made parameter/mark lookup amortized constant time,
  instead of potentially O(stack depth)
Misc:
 Added char-general-category
 Added string-normalize-nf[k]{d,c}
 Changed bitwise-{and,ior,xor} to accept 0 arguments
 Changed file-position: eof moves to the end of a file/string
 Changed readtable to support "default" parser used for symbols/numbers
 Changed system-type's optional argument to 'os, 'link, or 'machine
 Added current-thread-initial-stack-size
 Added procedure-closure-contents-eq?
 Added struct-type-make-constructor and struct-type-make-predicate
 Inside MzScheme: added scheme_make_prim_closure_w_arity(), etc.

Version 301, December 2005
Fixed a custom-input-port bug in the case that a read or peek procedure
 returns an event created by handle-evt

Version 300, December 2005
Generalized network-address handling, includes IPv6
Added ephemerons
0.0 and -0.0 are different by eqv?
Added keyword values (#: prefix) and keyword? predicate
Added system-language+country
Added current-preserved-thread-cell-values
Added #%variable-reference
MzLib: added object-method-arity-includes? to class.ss
Added --xform mode to mzc

Version 299.400, Setember 2005
Improved Windows path support (e.g., \\?\ paths)
Added optional argument to simplify-path
Added 'pair-shape property to reader
Inside MzScheme: added scheme_get_port_file_descriptor()
 and scheme_get_port_socket()

Version 299.200, August 2005
Ports:
 TCP output ports are now block-buffered by default
 Changed file-stream-buffer-mode to work on more port types,
  including TCP ports and custom ports
 Added extra argument to make-input-port and make-output-port
  to get/set buffer mode
 Changed port-count-lines! and port-next-location to work
  on output-ports
 Changed make-output-port to take three new arguments:
  get-location procedure, count-lines! procedure,
  and initial position
 Changed make-input-port to take two new arguments: count-lines!
  procedure (defaults to void) and initial position
 Added relocate-input-port, relocate-output-port, transplant-input-port,
  and transplant-output-port to MzLib's "port.ss"
Strings and Unicode:
 \U allows up to 8 digits instead of 6
 Changed char-lower-case? and char-upper-case?
 Added string-upcase, string-downcase, string-titlecase,
  string-foldcase, and char-foldcase
 In case-insensitive mode, symbols are case-folded instead
  of downcased (which is usually the same thing)
Reader:
 Added #reader and readtables
 When { or [ is disabled, it is treated as an illegal character
  instead of a symbol character by the reader
 Changed read-syntax[/recursive] to remove the delta-list
  argument
 Changed read handler to remove the delta-list argument
 Changed read[-syntax]/recursive to produce a special-comment
  value when a comment is parsed (instead of reading the
  next datum)
Printer:
 Added custom struct writers through prop:custom-write,
  custom-write?, custom-write-accessor
Syntax and Macros:
 Changed expansion of internal definitions so that local
  macros that expand to definition forms can be used
  within the local definition set
 Added syntax-local-make-definition-context
 Added syntax-local-bind-syntaxes
 Added optional definition-context argument to
  local-expand and syntax-local-value
 Changed certification so that a reference cannot have more
  certificates than its binding, and lexical context gives
  syntax-quoted values inactive instead of active certificates
 Added sub-form for require: only
 Added module-provide-protected?
 Fixed all-from provides to include redundant imports from the
  indicated require
 Added prefix-all-defined and prefix-all-defined-except
  provide forms
Structure Types:
 Struct custodian can be #f to make it fully transparent
Libraries:
 Added define-serializable-class[*], externalizble<%>,
  class/derived, and inspect clause form to MzLib's "class.ss"
 Changed run-server in thread.ss to use the same parameterization
  for all connection threads
 Added define-struct/properties to MzLib's "struct.ss"
 Removed pretty-print-display-string-handler from MzLib's
  "pretty.ss", and adapted protocol for hook procedures
  slightly (i.e., they usually must write to a given port)
 Changed collects/web-server request-bindings/raw
  to return an alist of bytes, not strings
Misc:
 Cygwin build produces a Unix-style installation instead of
  a Windows-style installation (e.g., system-type is 'unix)

Version 299.100, March 2005
Unicode and Strings:
 Removed char-locale... operations
 Removed char->latin-1-integer and latin-1-integer->char
 Added string-copy!, read-string!, peek-string!, and write-string
 Added convert-stream, reencode-input-port, etc. to port.ss
 Added \u and \U syntax in strings and chars
 Fixed log for large exact integers
 Added path-string?, path-replace-suffix
 Renamed all of the number "byte-string" functions to "bytes"
 Added \' escape for strings (for compatibility with C & Java)
 Added locale-string-encoding
 Changed regexp-replace* to raise an exception if it matches an
  empty string
 Added binding of greek-lambda character (code point #x03BB) to
  expand to lambda
Paths:
 Changed pref dir (all platforms) and pref file name (except Windows);
  changed home dir under Windows to use the registry-specified profile
  directory
 Added 'doc-dir and 'desk-dir to find-system-path
 Unix and Mac OS X: path expansion removes redundant slashes
 Removed exists check for current-directory
Ports:
 Change default buffering of file-stream output ports
 Changed file-stream-buffer-mode to work on input ports
 Changed make-custom-input-port to make-input-port
 Changed make-custom-output-port to make-output-port
 Added terminal-port?
 Added pipe-content-length
 Changed {read,peek}-bytes-avail!{,*,/enable-break} to produce
  a special-reading procedure when a stream contains specials
 Added make-pipe-with-specials to MzLib's "port.ss"; procedures
  like copy-port now also handle specials
 Moved most of (lib "thread.ss") to (lib "port.ss"), and many
  remaining useless procedures (such as dynamic-enable-break)
  were removed
 Added port-progress-evt, port-commit-peeked, and
  port-provides-progress-evts?
 Added an optional progress-event argument to peek-bytes-avail!,
  etc., before the port argument
 Added an optional progress-event argument to regexp-match-peek
  and regexp-match-peek-positions
 Peeking from a limited pipe effectively increases its capacity,
  temporarily
 Added optional port name arguments to make-pipe
  and open-{input,output}-{string,bytes}
 Changed object-name for input ports and output ports
 Added write-special and write-special-avail*
 A location-offset lists for a port read handler can contain #f
 Changed read-syntax to make the source name optional (defaults
  to the port's name)
Syntax and Macros: 
 Eliminated "identifier for a definition has a module context"
  errors
 In a syntax template, when an identifier has more ellipses
  then in the pattern, inner ellipses bind more
  tightly than the outer ellipses
 New forms: require-for-template (core), define-values-for-syntax
  (core), define-for-syntax, begin-for-syntax
 New procedures: local-transformer-expand, syntax-transforming?,
  syntax-local-lift-expression, local-expand/capture-lifts,
  local-transformer-expand/capture-lift, syntax-recertify, 
  module-template-identifier=?, identifier-template-binding,
  rename-transformer-target
 Removed fluid-let-syntax, syntax-local-certifier
 Added (lib "stxparam.ss"), partly as a replacement for
  fluid-let-syntax
 Removed use of #%top from references to a module's own bindings
 Added protect sub-form of provide
 module-compiled-imports now returns 3 values
 indentifier-[transformer-]binding returns a list of five items
  instead of four for a module-bound identifier
 Added 'module-begin to the set of possible results from
  syntax-local-context
 Added begin-with-definitions to (lib "etc.ss")
 Added syntax-property-symbol-keys
 Added namespace-unprotect-module
 Changed eval, expand, etc. so that only the leading
  identifier in a module form is given context
 Changed module expansion/compilation so that it's deterministic,
  as long as macros do not use gensym or external side-effects;
  using generate-temporaries preserves determinism
 Changed module->namespace and module re-definition so that they're
  controlled by the code inspector, not the modules attach state
 Added current-compile parameter, which is used by compile
  and by the default evaluation handler
 Changed expansion-time structure type info to allow #f in place
  of a mutator id
 Added construct-time field guards to structure types
 Changed raise-syntax-error so that it no longer accepts a list
  as its first argument
Reader Syntax:
 Added #<< here strings
 Added H-expression mode to reader, triggered by #hx or #honu,
  and escaped by #sx
 Added read-honu, read-honu-syntax, and print-honu
 Changed #; for top-level read; graph assignments are forgotten
  before reading the next expression
Control Flow and Paramaters:
 While an exception handler is called, the current exception
  handler is reset to the default handler; similarly,
  the error display and escape handlers are called by the
  default exception handler in a context that resets the
  corresponding parameters to the default handlers
 An exception handler can handle exceptions that are raised
  during the handler (by using with-handlers or setting the
  current-exception-handler parameter)
 During the evaluation of dynamic-wind pre and post thunks,
  the current continuation marks and parameterization are reset
  to those active at the time of the dynamic-wind call
  (except that the parameterization is extended to disable
  breaks)
 Added current-parameterization and call-with-parameterization
 Added continuation-mark-set-first
 Removed optional argument of continuation-mark-set->list
 Added continuation-mark-set->list*
 Added call-with-continuation-barrier
 Renamed "continuation boundary" to "continuation barrier"
 Added call-with-semaphore and call-with-semaphore/enable-break
Events:
 Renamed udp-send-evt and udp-receive-evt to udp-send-ready-evt
  and udp-receive-ready-evt
 Added udp-send-evt, udp-send-to-evt, and udp-receive!-evt
 Added tcp-accept-evt
 Added make-alarm
Misc:
 Regexp grammar changed to match docs with respect to "-"
 Struct property types are now overridable in subtypes
 Added module-compiled-exports
 Added hash-table-copy and hash-table-count
 Changed the random-number generator to use L'Ecuyer's MRG32k3a
  algorithm, as encouraged by SRFI-37
 Changed random to accept 0 arguments to generate a random real
  number, and added pseudo-random-generator->vector and
  vector->pseudo-random-generator; these are compatible
  with the SRFI-27 reference implementation
 Added print-unreadable parameter
 Changed use-compiled-file-kinds to use-compiled-file-paths
 Mac OS X: extension suffix changed from ".so" to ".dylib"
Libraries:
 "class.ss" MzLib module: changed the interface to 
  make-primitive-class; see plt/collects/mzscheme/examples/tree.cxx 
  for details
 "serialize.ss" MzLib module: new
 "contract.ss" MzLib module: names are more uniform; if the name of a
  contract a suffix, the suffix is now "/c" (instead of one of "/p",
  "/c", or "/f")
 "url.ss" in the "net" collection: new url data definition; url/user is
   gone, and no extra encoding/decoding required once a url has been
   parsed anymore
Inside MzScheme: 
 Added scheme_set_type_printer, scheme_print_bytes,
  and scheme_print_string

Version 209, December 2004
Fixed (abs -1073741824)
Avoided gcc 3.4 bug(?) related to inline checking for -0.0

Version 208, August 2004
Added string-copy! and hash-table-count
Upgraded to gc 6.3

Version 207, May 2004
Fixed comparison of infinities and 0.0 in eqv?
Fixed incorrect handling of -0.0 versus 0.0 for various
 platforms, including x86 with gcc 3.2
Fixed inefficient (/ x 1) for an exact rational x

Version 206, January 2004
A shut-down custodian is no longer allowed to manage new
 objects
Changed thread-resume so that it adds custodians to a thread,
 instead of changing the thread's custodian
Added make-thread-group, etc.
Changed define to support MIT-style curried-procedure forms
Added an optional argument to peek-char and 
 peek-char-or-special to indicate the number of characters
 to skip in the input stream
Added optional argument to file-or-directory-modify-seconds
 for setting the modification date of a file or directory
Added integer-sqrt, quotient/remainder, integer-sqrt/remainder
Fixed transitivity of numerical comparison for mixed
 inexact--exact comparisons when the inexact versions
 of the numbers are = but the exact versions are not
Macro templates can include consecutive ... for splicing
 sequences
Macro patterns can include sub-patterns after ...
Improved error reporting for with-syntax
Non-constant syntax pairs generated from templates
 (in syntax-case, with-syntax, quasisyntax, etc.)
 keep source-location and context information,
 instead of acquiring the context and location of
 the generator expression as a whole
generate-temporaries produces identifiers that are
 suitable for use as defined names in the module
 being expanded (if any)
Added syntax-local-module-introduce, which is used
 by generate-temporaries
Added syntax-track-origin
Changed syntax-local-get-shadower to add the current
 module expansion context, if any
Added 'disappeared-binding and 'disappeared-use properties
 and refined 'origin tracking for internal definitions
 and spliced sequences
Added optional namespace argument to most of the
 namespace- primitives
Added vector-immutable
Fixed a bug in the bytecode verifier that caused it to skip
 significant parts of typical bytecode
Added a hook for (planet ...) module paths to the standard
 module name resolver
MzLib's contract.ss: changed and/f to and/c, or/f is deprecated
 (use union), added object contracts, flat-contracts (without
 names) are a separate type; use flat-contract-predicate rather
 than flat-named-contract, added flat-rec-contract, improved
 performance
MzLib's class.ss: added get-field and field-bound?


Version 205, August 2003
Extended regexp language with "(?:...)"
Added 'addon-dir for find-system-path
Changed default library collections path list to include
  (build-path (find-system-path 'addon-dir) (version) "collects")
Added #; reader comment syntax
Added namespace-module-registry
Added module->namespace
Changed eval handler so that when it is given a syntax object, it
 does not extend the object's lexical context with top-level
 bindings from the current namespace
Added namespace-syntax-introduce
Added eval-syntax, compile-syntax, expand-syntax, expand-syntax-once,
 and expand-syntax-to-top-form
Added set!-transformer-procedure
Added namespace-undefine-variable!
syntax-local-context can return a list for internal-define
 expansion, and local-expand accepts a list to mean 
 internal-define expansion; for built-in expansion, each
 list item uniquely indicates a distinct, active
 internal-define expansion context
Added syntax-local-get-shadower
Changed top-level `define-syntaxes' to treat zero results
 from the right-hand side as an abort, so that
   (define-syntax (id ...) (values))
 declares the ids. This is useful for macros that
 expand to mutuaully recursive definitions of private
 variables
Changed the expansion-time information associated with a
 struct type to include an identifier for the super-type
Handling of --main/-C command-line flag changed
Changed "scheme-<dialect>" script handling to add the script
 path as an argument, which matches SRFI-22
Changed Windows extension-linking convention; extensions
 link directly to the MzScheme/GC DLLs
Added an optional argument to system-library-subath
Added custodian-managed-list
Changed vector-set-performance-stats! to accept an optional
 thread argument for thread-specific stats
Mac OS Classic: file-size result no longer includes
 the resource-fork size
Added a `super-new' local form to (lib "class.ss")
Added a `new' form to (lib "class.ss")
3m: changed to the calling convention for managing
 GC_variable_stack

Version 204, May 2003
Added UDP operations
Added synchronous channels
Added thread-suspend and thread-resume
Added thread/suspend-to-kill
Added thread-dead?
Added thread-suspend-waitable, thread-resume-waitable, 
 and thread-dead-waitable
Added make-wrapped-waitable, make-guard-waitable, and
 make-nack-guard-waitable a la CML
Added waitables->waitable-set, which is like CML's choose
Renamed make-nack-waitable to make-nack-guard-waitable
 to claify its relation to make-guard-waitable
Added make-poll-guard-waitable
Added make-semaphore-peek
Added current-wait-pseudo-random-generator
Changed unreachable threads to be garbage-collected when
 blocked on any combination of otherwise unreachable
 waitables by object-wait-multiple, semaphore-wait, 
 channel-put, channge-get, or thread-wait; in addition,
 unreachable suspended threads are garbage-collected
Added "async-channel.ss" to MzLib
Changed make-custom-input-port to drop the initial
 waitable argument; instead, the read and peek
 functions should return a waitable instead of 0
Changed make-custom-output-port so that the first
 argument is #f or a procedure to return a waitable
 (instead of #f or a waitable)
Added tcp-port?
Added port-file-identity
Deprecated normal-case-path
Changed the symbolic name for a file-based module to be
 determined without using normal-case-path
Fixed MzLib's regexp-split, etc., to work on input ports
Changed make-struct-type-property to accept a guard
 procedure for the property
Changed make-struct-type to accept a list of immutable
 field positions
Changed struct-type-info to return 8 values instead of 6
 to include information on immutable fields
Changed proc-spec handling in make-struct-type; an integer
 value must be < init-field-k, and overriding is disallowed
 (for consistency with user-defined properties)
Added prop:waitable
Changed handling of top-level and module top-level definitions
 of identifiers that originate from a macro expansion; such
 definitions now bind only the uses of the identifier with the
 same expansion origin
Added make-syntax-introducer, for creating new macro origins
Changed generate-temporaries so that it does not use gensym,
 but instead uses make-syntax-introducer to distinguish names
Added make-rename-transformer and rename-transformer?
Changed syntax-local-value to cooperate specially with
 rename transformers
Fixed parse problems with # in numbers, as in `1#/2' and
 `#e#x+e#s+e@-e#l-e'
Added literal hashtable syntax #hash..., added support
 for immutable hash tables, and added print-hash-table
 parameter
Added literal regexp syntax #rx... and changed the printer
 to use this notation for printing regexps
Changed hash-table? to accept 'weak and/or 'equal and return
 #t only if the first argument is a hash table created with
 the corresponding flag(s)
Changed equal? to compare hash tables by determining whether
 they map the same keys to equal? values
Added vector->immutable-vector
Added immutable-box
Added vector-set-performance-stats!
Changed columns to count from 0 instead of 1 

Version 203, December 2002
Added support for structure types whose instances act as
 procedures
Added open-input-output-file
Added port-count-lines-enabled parameter

Version 202, August 2002
Changed expansion of () to '()
Unix: Fixed open on fifos to not block
Windows 9x: Added workaround for resolution of "127.0.0.1"

Version 201, July 2002
Fixed bug in port reading (especially variants of read-string)
 and file-position that follow peeks on the port
Added exn:special-comment, expected to be used by custom input ports
 that contain non-character-based comments (e.g., the comment boxes
 soon to appear in DrScheme)
Windows: added special handling of "special files" (COM1, etc.);
 internally MzScheme opens the file only once to satisfy multiple
 open-input-file and open-output-file calls that have the
 port open at the same time

Version 200, June 2002
>> See MzScheme_200.txt for information on major changes in
   MzScheme 200. Minor changes are listed below.
(cond) alays returns void; the cond-allow-fallthough parameter and
 exn:cond exception have been removed
Changed all comparison precedures to require at least two
 operands, including =, <, ..., char=?, char<?, ...,
 string=?, string<?, ...
Added locale support with string-locale<?, etc.
Added integer-byte-string->integer, floating-point-byte-string->real,
 integer->integer-byte-string, real->floating-point-byte-string,
Renamed exn:misc:user-break to exn:break
Removed the port field of exn:read
Renamed arity to procedure-arity
Replaced primitive-name and inferred-name with object-name
Added security guards for controlling file and network access
Added an "infix" conversion in the reader, triggered by a pair of dots
 between a pair of parens
Added #cs and #ci prefixes for controlling case sentivity during read
Added current-command-line-arguments parameter
Added error-print-source-location parameter
Added current-load/use-compiled parameter
Changed string constants to support ANSI C escapes (e.g., \n)
Fixed leaks (file descriptors, etc.) that could happen with
 thread kills
Fixed memory bug in the run-time support for mzc-compiled code
Fixed an old and serious set of tail-call+thread-or-exception+GC bugs 
 in the core interpreter
Changed the error display handler to take a raised value (usually
 an exception record) as a second argument
Removed make-hash-table-weak and changed make-hash-table to
 accept up to two flag arguments: 'weak and/or 'equal
Added eq-hash-code and equal-hash-code
Extended regexp-match, etc. to work on port inputs
Added read-strng-avail!* and write-string-avail*, which never block
Added peek-string, peek-string-avail!, peek-string-avail!*,
 and peek-string-avail!/enable-break
Added port-count-lines!, which enables line-couting for a port,
 and port-next-location
Extended custom ports to support non-char input, added
 read-char-or-special and peek-char-or-special
Added immutable?
Quoted portions of a symbol (using | or \) preserve their case,
Added read-dot-as-symbol and read-accept-quasiquote parameters
Added an optional third argument to tcp-listen to reuse addresses
Added tcp-connect/enable-break and tcp-accept/enable-break
Added object-wait-multiple and object-wait-multiple/enable-break
Added cons-immutable, list-immutable, and list*-immutable, 
 and removed pair->immutable-pair
Replaced read-dot-as-symbol with read-accept-dot
Fixed quotient, remainder, and modulo when the first argument
 is exact 0 and the second argument is inexact
Default for pconvert.ss's whole/fractional-exact-numbers parameter
 changed to #f
Load handler or load extension handler now takes two arguments
 instead of one: the filename and the expected module name
Added shell-execute for Windows
Moved send-event to MrEd; added a "sendevent.ss" MzLib library
Changed assf in MzLib
Added special handling when MzScheme is invoked with the name
 "scheme-<dialect>", useful to support SRFI-22
New implementation of Windows I/O
Renamed "2k" to "3m" (for "moving memory manager")
Upgraded to gc 6.1alpha2
Inside MzScheme: changed type of third argument for
 scheme_block_until() from void* to Scheme_Object*
Inside MzScheme: added scheme_add_waitable() and
 scheme_add_waitable_through_sema() for extending the set of objects
 supported by object-wait-multiple

Version 103, August 28, 2000
Changed define-values and set!-values to require distinct variables
 for binding
Windows: Fixed bug in close-output-port for TCP ports
Closing a TCP output port always sends an EOF to the other
 end of the connection, even if the associated input port
 remains open
Changed order of first two arguments to process[*]/ports and
 fixed bugs
Added an optional limit argument to make-pipe
Added deflate.ss library to MzLib, providing gzip, etc.
Added not-break-exn?, useful mainly as a predicate in a
 with-handlers expressions
Fixed load/use-compiled, require-library, and many MzLib functions to
 propagate break exceptions correctly
Added check-parameter-procedure and changed parameterize
Changed order of first two arguments to process[*]/ports, and
 fixed bugs
Fixed bugs in (eval (compile e))
Changed handling of pre- and post-queued breaks by
 call-in-nested-thread
Unix: fixed interaction among signals, I/O, and process sleeping
Unix: fixed bug in writing/closing file-stream output ports
 when a write error occurs
MacOS: changed `split-path' to preserve the colon suffix on a root
 name

Version 102, June 26, 2000
Switched to configure-based makefiles (autoconf)
with-input-from-file and with-output-to-file close the port when
 control leaves the dynamic extent of the call (normally, through an
 exception, or through a general continuation jump).
Added detail field to exn:i/o:filesystem
Added immutable strings and pairs, string->immutable-string,
 cons-immutable, list-immutable, and list*-immutable
Added read-decimal-as-inexact parameter
Fixed number reader to allow +inf.0, -inf.0, and +nan.0 in
 complex constants
Fixed bugs in number reader for hexadecimal numbers containing `.'
 and/or `s'/`l'-based exponents; note that `#e#x+e.s+e@-e.l-e'
 is a legal number(!)
Fixed reading from special devices, such as /dev/null and /dev/zero,
 in Solaris and HP/UX
Fixed blocking output (to stdout, stderr, or a process port) so that
 only the writing thread is blocked
Changed read-string! to read-string-avail!, added
 read-string-avail!/enable-break
Added write-string-avail and write-string-avail/enable-break
Added process/ports and process*/ports
Added file-stream-port?
Added 'update to the set of flags for open-output-file et al.
Changed default exit handler to return only results in 0 to 255
 as results to the OS, and everything else means 1
Changed time-apply to return four values, and to take an argument
 list to provide to the timed procedure
Change find-executable-path to accept #f as its second argument
Change normal-case-path to remove spaces at the end of a path
Changed angle on inexact zero (0 for 0.0, pi for -0.0)
Fixed arithmetic-shift for a -32 shift
Fixed angle on +nan.0
Fixed expt on 0 and a negative number
Added 'exec-file flag to find-system-path
Added provide-library
Added square and mergesort to MzLib's function.ss
Added tcp-addresses
Added -k command-line flag
Inside MzScheme: provided a way to fix the GC--thread problems
 under Windows, via GC_use_registered_statics
Inside MzScheme: scheme_basic_env() initializes break-enabled
 to #f instead of #t
Inside MzScheme: changed scheme_get_chars to consume an
 offset into the string
Inside MzScheme: added embedding-settable function
 scheme_console_output, used to report low-level errors
Inside MzScheme: restricted the format strings accepted by
 scheme_signal_error, scheme_raise_exn, and scheme_warning
Inside MzScheme: added scheme_count_lines; scheme_tell_line
 can return -1 if lines are not counted for a port
Inside MzScheme: added offset argument to scheme_write_string
 and scheme_read_bignum

Version 101, October 25, 1999
Added 'sys-dir to find-system-path
Added latin-1-integer->char and char->latin-1-integer
Added time-zone-offset field to the date structure
Added continuation field to exn:misc:user-break
Windows: all network sockets are closed on exit
Fixed (acos 0)
Fixed (expt x y) where x is negative and y is non-integral
Inside MzScheme: scheme_param_config's 2nd argument is
 now a Scheme_Object*

Version 100, August 9, 1999
 + indicates a change since 100alpha4
 * indicates a change since 100alpha3
Changed class syntax, splitting public clause use into:
 public : defines ivars not in superclass
 override : defines ivars already in superclass
Changed empty superclass from the empty list to object%;
 every class initialization must call super-init
Added ivar-in-interface?
+ Added class-initialization-arity
* Added class->interface
* Added object-interface
+ Removed object-class
+ Removed ivar-in-class?; replace (ivar-in-class? x c)
 with (ivar-in-interface? (class->interface x c))
Changed interface: raises an exception if a superinterface
 declares a variable that is also declared in the interface
 expression
Removed letrec*; letrec has the same semantics
* Fixed scope of function name in a named let
Internal definitions are allowed only at the beginning of lambda,
 case-lambda, let, let-values, let*, let*-values,
 letrec, letrec-values, fluid-let, let-macro, let-id-macro,
 let-expansion-time, parameterize, and with-handlers
begin expressions are flattened in an internal-definition context
(begin) allowed in a top-level, unit, or internal-definition
 context
Removed invoke-open-unit; see the new invoke.ss library, which
 includes define-values/invoke-unit
Self-import is now allowed for unit linking
Removed constant-name and constant-name-all-globals
Removed secure-primitive-exception-types
Removed readable type symbols (e.g., #<procedure>)
Removed semaphore-callback (MrEd now has queue-callback)
Removed parameterizations (but not parameters!)
parameterize sets parameter values in parallel (like let)
 instead of in series (like let*)
* Changed the initialization of the exception handler in a new
 thread to use the value of the initial-exception-handler
 parameter
Fixed unfairness in threads (perpetually creating threads
 would starve certain threads, particularly the main thread)
Unreachable thread blocked on an unreachable semaphore is
 garbage-collectable
Added current-memory-use
Fixed weak hash table bug (could drop keys too soon)
Added optional peek-proc argument to make-input-port
Changed TCP writes to block when the underlying implementation
 blocks, and removed tcp-port-send-waiting?
Asynchronous breaks are now disabled during dynamic-wind
 pre and post thunks
Removed user-break-poll-handler; spawn a thread that sleeps and
 calls break-thread, instead
Removed dynamic-enable-break (no long needed since dynamic-wind
 post thunks can't be broken), but moved it to MzLib's thread.ss
Removed                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       