Immutable queue in Clojure

35
votes

What is the best way to obtain a simple, efficient immutable queue data type in Clojure?

It only needs two operations, enqueue and dequeue with the usual semantics.

I considered lists and vectors of course, but I understand that they have comparatively poor performance (i.e. O(n) or worse) for modifications at the end and beginning respectively - so not ideal for queues!

Ideally I'd like a proper persistent data structure with O(log n) for both enqueue and dequeue operations.

3
algorithmdata-structuresclojurequeueimmutability
To save someone from writing about how cons lists can be used to implement push/pop stacks (like I almost did), don't forget the question asks about queues. :-) - Joey Adams
Just noticed there is a class called PersistentQueue in the latest 1.2 snapshot Clojure Java source.... may be the answer to my own question - mikera
It's been in there since forever (just checked with 1.1, but I think it's older than that). Note that there's no factory function nor reader syntax for it provided by default; use clojure.lang.PersistentQueue/EMPTY to get an empty instance. Then conj, pop & peek work as they should with a queue. See e.g. my answer to this question: stackoverflow.com/questions/2760017 for some code written with both c.l.PQ and Java's LinkedBlockingQueue. - Michał Marczyk
Cool, thanks Michal! I guess I missed it at first because there wasn't a simple "queue" constructor in the API. Maybe I should submit a patch :-) - mikera
PersistentQueue is indeed one of Clojure's more closely guarded secrets. ;-) About possible queue-related API enhancements, see this thread on Clojure Dev: groups.google.com/group/clojure-dev/browse_thread/thread/… Note that's probably a very low-priority matter right now, what with the new numerics and all... - Michał Marczyk

3 Answers

37
votes

Problem solved - solution for others who may find it helpful.

I've found that Clojure has the clojure.lang.PersistentQueue class that does what is needed.

You can create an instance like this:

(def x (atom clojure.lang.PersistentQueue/EMPTY))

As far as I can see, you currently need to use the Java interop to create the instance but as Michal helpfully pointed out you can use peek, pop and conj subsequently.

9
votes

I use the following function queue to create a PersistentQueue. Optionally, you might want to have a print-method and a data-reader if you're going to be printing and reading the queues.

The usual Clojure functions are already implemented for PersistentQueue.

  • peek -- get the head
  • pop -- returns a new PersistentQueue without the head
  • conj -- add item to the tail
  • empty? -- true if empty
  • seq -- contents as a sequence (list)

    (defn queue
      ([] clojure.lang.PersistentQueue/EMPTY)
      ([coll] (reduce conj clojure.lang.PersistentQueue/EMPTY coll)))

    (defmethod print-method clojure.lang.PersistentQueue
      [q ^java.io.Writer w]
      (.write w "#queue ")
      (print-method (sequence q) w))

    (comment
       (let [*data-readers* {'queue #'queue}]
         (read-string (pr-str (queue [1 2 3])))))
1
votes

Clojure could really benefit from a queue literal. This would be cleaner (and more portable) than relying on Java interop.

However, it's not that hard to roll your own portable persistent queue, just using ordinary household items like lists.

Consider the queue as two lists, one providing the head portion of the queue, and the other the tail. enqueue adds to the first list, dequeue pops from the latter. Most ISeq functions are trivially implemented.

Probably the only tricky part is what happens when the tail is empty and you want to dequeue. In that case the head list is reversed and becomes the new tail, and the empty list becomes the new head list. I believe, even with the overhead of the reverse, that enqueue and dequeue remain O(1), though the k is going to be higher than a vanilla vector of course.

Happy queueing!