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 indentation. 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. http://p.sf.net/sfu/sophos-d2d-feb _______________________________________________ Readable-discuss mailing list Readable-discuss@lists.sourceforge.net https://lists.sourceforge.net/lists/listinfo/readable-discuss