Function to merge two property lists?

Question

I have not found a standard Elisp library function to merge two property lists, like this:

(setq pl nil)
(setq pl (plist-put pl 'key-1 'value-1))
(setq pl (plist-put pl 'key-2 'value-2))

I could build something with dolist, but before I do, I would like to check that I'm not overlooking an existing function in some library.

Updates, based on the comments:

1. In response to the "many-ways" comment:

I would imagine that there isn't such a function because there are different (and possibly valid) answers possible to the question: what to do when you have duplicate property names with distinct values?

Yes, there is a question on how to merge duplicates, but there are relatively few ways to address that. I see two general approaches. First, argument order could resolve the duplicates; e.g. rightmost wins, as in Clojure's merge. Second, the merge could delegate to a user-provided callback function, as in Ruby's merge.

In any case, the fact that there are different ways of doing it does not prevent many other language standard libraries from providing a merge function. The same general argument could be said of sorting, and yet Elisp provides sorting functionality.

2. "Could you elaborate?" / "Please specify the behavior you are looking for precisely."

Generally speaking, I'm open to what the Elisp community uses. If you would like a specific example, here would be one example that would work:

(a-merge-function '(k1 1) '(k2 2 k3 3) '(k3 0))

And returns

'(k1 1 k2 2 k3 0))

This would be a rightmost-wins style, like Clojure's merge.

3. "They're lists, so just append?"

No, append does not preserve property list semantics. This:

(append '(k1 1 k2 2) '(k2 0))

Returns this:

(k1 1 k2 2 k2 0)

append is a built-in function in `C source code'.

(append &rest SEQUENCES)

Concatenate all the arguments and make the result a list. The result is a list whose elements are the elements of all the arguments. Each argument may be a list, vector or string. The last argument is not copied, just used as the tail of the new list.

4. "And your example does not show anything like a merge - it does not even show two property lists."

Yes it does; it does the merge step by step. It shows how doing a merge using the Elisp's documented property list functions is painfully verbose:

(setq pl nil)
(setq pl (plist-put pl 'key-1 'value-1))
(setq pl (plist-put pl 'key-2 'value-2))

Just display the resulting output value from pl:

(key-1 value-1 key-2 value-2)

---

To reiterate, I am capable of writing a function to solve this problem, but I first wanted to figure out if such a function exists somewhere in common use.

Finally, if you downvoted the question because you found it unclear, I would ask that you reconsider now that I've gone to some effort to clarify. This is not a lack of research. The Elisp documentation on "Lists" does not answer the question.

Answer 1

Org-mode, which is included with Emacs, has a plist merge function:

(defun org-combine-plists (&rest plists)
  "Create a single property list from all plists in PLISTS.
The process starts by copying the first list, and then setting properties
from the other lists.  Settings in the last list are the most significant
ones and overrule settings in the other lists."
  (let ((rtn (copy-sequence (pop plists)))
        p v ls)
    (while plists
      (setq ls (pop plists))
      (while ls
        (setq p (pop ls) v (pop ls))
        (setq rtn (plist-put rtn p v))))
    rtn))

To use it you'd need to (require 'org) first to load the file. Unfortunately, it's a very large file, 900+KB, so it's not really usuable as a utility library. Something like a standard plist package would be nice to have.

I started a very small one recently and realized that alists and plists are not treated the same, argument-wise - eg (plist-get LIST KEY) vs (assoc KEY LIST), which must be some unfortunate relic of optimization (or ?).

But, yes, Emacs does need a nice plist library - I didn't come across across one in my search, but it's still possible there's one out there somewhere, or else we'll have to start one and put it on Elpa/Melpa.

An alist library with the same interface would be nice to have also.

Answer 2

Reading the manual and browsing the list from C-u C-h a plist RET doesn't turn up any function to merge two property lists. The Common Lisp extensions don't provide any function specifically to act on property lists, only place (getf/setf/…) support. So you either need to rely on a third-party library or roll your own.

Rolling your own isn't too difficult. This implementation uses the last value in case of conflict.

(defun plist-merge (&rest plists)
  (if plists
      (let ((result (copy-sequence (car plists))))
        (while (setq plists (cdr plists))
          (let ((plist (car plists)))
            (while plist
              (setq result (plist-put result (car plist) (car (cdr plist)))
                    plist (cdr (cdr plist))))))
        result)
    nil))

(plist-merge '(:x 2 :y 3)
             '(     :y 0 :z 7))
=>            (:x 2 :y 0 :z 7)

Answer 3

I know this has been answered already, but incase anybody is interested, I took the org implementation and played a bit of code golf on it

(defun plist-merge (&rest plists)
  "Create a single property list from all PLISTS.
Inspired by `org-combine-plists'."
  (let ((rtn (pop plists)))
    (dolist (plist plists rtn)
      (setq rtn (plist-put rtn
                           (pop plist)
                           (pop plist))))))