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.

A common objection to any scheme allowing unmatched dedents is that it
requires lookahead, both for machine parsing *and humans*.  When you read:

! ! 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
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:
Readable-discuss mailing list

Reply via email to