Use just the process dictionary for keeping history

Author: alco

lib/iex/lib/iex/history.ex

@@ -1,99 +1,71 @@
 defmodule IEx.History do
+  @moduledoc false
 
   def init do
-    Process.put :iex_history, :queue.new
+    Process.put(:iex_history_start_counter, 1)
+    Process.put(:iex_history_counter, 1)
   end
 
   ### append ###
 
-  def append(entry) do
-    history = Process.get(:iex_history)
-    len = :queue.len(history)
-    limit = IEx.Options.get(:history_size)
-
-    new_history =
-      :queue.in(entry, history)
-      |> limit_history(len + 1, limit)
-    Process.put(:iex_history, new_history)
-  end
+  def append(entry, counter) do
+    Process.put({:iex_history, counter}, entry)
+    Process.put(:iex_history_counter, counter+1)
 
-  defp limit_history(_, _, 0) do
-    :queue.new
+    limit = IEx.Options.get(:history_size)
+    start_counter = Process.get(:iex_history_start_counter)
+    should_collect = limit_history(start_counter, counter, limit)
+    if should_collect do
+      IO.puts "...collecting garbage"
+      :erlang.garbage_collect
+    end
   end
 
-  defp limit_history(queue, _, limit) when limit < 0 do
-    queue
+  defp limit_history(_, _, limit) when limit < 0 do
+    false
   end
 
-  defp limit_history(queue, len, limit) when len > limit do
-    # FIXME: check if the result we're removing had any binaries in it and
-    # garbage collect them
-    limit_history(:queue.drop(queue), len-1, limit)
+  defp limit_history(counter, max_counter, limit) when max_counter - counter < limit do
+    Process.put(:iex_history_start_counter, counter)
+    true
   end
 
-  defp limit_history(queue, _, _) do
-    queue
+  defp limit_history(counter, max_counter, limit) do
+    Process.delete({:iex_history, counter})
+    limit_history(counter+1, max_counter, limit)
   end
 
   ### each ###
 
   def each(fun) do
-    history = Process.get(:iex_history)
-    each(history, fun)
+    each(Process.get(:iex_history_start_counter),
+         Process.get(:iex_history_counter),
+         fun)
   end
 
-  defp each(queue, fun) do
-    case :queue.out(queue) do
-      { { :value, val }, tail } ->
-        fun.(val)
-        each(tail, fun)
+  defp each(counter, max_counter, fun) when counter < max_counter do
+    entry = Process.get({:iex_history, counter})
+    fun.(entry)
+    each(counter+1, max_counter, fun)
+  end
 
-      { :empty, _ } -> :ok
-    end
+  defp each(_, _, _) do
+    :ok
   end
 
   ### nth ###
 
   def nth(n) do
-    history = Process.get(:iex_history)
-    len = :queue.len(history)
-    case n do
-      n when n > 0 ->
-        queue_nth(history, n - 1, len)
+    entry = case n do
+      n when n >= 0 ->
+        Process.get({:iex_history, n})
       n when n < 0 ->
-        queue_nth_r(history, -n - 1, len)
-      0 ->
-        raise ArgumentError[]
+        counter = Process.get(:iex_history_counter)
+        Process.get({:iex_history, counter + n})
     end
-  end
-
-  defp queue_nth(_, _, 0) do
-    raise_bounds
-  end
-
-  defp queue_nth(queue, 0, _) do
-    { :value, value } = :queue.peek(queue)
-    value
-  end
-
-  defp queue_nth(queue, n, len) when n > 0 do
-    queue_nth(:queue.drop(queue), n-1, len-1)
-  end
-
-  defp queue_nth_r(_, _, 0) do
-    raise_bounds
-  end
-
-  defp queue_nth_r(queue, 0, _) do
-    { :value, value } = :queue.peek_r(queue)
-    value
-  end
-
-  defp queue_nth_r(queue, n, len) when n > 0 do
-    queue_nth_r(:queue.drop_r(queue), n-1, len-1)
-  end
-
-  defp raise_bounds do
-    raise "Out of bounds"
+    if nil?(entry) do
+      raise "Out of bounds"
+    end
+    entry
   end
 end

lib/iex/lib/iex/server.ex

@@ -84,7 +84,7 @@ defmodule IEx.Server do
 
         config = config.result(result)
         update_history(config.cache(code).scope(nil))
-        config.update_counter(&1+1).cache('').binding(new_binding).scope(scope)
+        config.update_counter(&1+1).cache('').binding(new_binding).scope(scope).result(nil)
 
       { :error, { line_no, error, token } } ->
         if token == [] do
@@ -136,7 +136,7 @@ defmodule IEx.Server do
   end
 
   defp update_history(config) do
-    IEx.History.append(config)
+    IEx.History.append(config, config.counter)
   end
 
   defp io_get(config) do