bug#24982: 24.5; way to let Elisp reader ignore unreadable #(...) constructs

[Drew Adams <drew.adams@oracle.com>]

You bring up a few things.  I'll comment only about
commenting. ;-)

> I couldn't quite remember whether the Common Lisp #| |# was balanced,
> but it is, which is nice.  That is, you can write
> #| foo #| bar |# zot |#
> and the first |# doesn't end the first #|.

Yes, CL block commenting is fully nestable and unnestable.

(IMO, that's really the point/advantage of block commenting.)

> I'm not an expert on the Emacs Lisp reader, but poking at it at bit, it
> seems like adding support for #| |# should be trivial: It's just a new
> comment syntax, really, so we just have to count #|'s and discard the
> input.

Possibly; dunno.

[Aside: I think it would be great if Elisp had reader
macros - give Lisp programs control over the Lisp reader.]
 
> So ... What's the use case?  Well, I think it's handy
> when developing.  If I'm in the middle of a function
> (foo)
> (bar)
> (and-here-i'm-adding-some-new-stuff-that's-not-finished
>   ...
>   )
> (zot)
> 
> and I'm testing stuff, and I decide to take out the stuff I'm
> writing...  Emacs doesn't really handle that well.  I usually end up
> deleting the sexp, and hoping that the kill ring is big enough to hold
> it until I need it again, or slapping a (when nil ...) around it, which
> is unsatisfactory, because that changes the indentation.
> 
> Just being able to do:
> (foo)
> (bar)
> #|
> (and-here-i'm-adding-some-new-stuff-that's-not-finished
>   ...
>   )
> |#
> (zot)
> 
> would be nice.  And then the stuff I'm working on doesn't even have to
> be syntactically correct.

Yes.  Well, we do have such a feature, but we don't have
it by just inserting paired delimiters.

We have it with `comment-region' (and similar).  How so?
Plain `C-u' UNcomments/unnests a given comment level.

One difference, besides the paired-delimiter one (but
which follows from it), is that you can't do it with
the same effect in-line.

Another is that because a single `;' comments to eol,
syntactically there's no essential difference among
`;', `;;', `;;;', etc.  And yet the commenting and
UNcommenting of `comment-region' give you the
additional control of how many `;' to work with.

E.g., you can "uncomment" by N `;', which may uncomment
some code and leave other code commented (which had M>N
`;').  But that's also what makes `comment-region' and
its `C-u' give you block-commenting behavior.

That's how I use `comment-region' - for block commenting
and uncommenting - unnesting a block of commented code.

And it's why I use `M-;' (`comment-dwim') ONLY for a
comment after a line of code.  I don't use it to comment
the region as a block comment.  Its behavior when the
region consists only of comments is different from its
region behavior otherwise.  And I don't want that.
___


Actually, instead of `comment-region' for block commenting
I use this, which is the same except it comments/uncomments
whole lines.

(defun comment-region-lines (beg end &optional arg)
  (interactive "*r\nP")
  (when (> beg end) (setq beg  (prog1 end (setq end  beg))))
  (let ((bol  (save-excursion
                (goto-char beg)
                (line-beginning-position)))
        (eol  (save-excursion
                (goto-char end)
                (if (bolp) (point) (line-end-position)))))
    (comment-region bol eol arg)))