diff --git a/src/main/clojure/clojure/core/logic.clj b/src/main/clojure/clojure/core/logic.clj
index 6a2b6d8..5089b1f 100644
--- a/src/main/clojure/clojure/core/logic.clj
+++ b/src/main/clojure/clojure/core/logic.clj
@@ -3738,3 +3738,11 @@
   ([_ [y . ys] [y . zs]]
      (!= y x)
      (rembero x ys zs)))
+
+
+
+
+
+
+
+(load "logic/partial_map")
diff --git a/src/main/clojure/clojure/core/logic/partial_map.clj b/src/main/clojure/clojure/core/logic/partial_map.clj
new file mode 100644
index 0000000..7f57755
--- /dev/null
+++ b/src/main/clojure/clojure/core/logic/partial_map.clj
@@ -0,0 +1,72 @@
+;;This file defines a PMap (partial map) record that unifies with maps without having all of that map's keys.
+(in-ns 'clojure.core.logic)
+
+(defprotocol IUnifyWithPMap
+  (unify-with-pmap [pmap u s]))
+
+(defrecord PMap []
+  IUnifyWithMap
+  (unify-with-map [v u s]
+    (loop [ks (keys v) s s]
+      (if (seq ks)
+        (let [kf (first ks)
+              vf (get v kf)
+              uf (get u kf ::not-found)]
+          (if (= uf ::not-found)
+            ;;If one of PMap's values is !_, it will only unify with a map that does NOT have that key.
+            (if (= vf '!_)
+              (recur (next ks) s)
+              nil)
+            (if-let [s (unify s vf uf)]
+              (recur (next ks) s)
+              nil)))
+        s)))
+
+  IUnifyWithPMap
+  (unify-with-pmap [v u s]
+    (unify-with-map v u s))
+
+  IUnifyTerms
+  (unify-terms [u v s]
+    (unify-with-pmap v u s))
+
+  IUnifyWithLVar
+  (unify-with-lvar [v u s]
+    (ext-no-check s u v)))
+
+(extend-protocol IUnifyWithPMap
+  nil
+  (unify-with-pmap [v u s] nil)
+
+  Object
+  (unify-with-pmap [v u s] nil)
+
+  clojure.core.logic.LVar
+  (unify-with-pmap [v u s]
+    (ext s v u))
+
+  clojure.lang.IPersistentMap
+  (unify-with-pmap [v u s]
+    (unify-with-map u v s)))
+
+(defn partial-map
+  "Given map m, returns partial map that unifies with maps even if it doesn't share all of the keys of that map.
+   Only the keys of the partial map will be unified:
+
+   (run* [q]
+         (fresh [pm x]
+                (== pm (partial-map {:a x}))
+                (== pm {:a 1 :b 2})
+                (== pm q)))
+   ;;=> ({:a 1})
+
+   The symbol !_ can be used to prevent unification with maps that have a key at that position.
+   E.g., (partial-map {:a !_}) will not unify with {:a 1 :b 2} since :a is defined in the latter."
+  [m]
+  (map->PMap m))
+
+(run* [q]
+      (fresh [pm x]
+             (== pm (partial-map {:a x}))
+             (== pm {:a 1 :b 2})
+             (== pm q)))
diff --git a/src/test/clojure/clojure/core/logic/tests.clj b/src/test/clojure/clojure/core/logic/tests.clj
index 7b06240..d40d09a 100644
--- a/src/test/clojure/clojure/core/logic/tests.clj
+++ b/src/test/clojure/clojure/core/logic/tests.clj
@@ -1196,6 +1196,21 @@
                (== z [x y])
                (== [x] [3])))))
 
+(deftest test-49-partial-map-unification
+  (is (= '[{:a 1}]
+         (run* [q]
+               (fresh [pm x]
+                      (== pm (partial-map {:a x}))
+                      (== pm {:a 1 :b 2})
+                      (== pm q)))))
+
+  (is (= '[]
+         (run* [q]
+               (fresh [pm x]
+                      (== pm (partial-map {:a x :b '!_}))
+                      (== pm {:a 1 :b 2})
+                      (== pm q))))))
+
 ;; =============================================================================
 ;; cKanren