 
   defp set_delete(ordered(bucket: bucket, size: size) = set, member) do
     case bucket_delete(bucket, member) do
-      { _, value, 0 } ->
-        { set, value, 0 }
-      { new_bucket, value, -1 } ->
-        { ordered(set, size: size - 1, bucket: new_bucket), value, -1 }
+      { _, 0 } ->
+        { set, 0 }
+      { new_bucket, -1 } ->
+        { ordered(set, size: size - 1, bucket: new_bucket), -1 }
     end
   end
 
   defp set_delete(trie(root: root, size: size, depth: depth) = set, member) do
     pos = bucket_hash(member)
     case node_delete(root, depth, pos, member) do
-      { _, value, 0 } ->
-        { set, value, 0 }
-      { root, _, -1 } ->
+      { _, 0 } ->
+        { set, 0 }
+      { root, -1 } ->
         { if depth > 0 and trie(set, :contract_on) == size do
           root = node_contract(root, depth)
           trie(set,

            expand_on: div(trie(set, :expand_on), @node_size))
        else
          trie(set, size: size - 1, root: root)
        end, member, -1 }
    end
  end


  defp node_delete(node, 0, hash, member) do
    pos = bucket_index(hash)
    case bucket_delete(elem(node, pos), member) do
      { _, 0 } -> { node, 0 }
      { new, -1 } -> { set_elem(node, pos, new), -1 }
    end
  end

  defp node_delete(node, depth, hash, member) do
    pos = bucket_index(hash)
    case node_delete(elem(node, pos), depth - 1, bucket_next(hash), member) do
      { _, 0 } -> { node, 0 }
      { new, -1 } -> { set_elem(node, pos, new), -1 }
    end
  end

