Change HashDict implementation to use tries with compound nodes

The new implementation is basically a tree of tuples (tries) but
they allow compond nodes (a node with a key-value pair and a
sub-tree). This removes the need for node-expansion and also simplifies
the design structure to not require multiple stages nor buckets.

The end result is a faster HashDict implementation (about 10% faster
on access, 30% on updates), which is still small for small dicts
but about 30% bigger for large dicts (in terms of memory) and with
a much simpler implementation.

Author: José Valim

lib/elixir/lib/dict.ex

@@ -42,30 +42,30 @@ defmodule Dict do
 
   @type key :: any
   @type value :: any
-  @type keys :: [ key ]
   @type t :: tuple | list
 
   defcallback new :: t
   defcallback new(Keyword.t) :: t
+  defcallback new(Keyword.t, (any -> { key, value })) :: t
   defcallback delete(t, key) :: t
-  defcallback drop(t, keys) :: t
+  defcallback drop(t, [key]) :: t
   defcallback empty(t) :: t
   defcallback equal?(t, t) :: boolean
   defcallback get(t, key) :: value
   defcallback get(t, key, value) :: value
   defcallback fetch(t, key) :: { :ok, value } | :error
   defcallback fetch!(t, key) :: value | no_return
   defcallback has_key?(t, key) :: boolean
-  defcallback keys(t) :: list(key)
+  defcallback keys(t) :: [key]
   defcallback merge(t, t) :: t
   defcallback merge(t, t, (key, value, value -> value)) :: t
   defcallback pop(t, key) :: {value, t}
   defcallback pop(t, key, value) :: {value, t}
   defcallback put(t, key, value) :: t
   defcallback put_new(t, key, value) :: t
   defcallback size(t) :: non_neg_integer()
-  defcallback split(t, keys) :: {t, t}
-  defcallback take(t, keys) :: t
+  defcallback split(t, [key]) :: {t, t}
+  defcallback take(t, [key]) :: t
   defcallback to_list(t) :: list()
   defcallback update(t, key, value, (value -> value)) :: t
   defcallback update!(t, key, (value -> value)) :: t | no_return
@@ -381,7 +381,7 @@ defmodule Dict do
 
       iex> d = dict_impl.new([a: 1, b: 2, c: 3, d: 4])
       ...> { d1, d2 } = Dict.split(d, [:a, :c, :e])
-      ...> { Dict.to_list(d1), Dict.to_list(d2) }
+      ...> { Dict.to_list(d1) |> Enum.sort, Dict.to_list(d2) |> Enum.sort }
       { [a: 1, c: 3], [b: 2, d: 4] }
 
       iex> d = dict_impl.new([])
@@ -391,11 +391,11 @@ defmodule Dict do
 
       iex> d = dict_impl.new([a: 1, b: 2])
       ...> { d1, d2 } = Dict.split(d, [:a, :b, :c])
-      ...> { Dict.to_list(d1), Dict.to_list(d2) }
+      ...> { Dict.to_list(d1) |> Enum.sort, Dict.to_list(d2) }
       { [a: 1, b: 2], [] }
 
   """
-  @spec split(t, keys) :: {t, t}
+  @spec split(t, [key]) :: {t, t}
   def split(dict, keys) do
     target(dict).split(dict, keys)
   end
@@ -413,11 +413,11 @@ defmodule Dict do
 
       iex> d = dict_impl.new([a: 1, b: 2])
       ...> d = Dict.drop(d, [:c, :d])
-      ...> Dict.to_list(d)
+      ...> Dict.to_list(d) |> Enum.sort
       [a: 1, b: 2]
 
   """
-  @spec drop(t, keys) :: t
+  @spec drop(t, [key]) :: t
   def drop(dict, keys) do
     target(dict).drop(dict, keys)
   end
@@ -440,7 +440,7 @@ defmodule Dict do
       []
 
   """
-  @spec take(t, keys) :: t
+  @spec take(t, [key]) :: t
   def take(dict, keys) do
     target(dict).take(dict, keys)
   end

lib/elixir/lib/enum.ex

@@ -145,7 +145,7 @@ defmodule Enum do
   enumeration. For dicts, the argument is always a `{ key, value }` tuple:
 
       iex> dict = HashDict.new [a: 1, b: 2]
-      iex> Enum.map(dict, fn { k, v } -> { k, v * 2 } end)
+      iex> Enum.map(dict, fn { k, v } -> { k, v * 2 } end) |> Enum.sort
       [a: 2, b: 4]
 
   Note that the functions in the `Enum` module are eager: they always start