Manage circular buffer using lists

This switches the implementation from using the general purpose `:queue`
module to enable optimizations for the circular buffer use case. At a
high level, an Okasaki queue is still used. Since insertion to a
circular buffer always requires a removal once the buffer reaches its
max size, this change makes it possible to do this in one step.
Previously, this was a call to `:queue` to remove one element and then a
call to insert the new one.

With the general caveat on microbenchmarks, the new implementation is a
small performance improvement and reduces the garbage created when
managing the structure. The following results are from inserting items
repeatedly into a CircularBuffer. "cb2" is the new implementation and
"cb" is the `:queue` implementation in the results below.

```
Name                 ips        average  deviation         median         99th %
cb2 insert        236.18        4.23 ms     ±3.01%        4.31 ms        4.39 ms
cb insert         140.35        7.13 ms     ±3.27%        7.14 ms        7.66 ms

Comparison:
cb2 insert        236.18
cb insert         140.35 - 1.68x slower +2.89 ms

Memory usage statistics:

Name          Memory usage
cb2 insert         9.12 MB
cb insert         16.24 MB - 1.78x memory usage +7.12 MB
```

Author: fhunleth

lib/circular_buffer.ex

@@ -1,76 +1,70 @@
 defmodule CircularBuffer do
   @moduledoc """
-  Circular Buffer built around erlang's queue module.
+  Circular Buffer
 
   When creating a circular buffer you must specify the max size:
 
   ```
   cb = CircularBuffer.new(10)
   ```
+
+  CircularBuffers are implemented as Okasaki queues like Erlang's `:queue`
+  module, but with additional optimizations thanks to the reduced set
+  of operations.
   """
 
-  defstruct [:q, :max_size, :count]
+  defstruct [:a, :b, :max_size, :count]
 
   alias __MODULE__, as: CB
 
   @doc """
   Creates a new circular buffer with a given size.
   """
   def new(size) when is_integer(size) and size > 0 do
-    %CB{q: :queue.new(), max_size: size, count: 0}
+    %CB{a: [], b: [], max_size: size, count: 0}
   end
 
   @doc """
   Inserts a new item into the next location of the circular buffer
   """
-  def insert(%CB{}=cb, item) do
-    if cb.count < cb.max_size do
-      %{cb | q: :queue.cons(item, cb.q), count: cb.count + 1}
-    else
-      new_q =
-        cb.q
-        |> :queue.drop_r
-        |> (fn q -> :queue.cons(item, q) end).()
-
-      %CB{cb | q: new_q}
+  def insert(%CB{b: b} = cb, item) when b != [] do
+    %CB{cb | a: [item | cb.a], b: tl(b)}
+  end
+
+  def insert(%CB{count: count, max_size: max_size} = cb, item) when count < max_size do
+    %CB{cb | a: [item | cb.a], count: cb.count + 1}
     end
+
+  def insert(%CB{b: []} = cb, item) do
+    new_b = cb.a |> Enum.reverse() |> tl()
+    %CB{cb | a: [item], b: new_b}
   end
 
   @doc """
   Converts a circular buffer to a list. The list is ordered from oldest to newest
   elements based on their insertion order.
   """
-  def to_list(%CB{}=cb) do
-    cb.q
-    |> :queue.reverse
-    |> :queue.to_list
+  def to_list(%CB{} = cb) do
+    cb.b ++ Enum.reverse(cb.a)
   end
 
   @doc """
   Returns the newest element in the buffer
   """
-  def newest(%CB{}=cb) do
-    case :queue.peek(cb.q) do
-      {_, val} -> val
-      :empty -> nil
-    end
-  end
+  def newest(%CB{a: [newest | _rest]}), do: newest
+  def newest(%CB{b: []}), do: nil
 
   @doc """
   Returns the oldest element in the buffer
   """
-  def oldest(%CB{}=cb) do
-    case :queue.peek_r(cb.q) do
-      {_, val} -> val
-      :empty -> nil
-    end
-  end
+  def oldest(%CB{b: [oldest | _rest]}), do: oldest
+  def oldest(%CB{a: a}), do: List.last(a)
 
   @doc """
   Checks the buffer to see if its empty
   """
-  def empty?(%CB{}=cb) do
-    :queue.is_empty(cb.q)
+  def empty?(%CB{} = cb) do
+    cb.count == 0
   end
 
   defimpl Enumerable do
@@ -79,7 +73,7 @@ defmodule CircularBuffer do
     end
 
     def member?(cb, element) do
-      {:ok, :queue.member(element, cb.q)}
+      {:ok, Enum.member?(cb.a, element) or Enum.member?(cb.b, element)}
     end
 
     def reduce(cb, acc, fun) do

test/circular_buffer_test.exs

@@ -19,10 +19,14 @@ defmodule CircularBufferTest do
     end
   end
 
+  def slow_cb_count(cb) do
+    Enum.count(cb.a) + Enum.count(cb.b)
+  end
+
   property "the count matches the number of elements in the buffer" do
     forall {size, is} <- {pos_integer(), list(integer())} do
       buffer = Enum.reduce(is, CB.new(size), fn i, cb -> CB.insert(cb, i) end)
-      :queue.len(buffer.q) == buffer.count
+      slow_cb_count(buffer) == buffer.count
     end
   end
 
@@ -60,7 +64,7 @@ defmodule CircularBufferTest do
   property "the number of elements never exceeds the size of the buffer" do
     forall {size, is} <- size_and_list() do
       buffer = Enum.reduce(is, CB.new(size), fn i, cb -> CB.insert(cb, i) end)
-      :queue.len(buffer.q) <= size
+      slow_cb_count(buffer) <= size
     end
   end
 
@@ -74,10 +78,9 @@ defmodule CircularBufferTest do
 
       slice =
         iis
-        |> Enum.reverse
-        |> Enum.take(size)
+        |> Enum.take(-size)
 
-      :queue.to_list(buffer.q) == slice
+      CB.to_list(buffer) == slice
     end
   end