Add sub/superset checking methods to Hash

spec/std/hash_spec.cr

@@ -99,6 +99,61 @@ describe "Hash" do
     end
   end
 
+  context "subset/superset operators" do
+    h1 = {"a" => 1, "b" => 2}
+    h2 = {"a" => 1, "b" => 2, "c" => 3}
+    h3 = {"c" => 3}
+    h4 = {} of Nil => Nil
+
+    describe "#proper_subset_of?" do
+      it do
+        h1.proper_subset_of?(h2).should be_true
+        h2.proper_subset_of?(h1).should be_false
+        h1.proper_subset_of?(h1).should be_false
+        h1.proper_subset_of?(h3).should be_false
+        h1.proper_subset_of?(h4).should be_false
+      end
+
+      it "handles edge case where both values are nil" do
+        {"a" => nil}.proper_subset_of?({"b" => nil, "c" => nil}).should be_false
+      end
+    end
+
+    describe "#subset_of?" do
+      it do
+        h1.subset_of?(h2).should be_true
+        h2.subset_of?(h1).should be_false
+        h1.subset_of?(h1).should be_true
+        h1.subset_of?(h3).should be_false
+        h1.subset_of?(h4).should be_false
+      end
+
+      it "handles edge case where both values are nil" do
+        {"a" => nil}.subset_of?({"b" => nil}).should be_false
+      end
+    end
+
+    describe "#proper_superset_of?" do
+      it do
+        h1.proper_superset_of?(h2).should be_false
+        h2.proper_superset_of?(h1).should be_true
+        h1.proper_superset_of?(h1).should be_false
+        h1.proper_superset_of?(h3).should be_false
+        h1.proper_superset_of?(h4).should be_true
+      end
+    end
+
+    describe "#superset_of?" do
+      it do
+        h1.superset_of?(h2).should be_false
+        h2.superset_of?(h1).should be_true
+        h1.superset_of?(h1).should be_true
+        h1.superset_of?(h3).should be_false
+        h1.superset_of?(h4).should be_true
+      end
+    end
+  end
+
   describe "[]" do
     it "gets" do
       a = {1 => 2}

src/hash.cr

@@ -1747,6 +1747,34 @@ class Hash(K, V)
     true
   end
 
+  # Returns `true` if `self` is a subset of *other*.
+  def proper_subset_of?(other : Hash)
+    return false if other.size <= size
+    all? do |key, value|
+      other_value = other.fetch(key) { return false }
+      other_value == value
+    end
+  end
+
+  # Returns `true` if `self` is a subset of *other* or equals to *other*.
+  def subset_of?(other : Hash)
+    return false if other.size < size
+    all? do |key, value|
+      other_value = other.fetch(key) { return false }
+      other_value == value
+    end
+  end
+
+  # Returns `true` if *other* is a subset of `self`.
+  def superset_of?(other : Hash)
+    other.subset_of?(self)
+  end
+
+  # Returns `true` if *other* is a subset of `self` or equals to `self`.
+  def proper_superset_of?(other : Hash)
+    other.proper_subset_of?(self)
+  end
+
   # See `Object#hash(hasher)`
   def hash(hasher)
     # The hash value must be the same regardless of the