(I forget the [PATCH] tag sometimes; sorry about inconsistency.)

This patch swaps out our SRFI-64 implementation for the one hosted at:

https://github.com/taylanub/scheme-srfis

The .body.scm files need no changes at all for Guile so keeping them in
sync with upstream should be trivial.  The .sld library can also be
trivially converted into Guile format, as seen in the srfi-64.scm file
containing the define-module/import/include boilerplate.

This implementation has a few advantages over the current one:

* Much better maintainability.  This hinges on several subjective
  points, but I hope for at least some of them to be highly agreeable,
  because this is the main advantage.

** The library is split into three main sub-libraries: the test-runner
   data type, the default "simple" test runner, and "execution," which
   contains the forms with which you write test suites themselves
   (without mucking with runners).  Source location information resides
   in a small fourth sub-library (more such might be added).

** Much less cond-expand clutter.  Long live C-M-a/C-M-e!

** Makes use of modern Scheme features instead of trying to be
   ultra-portable.

** Overall cleanup of coding style: using modern best-practices and
   idioms, being more internally consistent in style, being generally
   cleaner in small things like variable naming and whitespace, thus
   making the code overall more readable.

*** I use the <foo> naming convention for syntax-rules pattern
    variables.  I've been doing this for a while and in my experience it
    doesn't conflict with record type names, very clearly demarcates
    pattern variables in syntax templates (which is important because
    their semantics is significantly different from normal identifiers;
    I occasionally fall for this when I'm tired), and the code reads
    very nicely like BNF.  Please trust me on the merits of this
    notation and allow it at least in these source files.

* Somewhat nicer output by default.  Isn't silent on passing tests,
  shows information on failing tests directly instead of putting them
  into a log file.  I feel that it's closer to the typical 'make check'
  output we're used to from other programs, so I don't feel lost.

(No log file is produced at all by default, since it wouldn't contain
more output than the stdout.  If this disturbs some people's workflow, I
can add the feature back.)

And also:

* The author is committed to maintaining it well for Guile
  specifically. :-)

The implementation is tested against (an extended version of) Kawa's
SRFI-64 meta-test-suite, though it's in R7RS format in my repository; I
can port that to Guile too eventually.

If you think that the fact that this is a huge refactoring still means
it might contain more bugs than the original, then I'd like to point out
that the original contained at least one nontrivial bug for a long time
which in my opinion was likely a result of the sloppy style of the code
and the tendency of the code-base to mentally tire out a programmer.  I
hope I don't sound like a crazy code cleanliness pedant, but I do think
it's fairly important.

(If you have time, you might want to skim through the original code-base
a bit, and then this one, to see what I mean.)


Guile's test suite passes with this patch.


If you disagree with my mostly subjective points and don't want to
accept this patch, no hard feelings.  Guilifying the R7RS library was
trivial.

Taylan