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 ...)).

Convert and-let* to scons-rule.

Add some simple optimizations.

Convert a bunch more macros to scons-rule.

Use folding to eliminate loops in macros.

Rewrite COND and DO to use spar rules.

Change scons-call to not quote its operator.

Instead one must explicitly call scons-close when necessary.

Add context to items, for errors that happen during item compilation.

Formalize the context of a syntax error.

Implement spar-not.

Rewrite COND-EXPAND to use spar rule.

Change spars to set up error context when calling out to procedures.

Tweak CASE to use new keyword pattern.

Rename spar-seq to spar-and.

Tweak spar patterns.

* Rename (quote <x>) to (noise <x>).
* Rename (keyword <id>) to (noise-keyword <id>).
* Implement (keyword <id>) that matches <id> and then pushes it.

Clarify that spar-push-if pushes the form, and spar-push-elt the elt.

Rewrite CASE as a spar-transformer.

Implement spar-if and associated pattern.

Simplify spars pattern language.

Also change some of the terms to be clearer: I'm anticipating how the
documentation will read.

Eliminate parse-define-form.

Rewrite core of pattern compiler to use rules.

Implement spar-arg:compare and (keyword id) pattern.

More macros converted to new model, plus a lot of fixes and tweaks.

Implement syntax-constructor ("scons") mechanism.

This eliminates a potential problem with RSC and ER macros, which typically
construct ordinary list structure using quasiquote and renaming the keywords.
Unfortunately this will fail if the use environment has redefined the quasiquote
and/or quote keywords.  These constructors are careful not to use any keywords
except renamed ones; they also hide most of the renaming while providing a
simple procedural interface.

Handle case where debugging-info has an old-style pathname.

Don't write pathnames into debugging info.

Implement spar-top-level to cut down on boilerplate.

Tweak.

Change record predicate to check for child types.  Reported by Arthur.

Make record inheritance comply with SRFI 131.

Implement pattern language to make spars more terse.

Add forgotten export.

Change spar-match-null to a procedure.

Simplify spar interface a bit more.

Implement record inheritance at Arthur's request.

Eliminate default-inits arg from make-record-type.

This will allow all optional args to be removed after 9.3.

Streamline definition of record-type proxies.

Allow a record to be both applicable and fasdumpable.

Restrict access to type proxies.

Change default value of repl:write-result-hash-numbers? as requested by GJS.

Change pathname representation to be a fasdumpable record.

Use proxy instances for set-record-type-fasdumpable!.

Fix typo in previous change.

Implement fasdumpable records.

This is restricted to the runtime system since each type must have a
pre-allocated constant to represent it in the proxy table.

At the moment an applicable record can't be fasdumpable too.  That can be fixed
by teaching the microcode about the proxy mechanism, but for now it's not
necessary.

In pp, treat named list/vector specially.

Use cached predicate dispatchers only where tagging is ubiquitous.

Implement applicable records.

Change representation of dispatch tags to eliminated nested "extra" vector.

Eliminate two unused procedures.

Guarantee that capture-syntactic-environment preserves error context.

Some more tweaks to the low-level macro interfaces.

Implement first two macros using syntax-parser.

More tweaks to syntax-parser interface.

Tweak interface for syntax-parser macros.

Refactor syntax-low to improve support for spar transformers.

Eliminate a bunch of now-unused classifier procedures.

Split compile-expr-item into expr and non-expr versions.

Add weak-pair support to equal?.

Add call/cc as alias.

Allow calling register-predicate! twice with the same args.

Put back support for printing tagged lists and vectors when built by 9.2.

Make sure that tagged vector/pair predicates are registered.

Change compiled-code environments to be records.

Put error messages back into classifiers.

Also:
* Clean up spar API some more.
* Add spar-error for signalling errors.
* Add special args for specifying procedure args.

Rename spar-require-X to spar-match-X.

Make sure to flatten items in a body.

Rewrite mit-syntax using syntax parsers.

This is functionally equivalent except for error reporting.  Most syntax errors
will be "ill-formed syntax" with a form.  An future commit will tailor the
messages to be more informative.

This also breaks one syntax test, which will be fixed in the next commit.

Another round of changes to the spar API.

Fix thinko.

Implement spar-macro-transformer.

Split transformer->expander procedures into internal and external.

The external version takes a runtime environment as its closing env, while the
internal version takes a syntactic environment.

Merge classifier and keyword items.

A round of updates to the syntax parser.

Add syntax-parser to runtime; not yet being used.

Refactor the syntax-error mechanism.

* There's now a condition type for syntax errors.
* There's a distinction between errors that happen in macro expanders and those
  that happen inside the syntax implementation.
* All syntax errors now get the (form senv hist) objects.
* Syntax errors don't yet use the history to report context; that will come
  later.

Eliminate keyword-binder.

Make field-names argument of condition-constructor be optional.

When that happens it uses the type's field-names value.

Simplify slightly be introducing smap.

decl-item doesn't need to be distinct from expr-item.

Make sure history is correct for identifiers in declarations.

Plumb selectors through map-decl-ids and pass to procedure.

Reorganize cold-load for syntax.

* Rename syntax-transforms to syntax-low.
* Move expander-item to syntax-low.
* Don't load syntax-items early in cold load.
* Move compile-expr-item to syntax-items.

Bind classifiers directly into global environment.

Eliminates kludge of syntax-definitions.

Eliminate compile-body-item and simplify.

Minor tweaks to classifiers.

Rename classify-body to classify-forms-in-order.

Also have it return a list of items rather than a seq-item.

Some minor tweaks that were missed in earlier commits.

Eliminate compiler items.

Eliminate compiler->keyword.

Eliminate the remaining three compilers.

Change most of the "compilers" to "classifiers".

This is the first step in eliminating the idea of a "compiler".