completing-read

completing-read

[John J Foerch]

Hello,

The following code exhibits a behavior of completing-read that I would call a
bug.  Or am I missing something?

(let ((table '((foo . "you selected foo")
               (foobar . "you selected foobar"))))
  (completing-read "Symbol: " table nil 'require-match))

The unexpected behavior is that it is impossible to select `foo'.

Thanks,
John Foerch

RE: completing-read

[Drew Adams]

> The following code exhibits a behavior of completing-read that I
> would call a bug.  Or am I missing something?
>
> (let ((table '((foo . "you selected foo")
>                (foobar . "you selected foobar"))))
>   (completing-read "Symbol: " table nil 'require-match))
>
> The unexpected behavior is that it is impossible to select `foo'.

You need to use strings, not symbols, if you use an ALIST second argument to
`completing-read':

(let ((table '(("foo" . "you selected foo")
               ("foobar" . "you selected foobar"))))
  (completing-read "Symbol: " table nil 'require-match))

completing-read

[drain]

I'm curious what the numbers passed to the completing-read function are
used for. Here is the example I found online:

(completing-read
 "Complete a foo: "
 '(("foobar1" 1) ("barfoo" 2) ("foobaz" 3) ("foobar2" 4))
 nil t "fo")

This function appears to work fine without the 1, 2, 3, 4.



--
View this message in context: http://emacs.1067599.n5.nabble.com/completing-read-tp323117.html
Sent from the Emacs - Help mailing list archive at Nabble.com.

RE: completing-read

[Drew Adams]

> I'm curious what the numbers passed to the completing-read function are
> used for. Here is the example I found online:
> 
> (completing-read
>  "Complete a foo: "
>  '(("foobar1" 1) ("barfoo" 2) ("foobaz" 3) ("foobar2" 4))
>  nil t "fo")
> 
> This function appears to work fine without the 1, 2, 3, 4.

You would probably need to look at the context of the example
you cite, to see why they used an alist or that particular alist.

As to whether it is *necessary* to use an alist: no.

1. If by "without the 1,2,3,4" you mean (("foobar1") ("barfoo)...)
then yes.  That has always worked just as well.

2. If you instead mean ("foobar1" "barfoo"...) then yes, that
works just as well also.  However, in older versions of Emacs
the second arg, if a list, had to be a proper alist.  You could
not pass just a list of strings.

3. The real point behind having an alist argument is that the
arg *can* be an alist.  There are lots of ready-to-hand alists
in Emacs.  You can pass an alist as arg directly, without first
mapping over it to get its cars.

Re: completing-read

[lee]

drain <aeuster@gmail.com> writes:

> I'm curious what the numbers passed to the completing-read function are
> used for. Here is the example I found online:
>
> (completing-read
>  "Complete a foo: "
>  '(("foobar1" 1) ("barfoo" 2) ("foobaz" 3) ("foobar2" 4))
>  nil t "fo")
>
> This function appears to work fine without the 1, 2, 3, 4.

Shouldn`t that, nowadays, be more like '(("foobar1" . 1) ...'?

So you cannot create a list like this (anymore)?

But it works here:


,----
| *** Welcome to IELM ***  Type (describe-mode) for help.
| ELISP>  (completing-read
|   "Complete a foo: "
|   '(("foobar1" 1) ("barfoo" 2) ("foobaz" 3) ("foobar2" 4))
|   nil t "fo")
| "foobar1"
| ELISP> 
`----


-- 
Knowledge is volatile and fluid.  Software is power.

RE: completing-read

[Drew Adams]

> > (completing-read
> >  "Complete a foo: "
> >  '(("foobar1" 1) ("barfoo" 2) ("foobaz" 3) ("foobar2" 4))
> >  nil t "fo")
>
> Shouldn`t that, nowadays, be more like '(("foobar1" . 1) ...'?

("foobar" 2) is the same as ("foobar" . (2)), that is, a cons
whose cdr is the list (2).  Nothing non-nowadays about such a
beast.

> So you cannot create a list like this (anymore)?

'("foobar" 2)
`("foobar" ,(length "ab"))
(list (symbol-name 'foobar) (1+ 1))
...

RE: completing-read

[drain]

Thanks for the help.

. . .

What are some cases in which using dotted pair notation would be better
than using list notation? Or even more interesting: cases in which dotted
pair notation would be /necessary/, and list notation would be impossible.

Right now this is just a theoretical distinction to me.




--
View this message in context: http://emacs.1067599.n5.nabble.com/completing-read-tp323117p323304.html
Sent from the Emacs - Help mailing list archive at Nabble.com.