go-fringe.go: Remove all of the `;' statement terminators.

f#-fringe.fs: Return to a simple mode line, but with the correct mode.

My Emacs configuration now knows not to use tabs in F# files.  But you
don't want to say `-*-MUMBLE-mode-*-'...

Makefile: Apparently Algol 68 Genie now has a compiler.  Let's use it.

I don't know how to get it to write its output to a particular place so
let it do its thing and then move it where we want it.

algol68-fringe.a68: Fix stupid typo in a comment.

.gitignore: Ignore CLisp droppings.

cl-fringe.lisp: Fix the `cl-launch' machinery.

Now it's a proper citizen.

sbcl-build: Improve error handling and generally tidy up.

In particular, the polyglot rune is now a bit less awful, and we have
pleasant error messages rather than vast stack traces of doom.

icon-fringe.icn: Give record types a capital letter.

Reduces ambiguity (there was already a collision).

icon-fringe.icn: Rearrange some of the code a little.

It's just a little prettier this way.

Makefile, sbcl-build: Refresh the Common Lisp build system.

Apparently SBCL won't just run its FASL files any more.  But there's a
gadget for bundling FASLs together now, so use that.  Unfortunately it's
a bit complicated, so turn the whole build system into a script (in
Lisp, natch).

haskell-fringe.hs: The libraries have moved around a lot.

Find them all again.

go-fringe.go: Language change: `closed' function on channels has gone.

Replaced by a two-valued `<-' read operator, which does exactly what we
want.

Makefile: The `Go' build system has been turned upside-down.

algol68-fringe.a68: Empty row displays are apparently not allowed.

So supply a useless thing.

algol68-fringe.a68: Change the Emacs mode hint.

I must have looked for the Algol 68 mode under a different rock.

Makefile: The F# compiler has changed its name.

Various files: Whitespace fixes.

f#-fringe.fs: The F# compiler really doesn't like tabs.

So let's make sure we never introduce any.

New language: Dylan.

I'm using Gwydion Dylan (from CMU); I don't know how much weirder
OpenDylan is, but the Dylan hackers are trying to converge the two.

Dylan is annoying for small projects because we need /three/ source
files.  Oh, well.

cl-fringe.lisp: Gratuitously allow :START and :END keyword arguments.

Just to illustrate the way Lisp sequence functions tend to work.

algol68-fringe: New language.

Well, not that new.  But it's a language which wasn't represented here
before.  I'm using the Algol 68 Genie implementation, which works as a
dynamic-ish runtime.  Astonishingly, it can call execve(2) but not
exit(3), so there's an appalling hack.  Sorry.

forth: Implement some simple structure-defining words and use them.

Alleviates the tedium slightly.  Also demonstrates `does>', which is
appropriately scary.

erlang: Rename language from `erl'.

No idea why I named it like that in the first place.

forth: New language.

Very unpleasant coroutine hacking.

I had a neat word for parsing the basename out of argv[0], but Gforth
doesn't actually let you get at the image name, so it just said `gforth'
which isn't very helpful, really.

New language: Erlang.

Makefile: Tweak various compiler options for quieter builds.

Makefile: Silent-rules stuff.

Not completely successful, because some of the build machinery underneath
is still somewhat noisy.  Oh, well.

cl-fringe.lisp: Abstract out the startup stuff.

Less is `cl-launch' specific.  There's some support for ECL and SBCL
native startup stuff.  Indeed, this seems to work better than `cl-launch'
does, so we'll stick with it.

.gitignore: Don't worry about FASL files.

scheme-fringe.scm: Don't need to import `syntax-case' any more.

Seems that it doesn't work if you try.

haskell: Trivial reformatting.

Oh, and notice that we don't need flexible instances any more.

go: New language.

Do iteration with goroutines and channels.  It's much prettier than
doing it with closures.

smalltalk: Abstract out the common iteration protocol into a superclass.

haskell: Remove some redundant parenthesis.

Actually this changes the semantics of the program slightly: Node becomes
a (curried) 3-ary constructor rather than a unary constructor accepting
a tuple.  This is all to the good.

haskell: Tidy up the parser using proper monadic combinators.

Hope this isn't too complicated.

cl, scheme: Introduce `reduce' functions.

These illustrate higher-order functions fairly nicely.  Note that
the CL version is explicitly iterative with side-effects because of
the lack of reliable tail-recursion.

cruft.el: Some Emacs tweaking.

Currently indentation rules for Scheme.

f#: Tidy same_iterators_p a little.

Use Option.isNone rather than a multiline pattern match, and use a
pattern guard to reduce failure cases.

Makefile: Remove redundant `.o' suffix from Scheme build stanza.

Makefile: Gather statistics and report them.

For now, just the lengths of the source files.  Maybe we can think of
more interesting things to measure later.

f#: Fix Emacs mode header.

cl: Tidy up parser slightly.

Most of the other implementations don't have separate cases for end-of-
input and not-open-paren; so don't penalize Lisp because I decided to
make the parser more extendable.

cl: Unpleasant hack to fetch program name.

It seems that `cl-launch' doesn't set CL_LAUNCH_FILE when doing `-X',
which is rather inconvenient.  Stuff using `mdw.sys-base' wins because
(massive cheat) ASDF systems are loaded before the program name is
stripped off the front of the argument list; we don't get that luxury
here.  So `*load-pathname*' will have to do; take `pathname-name' to
strip away the unpleasant realities of FASL-caching.

Of course, if we're dumping images then CL_LAUNCH_FILE is set properly.
<sigh>

scheme: Use `resume' to switch coroutines.

The name `switch' was taken by Chicken as an undocumented `case'-like
control structure.  Grumble.

cl: Dump a core image to improve startup times.

This is cheating: the core image is massive because SBCL doesn't tree-
shake.

Makefile: Print timing information in test output.

For some reason, C makes a very poor showing in the timings.  I'd love
to know why.  (Guess at `malloc' being a bottleneck.)

Initial version.