19

I recently listened to Rich Hickey's interview on Software Engineering Radio. During the interview Rich mentioned that Clojure's collections are implemented as trees. I'm hoping to implement persistent data structures in another language, and would like to understand how sets and Clojure's other persistent data structures are implemented.

What would the tree look like at each point in the following scenario?

  1. Create the set {1 2 3}

  2. Create the union of {1 2 3} and {4}

  3. Create the difference of {1 2 3 4} and {1}

I'd like to understand how the three sets generated ({1 2 3}, {1 2 3 4}, and {2 3 4}) share structure, and how "deletions" are handled.

I'd also like to know the maximum number of branches that a node may have. Rich mentioned in the interview that the trees are shallow, so presumably the branching factor is greater than two.

davidchambers
  • 23,918
  • 16
  • 76
  • 105
  • 4
    The branching factor is 32. – Rob Lachlan Apr 29 '13 at 04:32
  • Pedantic note: I just listened to Rich Hickey _Clojure Data Structures 2_ at http://www.youtube.com/watch?v=sp2Zv7KFQQ0. Not sure where or when this was recorded. Collections have different storage implementations. (default?) vectors are shallow trees. Other collections may have other implementations. – Shannon Severance Apr 29 '13 at 19:56
  • 1
    They do. Specifically: hash-set, hash-map, and vector have 32 children per node; sorted-set and sorted-map are red-black trees and have 2 children per node. – Chouser May 04 '13 at 14:39

4 Answers4

25

You probably need to read the work of Phil Bagwell. His research into data structures is the base of Clojure, Haskell and Scala persistent data structures.

There is this talk by Phil at Clojure/Conj: http://www.youtube.com/watch?v=K2NYwP90bNs

There are also some papers:

You can also read Purely Functional Data Structures by Chris Okasaki. This blog post talks about the book: http://okasaki.blogspot.com.br/2008/02/ten-years-of-purely-functional-data.html

Rodrigo Taboada
  • 2,727
  • 4
  • 24
  • 27
11

You should really read Clojure Programming, it covers this in great detail, including pictures. Briefly though, collections are depth first searches through trees. We can show your examples like this:

(def x #{1 2 3})

x
|
| \
|\ 3
1 \
   2

(def y (conj x 4))

 x  y
 | / \
 | \   4
 |\ 3
 1 \
    2

 (def z (difference y #{1}))

 x  y
 | / \
 | \  4
 |\ 3
 1/\
z-  2

Note that these are just indicative, I'm not saying that this is exactly the layout Clojure uses internally. It's the gist though.

SCdF
  • 57,260
  • 24
  • 77
  • 113
8

I like SCdF's drawings and explanations, but if you're looking for more depth you should read the excellent series of articles on Clojure's data structures at Higher-Order. It explains in detail how Clojure's maps work, and Clojure's sets are just a thin layer on top of its maps: #{:a :b} is implemented as a wrapping around {:a :a, :b :b}.

omiel
  • 1,573
  • 13
  • 16
amalloy
  • 89,153
  • 8
  • 140
  • 205
0

Here's a starting point: https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/PersistentHashSet.java

You can see it's implemented in terms of PersistentHashMap.

gtrak
  • 5,598
  • 4
  • 32
  • 41