Re: Break code lines fluently

[Andrey Tykhonov]

Drew Adams <drew.adams@oracle.com> writes:

>> (defun test ()
>>   (let ((test t))
>>     (if test
>>         (message "True")
>>       (mes|sage "False"))))
>> Point is located in the middle of "message" function. And I would like to
>> insert more code to the `let' form (after the `if').
>
> Here is one approach:
>
> C-- 2 C-M-u RET
>
> C-M-u is `backward-up-list'.  You give it a negative prefix arg to go
> forward instead of backward.  -2 means go forward and up past (-1) the
> `message' sexp and then (-2) past the `if' sexp.  RET then indents
> (with recent Emacs dev snapshots - use C-j with older versions).
>
> If you don't want to count, just repeat C-- C-M-u until you get where
> you want to go.
>
> You can also bind `up-list' to a key, and use that to do the same
> thing as C-M-u with a negative arg.  E.g.
>
> M-x global-set-key C-o RET up-list RET
>
> C-o C-o RET ; move up & forward 2 list levels, then newline & indent
>
> The real advantage of binding a key to `up-list' is that you can
> just hold that key (C-o or whatever) down until you get where you
> want (the same as you can do with `backward-up-list', C-M-u).
>
> Prefix key `C-M-' introduces Lisp stuff in Emacs-Lisp mode, including
> commands that move over lists: e.g., C-M-u, C-M-d, C-M-n, C-M-p.  And
> commands that move over sexps, whether lists or not: C-M-f, C-M-b.
>
> Others will no doubt give you other ways, in particular that make use
> of 3rd-party libraries.  There are many ways to skin this cat.
>
> (If you use a mouse, you can of course also just click where you want
> to insert the newline: direct access.  That's sometimes easier or
> quicker, since you can see the destination and you don't need to move
> there incrementally or by counting list levels.  But it does take one
> hand off the keyboard.)

Thank you for such detailed the answer! I learned something new. I didn't
know about `up-list' command and most of the mentioned key bindings.

The goal of my little package is to insert new line (based on context) to a
Emacs Lisp code by means of very handy way (I believe so).

I like approach used by this package because it allows: 

1) do not pay additional attention (by looking at highlighted opened
bracket) whether my cursor is located after the right closing bracket (so
then I can hit C-j and input a code); after execution of `smart-return'
command new line indents so it is a little bit easily to note by means of
indentation level whether it is right place to input new code or not;

2) do not perform additional *navigation* through the code (within opened
and closed brackets) but just insert new line from the current cursor
position and to be ready to input new code immediately (by means of one
`smart-return' command execution or several).

3) to have one shorthand key binding (for example H-RET, as I have) instead
of different combinations of key bindings. For example:

(setq gnus-gcc-mark-as-read t
      gnus-expert-user t
      gnus-suppress-duplicates t
      gnus-con|firm-mail-reply-to-news t
      gnus-ignored-newsgroups ""
      nnml-get-new-mail t
      gnus-add-to-list t)

to append new SYM/VAL pairs to the `setq' form I need to C-o (`up-list'),
then C-b and lastly C-j. (Or probably the best way to do that is to hit
C-M-f as much as required and then C-j). But instead of such navigation and
following C-j I would like to have one command which can just *put* cursor
in the right place and will allow just to input SYM/VAL pair to the `setq'
form. Is case of such `setq' and `smart-return' it is required to hit key
binding only once.

"one hit" instead of several hits (in such case and others) probably
doesn't bring a huge advantage. But for me valuable advantage is to have
one key binding instead of several (such as `forward-sexp', `up-line') for
such trivial purpose as insert new line.


(By the way, I just updated this package and removed surplus `undo'
step. So mentioned example in the original message could be performed by
means of just three command executions instead of five).


Thank you!

Andrey