Choosing interactively from a list

[Florian v. Savigny]

Hi there everybody,

I would like to do something which seemed easy to me at first glance,
but is now proving mysteriously difficult:

I have a list, say ("A" "B" "C" "D" ... "Z" "a" "b" "c" "d"
... "z"). I also have an index, say 13. I would like to choose an item
from this list in the minibuffer, and be able to go forward and
backwards in this list, starting from the index, i.e. here, 13.

In other words, if the list goes on alphabetically as hinted above, the
element with the index 13 would be the string "N". I would like to
have "N" as the initial input in the minibuffer, and I would like to
go back (i.e. "M", "L", "K" - you name it) with some key and forth
(i.e. "O", "P", "Q" and so on).

I tried to do this with the usual minibuffer functions, and it almost
works, but not completely as I would like it:

(defun choose-from-list (list &optional index)
  "Choose an item from LIST in the minibuffer.
Use a copy of LIST as history list, i.e. do not modify LIST.
Optional arg INDEX means start in the list at index INDEX."
(let ((reverse-list (reverse list))
      (reverse-ind (- (length list) index))
      (history-length t)) 
  (read-from-minibuffer "Choose: "
                        (nth index list)
                        nil
                        nil
                        (cons 'reverse-list reverse-ind))))

(setq list
      (list "A" "B" "C" "D" "E" "F" "G" "H" "I" "J" "K" "L" "M" "O" "P" "Q" "R" 
"S" "T" "U" "V" "W" "X" "Y" "Z"
            "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "o" "p" "q" "r" 
"s" "t" "u" "v" "w" "x" "y" "z"))

(choose-from-list list 13)

This does exactly what I want, i.e. hitting M-p gets me one item back
in the list; M-n gets me one item forward. However, I would like to
require that the user (me) cannot change the value from the list, only
pick it. Thus, I have tried completing-read instead of
read-from-minibuffer, because completing-read has REQUIRE-MATCH:

(defun choose-from-list-cmplr (list &optional index)
  "Choose an item from LIST in the minibuffer.
Use a copy of LIST as history list, i.e. do not modify LIST.
Optional arg INDEX means start in the list at index INDEX."
(let ((reverse-list (reverse list))
      (reverse-ind (- (length list) index))
      (history-length t)) 
  (completing-read "Choose: " list
                   nil
                   t
                   (nth index list)
                   (cons 'reverse-list reverse-ind))))


I imagine this should be the same thing as regards the minibuffer
history, but here, the history cycling is somehow different: Although
I get the same list element as initial input, hitting M-n now gives me
the item at the *beginning* of the list ("A"), M-p gives me the item
at the *end*.

Can somebody explain that to me? An important aspect might be that I
am not really looking for completion, but rather rigid cycling through
a fixed list. And the whole approach, i.e. using the history for
something that is not really a history (and is not even supposed to be
modified like a history variable is), reversing it etc, feels very
roundabout and not as it should be.

Many thanks in advance!

Best regards,

Florian

-- 

Florian von Savigny
Melanchthonstr. 41
33615 Bielefeld