RE: [External] : Re: Updating *Completions* as you type

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

> > I think we should choose a key to toggle completion 
> > type between history/default/regular completion.
> 
> That works too of course, although it causes some 
> more proliferation of keys.

The approach I took in Icicles is preferable, IMO.
Food for thought:

1. There can be any number of sort orders to choose
   from at any given time, i.e., in any given context.
   For different calls to `completing-read' (e.g.
   for different commands), some very different sort
   orders can make sense.

   And one of the available ways of sorting is to do
   nothing - NOT sort the available candidates.  This
   can be useful if the completion function already
   provides them in a useful order, or if any sorting
   at all would be expensive for some reason.

2. Instead of wasting multiple keys, one for each
   sort-order choice, a single key cycles among them:
   `C-,'.

3. For any `completing-read' call there can also be
   a set of alternative sort orders.  You can toggle
   to the current alternative sort using `C-M-,'.
   And you can cycle among the available alternative
   orders using `M-,' (just like `C-,').

4. Both `C-,' and `M-,' also provide another way to
   choose a sort order, besides cycling to it: use
   completion to choose it by name.

5. You can choose, with an option, whether, by default,
   to (1) always use cycling to choose a sort order,
   (2) always use completion, or (3) cycle if there are
   fewer than N orders to choose from and complete if
   there are N or more.

6. Reversing the current sort order is just `C-,' with
   a numeric prefix arg, e.g., `C-9 C-,'.

7. Regardless of your user-option preference (#5), you
   can flip to the other kind of choosing as a one-off,
   on the fly, using a non-numeric prefix arg.  E.g.,
   if the option says to use cycling in the current
   situation then `C-u C-,' switches to choosing the
   order by name (completing).

8. It's very easy for users to define new sort orders.
   This is quite important, IMO.  It should seem clear,
   from your discussion so far, why this makes sense.

9. The available sort orders for `C-,' are defined by
   a user option.  But commands can adjust this list
   of possibilities by adding command-specific sort
   orders or removing some that might be inappropriate.

10. The sort order you last chose remains in effect
   for subsequent completion (e.g. other commands).
   But if the sort order isn't appropriate for some
   command it can turn sorting off, in which case
   `C-,' lets you choose an appropriate order. 

11. IMO, there is no reason at all to have different
   sort orders for display and for cycling:
   `display-sort-function' and `cycle-sort-function'.
   At least I haven't seen (or heard) any reason.
   Can anyone say why these aren't the same thing in
   Emacs?

   And even if there were some use case where someone
   might want them to differ, why wouldn't the normal,
   default case be for them to be the same (synced)?

   You're apparently already beginning to wonder about
   a difference between a "current" completion in
   *Completions* (the one that's highlighted) and a
   "current" completion in the minibuffer, no?  Why
   let them differ, ever - what's the use case?

   In my code (both Icicles and tiny `sortie.el') the
   two are the same.  The current candidate in the
   minibuffer is always the candidate highlighted in
   *Completions* (and vice versa - identical).

12. The current sort order, and whether it's reversed,
   is indicated in the mode-line of *Completions*, so
   you always know what sauce you're being cooked in.

https://www.emacswiki.org/emacs/Icicles_-_Completions_Display#SortOrder
   
13. I wonder if any of you have even looked at the doc
   describing the features I'm talking about.  I get
   the impression you're maybe starting to re-invent
   the wheel, without looking at how existing round
   things have been rolling along so far.

https://www.emacswiki.org/emacs/Icicles_-_Sorting_Candidates

(Many of the same sorting features are available with
`sortie.el' as with Icicles.  Trying it with library
`keysee.el' is a simple way to see what it's like.)

https://www.emacswiki.org/emacs/Sortie

https://www.emacswiki.org/emacs/KeySee