"assoc" for returning ALL associations for a given key

"assoc" for returning ALL associations for a given key

[florian]

I somehow suspect this question must have been discussed dozens of
times before, but well ...

As is well known, association lists differ from hashes in that the
same key can occur several times, and (assoc KEY ALIST) will return
only the first such occurrence.

Consequently, a convenient method for changing the value of an
association is to simply conse the new association to the front of the
alist, which will make any old associations with the same key
"invisible" (even if that feels kind of messy to me).

I am not wondering, however, whether it is generally better to use
hashes; rather, I am musing about whether the fact that association
lists may contain the same key several times could be seen as an
advantage: An alist could be the obvious place to store information
such as, e.g.,  "In which directories do I have a file with basename
X?", where X would be the key, and the directories, the values.

I have found no function comparable to assoc to cater for such a need,
and have thus written one for myself:

    (defun assocs (key alist)
      "Like `assoc', but return all elements of ALIST whose car is
`equal' to KEY.
In other words, return a subset of ALIST."
      (delq nil
	    (mapcar '(lambda (cons-cell)
		       (if (equal (car cons-cell) key)
			   cons-cell))
		    alist)))

But I am wondering whether that would have been necessary - perhaps I
am overlooking something? Otherwise, would anybody care to comment
about the efficiency of the above function?

Many thanks for your thoughts!

Florian

Re: "assoc" for returning ALL associations for a given key

[Juanma Barranquero]

On Tue, May 5, 2009 at 10:59, florian <lorian@fsavigny.de> wrote:

> But I am wondering whether that would have been necessary - perhaps I
> am overlooking something?

If you use the CL package (included in Emacs), `remove*' and friends
can be used for that:

  (remove* nil ALIST :key '(lambda (item) (equal (car item) KEY)))
  (remove-if-not (lambda (item) (equal item KEY)) ALIST :key 'car)

etc.

    Juanma

Re: "assoc" for returning ALL associations for a given key

[Pascal J. Bourguignon]

florian <lorian@fsavigny.de> writes:
> [...]
> But I am wondering whether that would have been necessary - perhaps I
> am overlooking something? Otherwise, would anybody care to comment
> about the efficiency of the above function?

(require 'cl)
(remove* key a-list :key (function car) :test-not (function eql))


(let ((key :one)
      (a-list '((:one . "un")   (:two . "deux")
                (:one . "eins") (:two . "zwei")
                (:one . "one")  (:two . "two"))))
  (remove* key a-list :key (function car) :test-not (function eql)))
-> ((:one . "un") (:one . "eins") (:one . "one"))



-- 
__Pascal Bourguignon__

Re: "assoc" for returning ALL associations for a given key

[Nikolaj Schumacher]

florian <lorian@fsavigny.de> wrote:

>     (defun assocs (key alist)
>       "Like `assoc', but return all elements of ALIST whose car is
> `equal' to KEY.
> In other words, return a subset of ALIST."
>       (delq nil
> 	    (mapcar '(lambda (cons-cell)
> 		       (if (equal (car cons-cell) key)
> 			   cons-cell))
> 		    alist)))
>
> But I am wondering whether that would have been necessary - perhaps I
> am overlooking something? Otherwise, would anybody care to comment
> about the efficiency of the above function?

A lot of temporary cons objects are created, so it's probably not the
most efficient way of doing this.

If efficiency is really critical, you should build the list yourself.

Or maybe create no list at all, if appropriate...

(dolist (el lst)
   (when (equal (car el) key)
      (do-stuff-here ...

That's easier on the eyes, too. ;)

regards,
Nikolaj Schumacher