Remove treatment of heaps with nil elements as empty

Author: zkayser

lib/chapter_2/unbalanced_set.ex

@@ -15,6 +15,7 @@ defmodule UnbalancedSet do
   Creates an UnbalancedSet from a list
   """
   def from_list([]), do: %__MODULE__{}
+
   def from_list(list) do
     list
     |> Enum.reduce(%__MODULE__{}, fn x, acc ->
@@ -68,6 +69,7 @@ defmodule UnbalancedSet do
   def insert(el, %__MODULE__{set: set}), do: %__MODULE__{set: insert_(el, set)}
 
   defp insert_(el, :empty), do: {:empty, el, :empty}
+
   defp insert_(el, {left, root, right} = tree) do
     cond do
       Ordered.lt(el, root) -> {insert_(el, left), root, right}
@@ -123,7 +125,9 @@ defmodule UnbalancedSet do
   d + 1 comparisons
   """
   @spec optimized_insert(Chapter2.el(), t()) :: t()
-  def optimized_insert(el, %__MODULE__{set: tree}), do: %__MODULE__{set: optimized_insert_(el, nil, tree)}
+  def optimized_insert(el, %__MODULE__{set: tree}),
+    do: %__MODULE__{set: optimized_insert_(el, nil, tree)}
+
   defp optimized_insert_(el, el, :empty), do: raise(ExistingElementException, el)
   defp optimized_insert_(el, _prev, :empty), do: {:empty, el, :empty}
 
@@ -141,11 +145,13 @@ defimpl Enumerable, for: UnbalancedSet do
   def reduce(_set, {:halt, acc}, _fun), do: {:halted, acc}
   def reduce(set, {:suspend, acc}, fun), do: {:suspended, acc, &reduce(set, &1, fun)}
   def reduce(%UnbalancedSet{set: :empty}, {:cont, acc}, _fun), do: {:done, acc}
+
   def reduce(%UnbalancedSet{set: set}, {:cont, acc}, fun) do
-    {:done,  reduce_(set, acc, fun)}
+    {:done, reduce_(set, acc, fun)}
   end
 
   defp reduce_(:empty, acc, _fun), do: acc
+
   defp reduce_({left, root, right}, acc, fun) do
     with {:cont, intermediate} <- fun.(acc, root) do
       {:cont, sum} = fun.(reduce_(left, acc, fun), reduce_(right, acc, fun))

lib/chapter_3/leftist_heap.ex

@@ -1,17 +1,27 @@
 defmodule LeftistHeap do
+  @moduledoc """
+  A Leftist Heap is a heap-ordered binary tree that satisfies the leftist property --
+  the rank of any left child is at least as large as the rank of its right sibling.
+
+  The rank of node is defined to be the length of its right spine (i.e., the rightmost
+  path from the node in question to an empty or leaf node).
+
+  This definition means that the right spine of any node is always the shortest path
+  to an empty node.
+  """
 
   defstruct right: :empty,
             left: :empty,
             element: nil,
             rank: 1
 
-  @type t(a) :: %LeftistHeap{right: t(a), left: t(a), element: any(), rank: non_neg_integer()} | :empty
+  @type t(a) ::
+          %LeftistHeap{right: t(a), left: t(a), element: any(), rank: non_neg_integer()} | :empty
 
   @spec empty() :: t(any())
-  def empty(), do: %LeftistHeap{}
+  def empty(), do: :empty
 
   @spec is_empty?(t(any())) :: boolean()
-  def is_empty?(%LeftistHeap{element: nil}), do: true
   def is_empty?(:empty), do: true
   def is_empty?(%LeftistHeap{}), do: false
 
@@ -20,18 +30,20 @@ defmodule LeftistHeap do
 
   @spec rank(t(any())) :: non_neg_integer()
   def rank(:empty), do: 0
-  def rank(%LeftistHeap{element: nil}), do: 0
   def rank(%LeftistHeap{rank: rank}), do: rank
 
   @spec merge(t(any()), t(any())) :: t(any())
-  def merge(%LeftistHeap{element: nil}, %LeftistHeap{} = leftist_heap), do: leftist_heap
-  def merge(%LeftistHeap{} = leftist_heap, %LeftistHeap{element: nil}), do: leftist_heap
   def merge(:empty, leftist_heap), do: leftist_heap
   def merge(leftist_heap, :empty), do: leftist_heap
-  def merge(%LeftistHeap{element: val_1} = h1, %LeftistHeap{element: val_2} = h2) when val_1 > val_2, do: merge(h2, h1)
+
+  def merge(%LeftistHeap{element: val_1} = h1, %LeftistHeap{element: val_2} = h2)
+      when val_1 > val_2,
+      do: merge(h2, h1)
+
   def merge(%LeftistHeap{right: right, left: left} = h1, %LeftistHeap{} = h2) do
     merged = merge(right, h2)
     {rank_left, rank_right} = {rank(left), rank(merged)}
+
     case rank_left >= rank_right do
       true -> %LeftistHeap{h1 | right: merged, rank: rank_right + 1}
       false -> %LeftistHeap{h1 | left: merged, right: left, rank: rank_left + 1}
@@ -46,22 +58,18 @@ defmodule LeftistHeap do
   end
 
   @spec get_min(t(any())) :: {:ok, any()} | {:error, :empty_heap}
-  def get_min(%LeftistHeap{element: nil}), do: {:error, :empty_heap}
   def get_min(:empty), do: {:error, :empty_heap}
   def get_min(%LeftistHeap{element: el}), do: {:ok, el}
 
   @spec get_min!(t(any)) :: any | none()
-  def get_min!(%LeftistHeap{element: nil}), do: raise EmptyHeapError
-  def get_min!(:empty), do: raise EmptyHeapError
+  def get_min!(:empty), do: raise(EmptyHeapError)
   def get_min!(%LeftistHeap{element: min}), do: min
 
   @spec delete_min(t(any())) :: {:ok, t(any())} | {:error, :empty_heap}
-  def delete_min(%LeftistHeap{element: nil}), do: {:error, :empty_heap}
   def delete_min(:empty), do: {:error, :empty_heap}
   def delete_min(%LeftistHeap{left: left, right: right}), do: {:ok, merge(left, right)}
 
   @spec delete_min!(t(any)) :: any | none()
-  def delete_min!(%LeftistHeap{element: nil}), do: raise EmptyHeapError
-  def delete_min!(:empty), do: raise EmptyHeapError
+  def delete_min!(:empty), do: raise(EmptyHeapError)
   def delete_min!(%LeftistHeap{left: left, right: right}), do: merge(left, right)
 end

test/chapter_2/unbalanced_set_test.exs

@@ -24,11 +24,13 @@ defmodule UnbalancedSetTest do
 
   describe "insert/2" do
     test "places the element to be inserted in the left sub tree if smaller than the root node" do
-      assert %UnbalancedSet{set: {{:empty, 1, :empty}, 4, :empty}} = UnbalancedSet.insert(1, %UnbalancedSet{set: @left_sub_tree})
+      assert %UnbalancedSet{set: {{:empty, 1, :empty}, 4, :empty}} =
+               UnbalancedSet.insert(1, %UnbalancedSet{set: @left_sub_tree})
     end
 
     test "places the element to be inserted in the right sub tree if larger than the root node" do
-      assert %UnbalancedSet{set: {:empty, 4, {:empty, 5, :empty}}} = UnbalancedSet.insert(5, %UnbalancedSet{set: @left_sub_tree})
+      assert %UnbalancedSet{set: {:empty, 4, {:empty, 5, :empty}}} =
+               UnbalancedSet.insert(5, %UnbalancedSet{set: @left_sub_tree})
     end
   end
 
@@ -53,17 +55,20 @@ defmodule UnbalancedSetTest do
     end
 
     test "return {:ok, {:empty, element, :empty} when inserting into an empty tree" do
-      assert {:ok, %UnbalancedSet{set: {:empty, 2, :empty}}} = UnbalancedSet.efficient_insert(2, %UnbalancedSet{set: :empty})
+      assert {:ok, %UnbalancedSet{set: {:empty, 2, :empty}}} =
+               UnbalancedSet.efficient_insert(2, %UnbalancedSet{set: :empty})
     end
   end
 
   describe "optimized_insert/2" do
     test "places the element to be inserted in the left sub tree if smaller than the root node" do
-      assert %UnbalancedSet{set: {{:empty, 1, :empty}, 4, :empty}} = UnbalancedSet.optimized_insert(1, %UnbalancedSet{set: @left_sub_tree})
+      assert %UnbalancedSet{set: {{:empty, 1, :empty}, 4, :empty}} =
+               UnbalancedSet.optimized_insert(1, %UnbalancedSet{set: @left_sub_tree})
     end
 
     test "places the element to be inserted in the right sub tree if larger than the root node" do
-      assert %UnbalancedSet{set: {:empty, 4, {:empty, 5, :empty}}} = UnbalancedSet.optimized_insert(5, %UnbalancedSet{set: @left_sub_tree})
+      assert %UnbalancedSet{set: {:empty, 4, {:empty, 5, :empty}}} =
+               UnbalancedSet.optimized_insert(5, %UnbalancedSet{set: @left_sub_tree})
     end
 
     test "raises ExistingElementException when inserting an existing element" do
@@ -83,25 +88,27 @@ defmodule UnbalancedSetTest do
     test "creates an unbalanced set from an Elixir list" do
       assert UnbalancedSet.from_list([]) == %UnbalancedSet{set: :empty}
       assert UnbalancedSet.from_list([1]) == %UnbalancedSet{set: {:empty, 1, :empty}}
+
       assert UnbalancedSet.from_list([5, 4, 6, 7, 8]) ==
-        %UnbalancedSet{set: @a_tree}
+               %UnbalancedSet{set: @a_tree}
     end
   end
 
   describe "Enumerable.UnbalancedSet" do
     test "allows you to call functions from the Enum module" do
       assert 30 ==
-        [7, 5, 6, 4, 8]
-        |> UnbalancedSet.from_list()
-        |> Enum.reduce(0, &Kernel.+/2)
+               [7, 5, 6, 4, 8]
+               |> UnbalancedSet.from_list()
+               |> Enum.reduce(0, &Kernel.+/2)
     end
 
     test "reduces over larger sets" do
       range = 1..200
+
       assert Enum.reduce(range, 0, &Kernel.+/2) ==
-        range
-        |> UnbalancedSet.from_list()
-        |> Enum.reduce(0, &Kernel.+/2)
+               range
+               |> UnbalancedSet.from_list()
+               |> Enum.reduce(0, &Kernel.+/2)
     end
   end
 end

test/chapter_3/leftist_heap_test.exs

@@ -3,15 +3,11 @@ defmodule LeftistHeapTest do
 
   describe "empty/0" do
     test "creates an empty leftist heap" do
-      assert %LeftistHeap{} == LeftistHeap.empty()
+      assert :empty == LeftistHeap.empty()
     end
   end
 
   describe "is_empty?/1" do
-    test "returns true for a leftist heap with no value" do
-      assert LeftistHeap.is_empty?(%LeftistHeap{})
-    end
-
     test "returns true for :empty" do
       assert LeftistHeap.is_empty?(:empty)
     end
@@ -31,12 +27,24 @@ defmodule LeftistHeapTest do
     test "returns non-empty leftist heap if one is empty" do
       assert LeftistHeap.merge(%LeftistHeap{element: 2}, :empty) == %LeftistHeap{element: 2}
       assert LeftistHeap.merge(:empty, %LeftistHeap{element: 1}) == %LeftistHeap{element: 1}
-      assert LeftistHeap.merge(LeftistHeap.empty(), %LeftistHeap{element: 3}) == %LeftistHeap{element: 3}
-      assert LeftistHeap.merge(%LeftistHeap{element: 4}, LeftistHeap.empty()) == %LeftistHeap{element: 4}
+
+      assert LeftistHeap.merge(LeftistHeap.empty(), %LeftistHeap{element: 3}) == %LeftistHeap{
+               element: 3
+             }
+
+      assert LeftistHeap.merge(%LeftistHeap{element: 4}, LeftistHeap.empty()) == %LeftistHeap{
+               element: 4
+             }
     end
 
     test "handles two singletons" do
-      expected = %LeftistHeap{element: 2, left: %LeftistHeap{element: 10, rank: 1}, rank: 1, right: :empty}
+      expected = %LeftistHeap{
+        element: 2,
+        left: %LeftistHeap{element: 10, rank: 1},
+        rank: 1,
+        right: :empty
+      }
+
       heap_1 = LeftistHeap.singleton(2)
       heap_2 = LeftistHeap.singleton(10)
       result = LeftistHeap.merge(heap_1, heap_2)
@@ -45,15 +53,25 @@ defmodule LeftistHeapTest do
     end
 
     test "handles leftist_heaps with more than one root" do
-      expected =
-        %LeftistHeap{
-          element: 2,
-          rank: 2,
-          right: LeftistHeap.singleton(10),
-          left: %LeftistHeap{element: 3, left: LeftistHeap.singleton(6), right: LeftistHeap.singleton(9), rank: 2}
+      expected = %LeftistHeap{
+        element: 2,
+        rank: 2,
+        right: LeftistHeap.singleton(10),
+        left: %LeftistHeap{
+          element: 3,
+          left: LeftistHeap.singleton(6),
+          right: LeftistHeap.singleton(9),
+          rank: 2
         }
+      }
+
+      left_heap = %LeftistHeap{
+        element: 2,
+        left: LeftistHeap.singleton(10),
+        right: LeftistHeap.singleton(9),
+        rank: 2
+      }
 
-      left_heap = %LeftistHeap{element: 2, left: LeftistHeap.singleton(10), right: LeftistHeap.singleton(9), rank: 2}
       right_heap = %LeftistHeap{element: 3, left: LeftistHeap.singleton(6)}
 
       assert LeftistHeap.merge(left_heap, right_heap) == expected
@@ -65,16 +83,15 @@ defmodule LeftistHeapTest do
       assert {:ok, 1} = LeftistHeap.get_min(LeftistHeap.singleton(1))
 
       assert {:ok, 5} =
-        LeftistHeap.singleton(5)
-        |> LeftistHeap.merge(LeftistHeap.singleton(10))
-        |> LeftistHeap.merge(LeftistHeap.singleton(20))
-        |> LeftistHeap.merge(LeftistHeap.singleton(15))
-        |> LeftistHeap.get_min()
+               LeftistHeap.singleton(5)
+               |> LeftistHeap.merge(LeftistHeap.singleton(10))
+               |> LeftistHeap.merge(LeftistHeap.singleton(20))
+               |> LeftistHeap.merge(LeftistHeap.singleton(15))
+               |> LeftistHeap.get_min()
     end
 
     test "returns an error tuple when the heap is empty" do
       assert {:error, :empty_heap} = LeftistHeap.get_min(:empty)
-      assert {:error, :empty_heap} = LeftistHeap.get_min(%LeftistHeap{element: nil})
     end
   end
 
@@ -83,10 +100,6 @@ defmodule LeftistHeapTest do
       assert_raise EmptyHeapError, fn ->
         LeftistHeap.get_min!(:empty)
       end
-
-      assert_raise EmptyHeapError, fn ->
-        LeftistHeap.get_min!(%LeftistHeap{})
-      end
     end
   end
 
@@ -107,7 +120,6 @@ defmodule LeftistHeapTest do
     end
 
     test "returns an error tuple when the heap is empty" do
-      assert {:error, :empty_heap} = LeftistHeap.delete_min(%LeftistHeap{})
       assert {:error, :empty_heap} = LeftistHeap.delete_min(:empty)
     end
   end
@@ -129,10 +141,6 @@ defmodule LeftistHeapTest do
     end
 
     test "raises EmptyHeapError when the heap is empty" do
-      assert_raise EmptyHeapError, fn ->
-        LeftistHeap.delete_min!(%LeftistHeap{})
-      end
-
       assert_raise EmptyHeapError, fn ->
         LeftistHeap.delete_min!(:empty)
       end