I've been reviewing the ancient records (LOL was most of
sweet-expressions decided just last year? (^_^)v)

So, this is just a recap of why the current sweet-expressions looks
the way it currently does.


As a complete and utterly gratuitous non-sequitur, I prefer (^.^)
smilies to :-) smilies because the () pair up in the former.


The path that was tread by sweet-expressions to get to where we are
now was basically:

1.  David A. Wheeler started with indentation semantics in general
(i.e. deduce parens from indent)

2.  David then (apparently) searched through existing semi-formalized
proposals for indentation and found SRFI-49:
2. a.  Indentation means "child of next less indented line above it"
2. b.  Multiple items on a line form a list
2. c.  Single items are just that item.
2. d.  Symbol 'group when found as the first item on a line is deleted
(i.e. the magic non-existent symbol).  To start a line with an actual
"group" you double up the "group" so that the first group is deleted
but the second remains (this is explained later on this list by Egil
Moller; initially our understanding was that it forced a grouping).

3.  David adds curly-infix and n-expressions over the basic SRFI-49
I-expressions (these two were somewhat independently built, mostly by
David, although discussed in the list; in particular I think I (Alan)
was the one who pointed out that automatic infix detection sucked, by
using the "convoke" example).

4.  List goes on hiatus as secondary participants move on, and David
(apparently) goes on a PhD-hunting spree and incidentally proves for
some reason that compiling things twice using open-source compilers
prevents some guy named ken from adding backdoors to every system on
the planet.

5.  David begins planning out some extensions over the basic SRFI-49,
describes them slightly on his webpage.  Some posts exist on the list,
scattered over 2006->2011, mostly David very occassionally posting
something about something.
5. a.  This includes some random stuff about "SPLICE", which is mostly
due to Arc's nasty if syntax.  Initially SPLICE is just a continuation
marker, then David extends it so that it has an inline meaning (the
same as the current GROUP/SPLIT when inline), and finally David
extends it so that it becomes invisible when at the start of a line.
SPLICE is spelled "\".

6.  Arne floats the idea to replace "group" with the syntax ".".
David mentions preferring a "larger" character ("because a period is
almost too small") and floats the idea to use "\".  This discussion
peters out mostly unresolved.

7.  Some guy named almkglor pops up late in June 2012, rants about how
Haskell is kewl and how every Lisp should be exactly like Haskell
except when it's like Lisp, and complains that every Haskell
implementation he can find can't be bootstrapped on his employer's
system except for Hugs98, which can't run GHC and doesn't have any of
GHC's kewl extensions like type class families (which he still doesn't
understand, but are kewl anyway).  He builds a parser description for
sweet-expressions using a system that exists only in his head.

8.  almkglor incidentally mentions that "\" (which David last proposed
as an alternative spelling for "group" instead of ".") was also
proposed before by David as SPLICE.  He points out that the
SPLICE-at-the-end rule is not easily implementable on a
one-char-lookahead machine, at least if you're going to consider
whitespace+EOL == EOL (which you should).

9.  Since David proposed "\" for SPLICE and later proposed "\" for
GROUP, almkglor assumes that what David is actually proposing is that
SPLICE and GROUP be somehow merged into a single semantic, and starts
working out how to safely merge both.  At this point GROUP is still
considered as meaning "add an extra layer of indent" rather than the
current meaning of "magical invisible symbol that is automatically
removed if it's the very first symbol".

10.  almkglor points out that Egil Moller himself said (in a message
somewhere in the limbo of The Hiatus) that "group" was intended to be
the magic invisible symbol, so that GROUP at the beginning was
equivalent to not having anything there, it just marked a point at
which that particular line actually indented.

11.  almkglor points out that Egil Moller's explanation means that
GROUP and SPLICE work exactly the same when at the start of a line.

12.  almkglor and David start discussing GROUP, SPLICE, and another
semantic called ENLIST (in modern terms, it acts more like the current
":" notation by Arne). Arne points out that SPLICE-inline rule is
complicated to explain; almkglor counters with the fact that it's
needed for easy usage of Arc if-syntax and CL keyword-syntax.

13.  David trolls the mailing list with the idea to use "." for indentation.

14.  almkglor goes on a spree of starting all sorts of threads on the
mailinglist to confuse everyone else into submission.

15.  almkglor renames SPLICE to SPLIT, since it's no longer actually a
SPLICE, with the removal of the SPLICE-at-the-end rule.

16.  David sets up the git repo.  almkglor starts a spree of
implementing what he wants, and pasting the bundle files on the
mailing list.

17.  People start discussing stuff, mostly David and almkglor, and
mostly only about GROUP/SPLIT/SPLICE/ENLIST and "."-as-indent.

18.  David and almkglor pretty much decide on SPLIT semantics to solve
the "double-bracket" and "freaking-Arc's-if-and-CL's-keywords"
problems using one semantic.  It's first spelled "\", then "\\".

19.  almkglor proposes SUBLIST just 2 weeks before the next scheduled
spec freeze.

20.  David initially thinks SUBLIST==ENLIST.

21.  almkglor points out that ENLIST is a (surprisingly) complicated
(implementation-wise) semantic that needs to be thought out more and
more, especially when found in the middle of a line; SUBLIST is
simpler.  After sketching out how ENLIST-at-the-start works, his
promptly BSOD's while thinking of reasonable ENLIST-inline rules
(despite his brain running Linux, it was that bad).  He declares "so
I'm really gonna have to pass ENLIST to one of you guys to consider."

22.  Nobody (apparently) picks up ENLIST.

23.  David says "What the heck, let's put it in" about SUBLIST.

24.  almkglor starts enjoying SUBLIST after finding that its limited,
simple semantics give surprisingly powerful expressive power.  During
all this time, there are several tangential and not-so-tangential
discussions on the list, mostly about other Lisp-like languages.

25.  David settles on "!" for indentation rather than ".".  almkglor
shrugs, since he too was struggling with implementing "." as

26.  0.3 gets frozen, with GROUP/SPLIT and SUBLIST, and "." as indentation.


Fast forward to today, the basic GROUP/SPLIT and SUBLIST have pretty
much remained at their 0.3 spec meanings (SUBLIST-at-start gets a
meaning at 0.4 - it had no meaning in 0.3 and triggered an error then;
this meaning can arguably be considered an extension of the
SUBLIST-inline meaning, with the LHS of SUBLIST being the empty list),
and we have a COLLECTINGLIST which is needed to handle R6RS library /
R7RS define-library.

Arne's ":" appears to be what ENLIST could have been, if someone had
picked it up then.

How about we try rewinding into ENLIST?

Free Next-Gen Firewall Hardware Offer
Buy your Sophos next-gen firewall before the end March 2013 
and get the hardware for free! Learn more.
Readable-discuss mailing list

Reply via email to