Jorge, thanks for the quick response!


>  * If the cursor is at the end of a list item, then "Return" should
>>  insert a new list item (i.e., automatically perform   org-meta-return)
>>
>
> M-<enter> does this. You do not want <enter> to do that because you when
> you want to finish the list <enter> finishes it.
>

I don't think I explained myself clearly the first time around. The
behavior I'm hoping to achieve (i.e., the default bulletting behavior in
Google Docs, OSX Notes, etc.) is as follows:

;; Starting with this setup:

- one
- two
 + a[CURSOR_HERE]

;; Hitting <enter> should produce:

- one
- two
 + a
 + [CURSOR_HERE]

;; Hitting <enter> again would then produce:

- one
- two
 + a
- [CURSOR_HERE]

;; And hitting <enter> one last time would produce:

- one
- two
 + a

[CURSOR_HERE]

I know we can already achieve this with some combination of M-<enter>,
<enter>, and M-S-<enter>, but this behavior has 2 distinct advantages:

1. The user only needs to remember one key to cycle between all of these
actions, rather than 3 key combinations.
2. This behavior is more consistent with the bulleting behavior in other
editors, which could make it feel more intuitive for new org-mode users.


>  * If the cursor is at the beginning of an empty list item, then
>>  "Return" should outdent the list item (or remove it if it's   already at
>> the outer-most indentation level)
>>
>
> I am not sure that I understand this but I assume that you would obtain
> the same with <tab>. It goes back and forth between levels of list so if
> you have
>
> - one
> - two
>  + a
>  + CURSOR_HERE
>
> and you hit <tab> then it changes to
> - one
> - two
>  + a
>    + CURSOR_HERE
>
> and then two times <tab> (or S-<tab> from the beginning) changes it to
>
> - one
> - two
>  + a
> - CURSOR_HERE
>

Yes, but for the reasons mentioned above, it'd be nice if we could use the
<enter> to outdent a new list entry as well.


>  * If the cursor is at the beginning of an empty list item, then
>>  "Backspace" should delete the list item and move my cursor to   the end of
>> the previous list item
>>
>
> I guess you could remap <backspace> to a function that checks if you are
> at the beginning of the list and when that is true it does what you want,
> otherwise it just calls `delete-backward-char'. But generally I would do
> C-a C-k <backspace>, just two more keystrokes.
>

Makes sense. This is an easy function to write -- just wanted to make sure
there wasn't something that already does this out-of-the-box.


>  * It'd be nice of these rules could be applied to checkboxes as well
>>
>
> M-S-<enter> inserts a check box.


In general, I *believe* a lot of folks use lists and checkboxs in similar
ways. I certainly do, and I frequently accidentally hit M-<enter> while
editing a checkbox when I really intend to insert a new checkbox entry. As
a result, it seems desirable to create an interface that treats them more
similarly (e.g., using a single <enter> keypress to auto-insert a new
entry).

If this doesn't exist yet, I'd be happy to roll it myself. But it'd be nice
to avoid re-inventing the wheel here if possible :)