   def reduce(%HashSet{root: root}, acc, fun) do
     do_reduce(root, acc, fun, @node_size, fn
       {:suspend, acc} -> {:suspended, acc, &{:done, elem(&1, 1)}}
-      {:halt, acc}    -> {:halted, acc}
-      {:cont, acc}    -> {:done, acc}
+      {:halt, acc} -> {:halted, acc}
+      {:cont, acc} -> {:done, acc}
     end)
   end
 

  def delete(%HashSet{root: root, size: size} = set, term) do
    case do_delete(root, term, key_hash(term)) do
      {:ok, root} -> %HashSet{root: root, size: size - 1}
      :error      -> set
    end
  end



  defp do_delete(node, term, hash) do
    index = key_mask(hash)

    case elem(node, index) do
      [] ->
        :error

      [^term] ->
        {:ok, put_elem(node, index, [])}

      [_] ->
        :error

      [^term | n] ->
        {:ok, put_elem(node, index, do_compact_node(n))}

      [t | n] ->
        case do_delete(n, term, key_shift(hash)) do
          {:ok, @node_template} ->
            {:ok, put_elem(node, index, [t])}

          {:ok, n} ->
            {:ok, put_elem(node, index, [t | n])}

          :error ->
            :error
        end
    end
  end

  Enum.each(0..(@node_size - 1), fn index ->
    defp do_compact_node(node) when elem(node, unquote(index)) != [] do
      case elem(node, unquote(index)) do
        [t] ->
