let !!$ x !!!!!!compute 'x !!!!y !!!!!!compute 'y !!use x y ==>
let INDENT INDENT x ; stack: (0 2 ?) INDENT compute 'x ; stack: (0 2 ? 6) DEDENT ; stack: (0 2 ?), indentation = 4 y ; stack: (0 2 4) INDENT compute 'y ; stack (0 2 4 6) DEDENT DEDENT ; stack (0 2) use x y DEDENT ==> let !\\ !!x !!!compute 'x !!y !!!compute 'y !use x y --- Hmmm..... let !!$ x (compute 'x) !!!!y (compute 'y) !!use x y ===> let INDENT INDENT x (compute 'x) ; stack: (0 2 ?) INDENT y (compute 'y) ; stack: (0 2 ? 4) - bummer!!!!!!!! DEDENT DEDENT ; stack: (0 2) use x y DEDENT ====> let !\\ !!x (compute 'x) !!!y (compute 'y) !use x y bummer!!!! On 2/19/13, Alan Manuel Gloria <almkg...@gmail.com> wrote: > On 2/19/13, Beni Cherniavsky-Paskin <c...@users.sf.net> wrote: >> Here is yet another idea for opening multiple levels on one line, that >> does >> NOT involve column counting, only comparison of leading whitespaces. >> >> It's a backward-compatible extension to SUBLIST (similarly applicable to >> any competing FOOLIST semantics), so we could leave it undecided for now, >> and legalize it later. >> >> $ lets one open an inner list on one line, but currently it's only usable >> when this list is the last element of the containing list: >> >> outer1 outer2 $ inner1 >> ! inner2 >> >> You cannot express (outer1 outer2 (inner1 inner2) outer3) >> without giving up on use of $. >> >> The proposal is to allow an unmatched dedent after inner2, and have that >> return you to the outer level: >> >> outer1 outer2 $ inner1 >> ! ! inner2 >> ! outer3 >> >> which would be equivallent to: >> >> outer1 outer2 >> ! inner1 >> ! ! inner2 >> ! outer3 >> >> More formally (described for simplicity in terms of numeric indentation >> levels; easily doable in terms of exact substrings): >> >> - Every $ pushes a "?" placeholder onto the stack of known indent levels. >> - As before, increases in indentation push a specific number onto the >> stack. >> - Dedents matching a level on the stack are handled as before, closing >> all >> levels to the right, whether specific or placeholders. >> - A dedent that doesn't match any specific level is *only* allowed if >> there >> is at least one placeholder between the closest specific levels. All >> higher levels are closed, and the *rightmost* (see rationate at end) of >> these placeholders is converted to the specific level seen. >> Let's say you had (10 ? ? 16) on the stack and you encounter a line >> starting with 14 spaces. This closes 16 and the new stack is (10 ? 14). >> A following 13 line would close 14 and leave (10 13), and then a >> following 12 line would be an error. > > I think it's also important to consider the "SAME" (as opposed to > INDENT or DEDENT) token. In particular: > > x > ! foo $ bar > ! a b > > ==> > > (x > (foo bar) > (a b) > ) > > Since the INDENT/SAME/DEDENT decision is based on the indentation > stack, I think we should specify it as follows: > > 1. Every $ adds a ? to the indentation stack, and emits an INDENT. > 2. On encountering an EOL, slurp the indentation. > 3. If the indentation is greater than the topmost non-? stack entry, > push its indentation level on the stack and consider it an INDENT. > 4. If the indentation is equal to the topmost non-? stack entry, pop > off ? stack entries (emitting a DEDENT for each). If there are no ? > on the stack top, emit a SAME. > 5. If the indentation is less than the topmost non-? stack entry, pop > off ? stack entries (emitting a DEDENT for each) until you reach a > state where the topmost non-? stack entry is less than or equal to the > indentation. > 5.1. If the topmost non-? stack entry is equal to the indentation, > pop off ? stack entries (emitting a DEDENT for each). > 5.2. if the topmost non-? stack entry is less than the indentation, > and there is at least one ? entry, pop off the topmost ? entry and > replace it with the current indentation (do not emit any INDENT or > DEDENT tokens). > 5.2. Otherwise, error! > > So, let's consider this classic SUBLIST text: > > probe $ call/cc $ lambda (exit) $ cond > foo? $ exit 1 > bar? $ 2 > > ==> > probe INDENT call/cc INDENT lambda (exit) INDENT cond > ; at this stage, stack is (0 ? ? ?) > INDENT foo? INDENT exit 1 > ; at this stage, stack is (0 ? ? ? 2 ?) > ; it sees an indent of 2, so it emits a DEDENT here > ; via rule #4. > DEDENT > bar? INDENT 2 > ; at this stage, stack is (0 ? ? ? 2 ?) > ; an empty line may be considered an indent of 0, > ; so insert 5 DEDENT's > DEDENT DEDENT DEDENT DEDENT DEDENT > > ==> > probe > ! call/cc > ! ! lambda (exit) > ! ! ! cond > ! ! ! ! foo? > ! ! ! ! ! exit 1 ; 5 indent's so far, so 5 levels, seems right > ! ! ! ! bar? > ! ! ! ! ! 2 ; 5 dedents after this, so we close!! > > -- > > Looks about right. > > Now the main reason to implement SUBLIST this way is, of course, the > bane of indentation syntax, LET: > > let > !!$ x $ compute 'x > !!!!y $ compute 'y > !!use x y > ==> > let > ; the first indent below is the "real" indent > INDENT INDENT INDENT x INDENT compute 'x > ; at this point, stack is (0 2 ? ?) > ; again, first indent below is "real" indent" > INDENT y INDENT compute 'y > ; at this point, stack is (0 2 ? ? 4 ?) > ; since we get back to an indent of 2, > ; emit 2 DEDENT's to get past the 4, > ; then (via rule 5.1) pop off all ? to > ; reach the 2 (which involves popping > ; off 4 indents). > DEDENT DEDENT DEDENT DEDENT use x y > ; again, empty line, pop off the single dedent > DEDENT > ==> > let > !\\ > !!\\ > !!!x > !!!!compute 'x > !!!!!y > !!!!!!compute 'y > ..... > > well, bummer, doesn't work. > > Oh well. > > Sincerely, > AmkG > > >> >> A common objection to any scheme allowing unmatched dedents is that it >> requires lookahead, both for machine parsing *and humans*. When you >> read: >> >> foo >> ! ! bar >> ... pages of stuff >> ! ! baz >> ! quux >> >> it's very disconcerting to realize that all this bar...baz stuff was not >> a >> direct child of foo but was nested within a ...quux construct! >> But in our case, $ already declares that we opened an inner construct, so >> I >> think it won't be surprising to humans. >> >> What about multiple $ ambiguity? Given: >> >> A1 $ B1 $ C1 >> ! ! C2 >> ! B2 >> >> why does the dedent return you to the inner B level and not the outer A >> level? >> It's the only sane choice, for several reasons: >> - Continuity with current usage, which I expect will remain the dominant >> use of $: without unmatched dedents you only have access to innermost C >> level, so the accessible level should be the next innermost. >> - It's the only way (without magic lookahead) that allows you to access >> all >> levels, if desired. >> - It's similar to the standard resolution of "if A1 if B1 if C1 else C2 >> else B2". >> > ------------------------------------------------------------------------------ Everyone hates slow websites. So do we. Make your web apps faster with AppDynamics Download AppDynamics Lite for free today: http://p.sf.net/sfu/appdyn_d2d_feb _______________________________________________ Readable-discuss mailing list Readable-discuss@lists.sourceforge.net https://lists.sourceforge.net/lists/listinfo/readable-discuss
