Re: Utf8 symbols in completing-read completion item

[Jean Louis]

* Heime via Users list for the GNU Emacs text editor <help-gnu-emacs@gnu.org> 
[2022-10-20 15:26]:
> Am using "completing-read" to input greek letters. To introduce the 
> corresponding utf8
> symbol I just copy it in the completion item, then match with a pcase that 
> includes the
> utf8 symbol. Is this the correct way of doing so?

Your Lisp formatting is not readable:

(defun nuket-greek (actm)
"TODO"

(interactive
(list
(let ( (cseq '("alpha α" "beta β" "gamma" "delta" "epsilon" "zeta" "eta")) )
(completing-read "Nuke: " cseq nil t "eta"))))

(pcase actm

("alpha α" (insert "\\alpha"))

("beta β" (insert "\\beta"))

("eta" (insert "\\eta"))) )


I can read better when I format it this way:

(defun nuket-greek (actm)
  "TODO."
(interactive
 (list
  (let ((cseq '("alpha α" "beta β" "gamma" "delta" "epsilon" "zeta" "eta")))
    (completing-read "Nuke: " cseq nil t "eta"))))
(pcase actm
  ("alpha α" (insert "\\alpha"))
  ("beta β" (insert "\\beta"))
  ("eta" (insert "\\eta"))))

Myself I do not know what is \\alpha, but maybe you use that for
LaTeX or something. Personally I don't like complicated
`interactive' statements, it looks ugly.

I would use the features that beautiful function `completing-read' offers:

(completing-read PROMPT COLLECTION &optional PREDICATE REQUIRE-MATCH
INITIAL-INPUT HIST DEF INHERIT-INPUT-METHOD)

Read a string in the minibuffer, with completion.
PROMPT is a string to prompt with; normally it ends in a colon and a space.
COLLECTION can be a list of strings, an alist, an obarray or a hash table.

What I see is that you wish to choose something like "alpha α"
 and then to get different result like "\\alpha".

Following may give you the result automatically, by using hash:

(let ((hash (make-hash-table :test #'equal)))
  (puthash "alpha α" "\\alpha" hash)
  (puthash "beta β" "\\beta" hash)
  (puthash "gamma" "\\gamma" hash)
  (puthash "delta" "\\delta" hash)
  (puthash "epsilon" "\\epsilon" hash)
  (puthash "zeta" "\\zeta" hash)
  (puthash "eta" "\\eta" hash)
  (gethash (completing-read "Choose: " hash nil t) hash)

I would put larger lists into hash by using this:

(let ((list '("alpha α" "\\alpha"
              "beta β" "\\beta"
              "gamma" "\\gamma"
              "delta" "\\delta"
              "epsilon" "\\epsilon"
              "zeta" "\\zeta"
              "eta" "\\eta"))
      (hash (make-hash-table :test #'equal)))
  (while list
    (let ((key (pop list))
          (value (pop list)))
      (puthash key value hash)))
  (gethash (completing-read "Choose: " hash nil t) hash)) ⇒ "\\epsilon"

When I say larger list, my lists are huge and would not have time to
use single `puthash` one by one, I must let program do it.


-- 
Jean

Take action in Free Software Foundation campaigns:
https://www.fsf.org/campaigns

In support of Richard M. Stallman
https://stallmansupport.org/