Implement current-error-port.

Implement tty-error-channel and export to console I/O.

Implement replace-binary-port! on generic I/O ports.

Provide access to the channels in a binary port.

Simplify console port exports.

* Eliminate console-input-port, console-output-port, and set-console-i/o-port!.
* Change console-i/o-port to be a thunk that returns the port.

Implement support for stderr.

Implement R7RS exceptions.

Fix typo in previous change.

Fix bug: error:file-operation couldn't work properly.

This is because substitutable-value-condition-signaller was mis-designed.  It
added retries *after* building the condition, so they weren't in the condition
and would never be shown.

I rewrote error:file-operation based on the model in microcode-errors.scm which
was apparently a workaround for the fact that error:file-operation didn't work.

This entailed a small but incompatible change to the procedure's arguments.

Add support for parsing nan.0, +inf.0, and -inf.0.

Not sure if nan.0 is meaningful, but it shouldn't do any harm.

Update to reflect changes in runtime system.

Add procedures to generate infinities and a nan.

Don't constant-fold an application if it generates an error.

Also fix overlong lines and pages in object.scm.

Implement finite?, infinite?, and nan? from R7RS.

Fix typo in previous edit.

Change rational? to be false for inf/nan.

Change printed representation of inf/nan to match R7RS.

Add support for C99 floating-point predicates.

Also expose those predicates in Scheme, and implement flo:eqv? properly.

Update documentation of booleans.

Generalize boolean=? to support multiple arguments.

Tweak char and string chapters to be closer to R7RS.

Eliminate bundle types; original design using predicates is better.

Convert object hasher to be a bundle.

Fix thinko as reported by Patric Jonsson.

Incorrectly computed length of result in exact-nonnegative-integer->bytevector.

Convert metadata tables to be bundles.

Initialize applicable records much earlier in the cold load.

Clean up bundle implementation.

Revert bundle abstraction back to what we are using the in the book.

The previous version didn't really do what I wanted and this one is useful in a
more limited context.

Fix typo: accidentally discarded initialization in earlier change.

Integrate applicable records into the procedure abstraction.

Also, don't allow applicable records to be made non-applicable.  This sort of
satisfies the idea that predicates aren't time-varying, provided that the record
type's applicator is set immediately after definition.

Add adapter for hash-object.

Implement symbol=? for R7RS.

Also fix some symbol procedures that were unsafe.

Change hash tables to use define-record-type instead of define-structure.

This has the advantage of eliminating the need for nearly all of the calls to
guarantee, which should at worst be a net wash and at best will be slightly
faster.  (Not a big deal either way.)

A second advantage is, of course, eliminating the use of define-structure.

Fix breakage I caused with a previous refactoring.

The procedures hash-table-update! and hash-table/modify! were not equivalent, as
I blindly assumed during the refactor.  Changing hash-table-update! to use the
same implementation as hash-table/modify! caused the unit tests to fail, because
that implementation couldn't implement the tested behavior.

Rather than try to fix the implementation, I reverted hash-table-update! to its
previous implementation.  The rationale for this is that fixing the implementation
would effectively eliminate its performance advantage, while still being hard to
understand.  The older implementation is trivial to understand and eliminates
the restriction that the update procedure not use the hash table.

An additional complication arose because the previous implementation of
hash-table-update! returned an unspecified value, which broke hash-table-intern!
and caused hash-table/modify! to differ from its previous behavior.  I fixed
these by rewriting them without using hash-table-update!.

Deprecate with-values.

Rename urtrap.scm -> reference-trap.scm.

Export scode-expression?.

Eliminate now-deprecated references to hash-table procedures.

Update hash-table documentation in the reference manual.

Mark all of the hash-table renames as deprecated.

Rename hash-table-entry-type:key{/,&}datum-weak.

This makes it consistent with the ephemeron naming.

Fix missed reference.

Rewrite the object hashing facility.

* Names have been changed to avoid conflicts with hash tables, and for
  consistency.  The old names are still available as deprecated renames.

* New implementation is much easier to read.

Add type and constructors for datum-weak hash tables.

Fix typo.

Refactor hash-table to clean up some issues noted in previous change.

* Export former %make-hash-table as make-hash-table*.

* Create new make-hash-table-type* which can create a type given an equality
  predicate and some keyword options.  If the equality predicate has registered
  properties, no additional options may be necessary, except perhaps to choose
  the entry type (which is specified by name).

* Change make-hash-table to accept the same options as make-hash-table-type* and
  to use the same defaulting.

* Change internal procedure follow-memo-crap to hash-metadata, which more
  accurately reflects its purpose: to get a properties table for the primary
  hash parameters.

Rename set-equality-predicate-hasher! -> set-equality-predicate-properties!.

Now has two required arguments: hash-function and rehash-after-gc?.
A rest argument is a keyword list for additional properties.

Change keyword-option-parser to expect defaults as a thunk.

Move int:modulo to primitive-arithmetic and export it.

Standardize hash tables on SRFI-69 names and deprecate others.

Change make-hash-table to be smarter about choosing the appropriate hash
function for a given equality predicate.

Also work around name collisions in rtlopt/rcse*.scm, and tweak the hash-table
implementation to favor SRFI-69.

Some work remains: the code around building hash-table types needs to be
re-thought: it's a little clunky and could usefully take advantage of keyword
arguments.  (These keyword arguments should also be supported by
make-hash-table.)  The hash function should be optional and use the
equality-predicate default.  The older %make-hash-table should be renamed and
exported as it's the right interface when using types.

Make sure that run-three-stages looks at "build" before "svm".

Eliminate remaining uses of find-matching-item.

Eliminate remaining uses of list-search-positive.

Downcase remaining symbols in the runtime system.

Only remaining such symbols are those that have explicit case.

Change SVM compiler to use new pop-return instruction.

Implement new SVM instruction: (pop-return).

Override definition of filter so that compilation using 9.2 works.

Implement scode-procedure-arity so that it can be run during cold load.

The lack of this prevented the cold load from running correctly when using
interpreted code, since it depended on a complex scode lambda implementation
that was loaded much later.

Change guarantee to show context of error.

Eliminate references to now-deprecated definitions.

Put back inadvertently-deleted bindings.

Mark deprecated list procedures and also more SRFI-1 procedures.

Change find-{,not-}matching-items procedures to call find instead.

Also eliminate find-unique-{,not-}matching-items procedures which aren't used
and aren't documented.  These are trivially solved with find-tail and any.

Tweak indentation.

Eliminate references to various list filters in favor of SRFI-1.

One unfortunate development is that somewhere in the compiler is some code that
depends on the result of a filtering option being newly allocated, while FILTER
shares the tail of the input list when it can.  I modified FILTER to stop doing
that, because it wasn't obvious which of the modified calls in the compiler was
causing the problem.

Optimize code generated for let*, let*-syntax, and letrec.

Thanks to Patric Jonsson for noticing this.

Another round of downcasing.

Downcase a lot more symbols and constants.

Add program to find symbols that depend on case folding.

Downcase a lot more symbols and constants.

Export char-changes-when-X predicates and char sets.

Downcase more symbols and constants.

Downcase more symbols and constants.

Downcase more symbols and constants.

Downcase more symbols and constants.

Downcase all symbols and constants.

Change *parser-canonicalize-symbols?* to affect symbols only.

Downcase symbols and constants in optiondb.

Downcase symbols and constants in optiondb.

Fix bug: mime decoder wasn't properly flushing its output.

Fix typo in previous change.

Eliminate define-expr-item-compiler in favor of define-item-compiler.

Not sure what I was thinking when I wrote that code; it was simply wrong.

Move definition of access entirely into mit-syntax.

Eliminate redundant code in cons-stream*.

Reorder definitions in mit-macros into topical groups.

Change spar-transformer->runtime to provide default environment.

Rename :FOO syntax names so that they aren't potential keywords.

Tweak quasiquote implementation to use shorter names.

Also refactor descend-pair slightly for brevity.

Change and to be defined by syntax-rules.

Also belatedly define the feature full-unicode.

Rewrite local-declare using syntax-rules.

Convert define-integrable, fluid-let, and paramaterize to scons-rule.

Change unsyntaxer:* variables to be parameters and export them.

Fix broken unsyntaxing of scode sequences.

Also fix over-long lines.

Make second arg to scons-set! optional.

Refactor how keywords are matched.

* spar-arg:compare renamed to spar-arg:id=? and second argument is optional,
  defaulting to spar-arg:form.

* patterns (noise ...), (noise-keyword ...), and (keyword ...) are eliminated.

* New pattern (ignore-if predicate arg...) ignores a subform if calling the
  predicate is satisfied.

* Renamed (value-if ...) to (keep-if ...) with same semantics: keeps a subform
  if calling the predicate is satisfied.

* New pattern (value arg) is like (values arg...) but a little clearer.

Change spar pattern (elt ...) to (subform ...).

Rename spar*elt* to spar*subform*.

Change pattern->spar to make * and + operators implicitly listify.

Eliminate special bindings for constants in pattern->spar.

Also change leading : to $ to avoid making names look like keywords.

Rewrite patterns as (elt (list ...)) rather than (list (elt ...)).