CLJS-2013 - Add MapEntry type

New additions:
* A MapEntry type for use by PAM and PHM
* -contains-key? from IAssociative protocol was missing from
  PersistentVector, RedNode and BlackNode

Changes:
* -nth on RedNode and BlackNode now throws on out of bounds
* -invoke on RedNode and BlackNode now throws on out of bounds
* -find on RedNode and BlackNode now returns correct value

Author: thomasmulvaney

src/main/cljs/cljs/core.cljs

@@ -5161,6 +5161,10 @@ reduces them without incurring seq initialization"
     (if (number? k)
       (-assoc-n coll k v)
       (throw (js/Error. "Vector's key for assoc must be a number."))))
+  (-contains-key? [coll k]
+    (if (integer? k)
+      (and (<= 0 k) (< k cnt))
+      false))
 
   IFind
   (-find [coll k]
@@ -6134,6 +6138,98 @@ reduces them without incurring seq initialization"
 
 (declare TransientArrayMap)
 
+(deftype MapEntry [key val ^:mutable __hash]
+  Object
+  (indexOf [coll x]
+    (-indexOf coll x 0))
+  (indexOf [coll x start]
+    (-indexOf coll x start))
+  (lastIndexOf [coll x]
+    (-lastIndexOf coll x (count coll)))
+  (lastIndexOf [coll x start]
+    (-lastIndexOf coll x start))
+
+  IMapEntry
+  (-key [node] key)
+  (-val [node] val)
+
+  IHash
+  (-hash [coll] (caching-hash coll hash-ordered-coll __hash))
+
+  IEquiv
+  (-equiv [coll other] (equiv-sequential coll other))
+
+  IMeta
+  (-meta [node] nil)
+
+  IWithMeta
+  (-with-meta [node meta]
+    (with-meta [key val] meta))
+
+  IStack
+  (-peek [node] val)
+
+  (-pop [node] [key])
+
+  ICollection
+  (-conj [node o] [key val o])
+
+  IEmptyableCollection
+  (-empty [node] [])
+
+  ISequential
+  ISeqable
+  (-seq [node] (list key val))
+
+  ICounted
+  (-count [node] 2)
+
+  IIndexed
+  (-nth [node n]
+    (cond (== n 0) key
+          (== n 1) val
+          :else    (throw (js/Error. "Index out of bounds"))))
+
+  (-nth [node n not-found]
+    (cond (== n 0) key
+          (== n 1) val
+          :else    not-found))
+
+  ILookup
+  (-lookup [node k] (-nth node k nil))
+  (-lookup [node k not-found] (-nth node k not-found))
+
+  IAssociative
+  (-assoc [node k v]
+    (assoc [key val] k v))
+  (-contains-key? [node k]
+    (or (== k 0) (== k 1)))
+
+  IFind
+  (-find [node k]
+    (cond
+      (== k 0) [0 key]
+      (== k 1) [1 val]
+      :else nil))
+
+  IVector
+  (-assoc-n [node n v]
+    (-assoc-n [key val] n v))
+
+  IReduce
+  (-reduce [node f]
+    (ci-reduce node f))
+
+  (-reduce [node f start]
+    (ci-reduce node f start))
+
+  IFn
+  (-invoke [node k]
+    (-nth node k))
+
+  (-invoke [node k not-found]
+    (-nth node k not-found)))
+
 (deftype PersistentArrayMapSeq [arr i _meta]
   Object
   (toString [coll]
@@ -7754,7 +7850,7 @@ reduces them without incurring seq initialization"
   (-nth [node n]
     (cond (== n 0) key
           (== n 1) val
-          :else    nil))
+          :else    (throw (js/Error. "Index out of bounds"))))
 
   (-nth [node n not-found]
     (cond (== n 0) key
@@ -7768,10 +7864,15 @@ reduces them without incurring seq initialization"
   IAssociative
   (-assoc [node k v]
     (assoc [key val] k v))
+  (-contains-key? [node k]
+    (or (== k 0) (== k 1)))
 
   IFind
   (-find [node k]
-    [key val])
+    (cond
+      (== k 0) [0 key]
+      (== k 1) [1 val]
+      :else nil))
 
   IVector
   (-assoc-n [node n v]
@@ -7786,10 +7887,10 @@ reduces them without incurring seq initialization"
 
   IFn
   (-invoke [node k]
-    (-lookup node k))
+    (-nth node k))
 
   (-invoke [node k not-found]
-    (-lookup node k not-found)))
+    (-nth node k not-found)))
 
 (es6-iterable BlackNode)
 
@@ -7910,7 +8011,7 @@ reduces them without incurring seq initialization"
   (-nth [node n]
     (cond (== n 0) key
           (== n 1) val
-          :else    nil))
+          :else    (throw (js/Error. "Index out of bounds"))))
 
   (-nth [node n not-found]
     (cond (== n 0) key
@@ -7924,10 +8025,15 @@ reduces them without incurring seq initialization"
   IAssociative
   (-assoc [node k v]
     (assoc [key val] k v))
+  (-contains-key? [node k]
+    (or (== k 0) (== k 1)))
 
   IFind
   (-find [node k]
-    [key val])
+    (cond
+      (== k 0) [0 key]
+      (== k 1) [1 val]
+      :else nil))
 
   IVector
   (-assoc-n [node n v]
@@ -7942,10 +8048,10 @@ reduces them without incurring seq initialization"
 
   IFn
   (-invoke [node k]
-    (-lookup node k))
+    (-nth node k))
 
   (-invoke [node k not-found]
-    (-lookup node k not-found)))
+    (-nth node k not-found)))
 
 (es6-iterable RedNode)
 

src/test/cljs/cljs/map_entry_test.cljs

@@ -0,0 +1,146 @@
+;; Copyright (c) Rich Hickey. All rights reserved.
+;; The use and distribution terms for this software are covered by the
+;; Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+;; which can be found in the file epl-v10.html at the root of this distribution.
+;; By using this software in any fashion, you are agreeing to be bound by
+;; the terms of this license.
+;; You must not remove this notice, or any other, from this software.
+
+(ns cljs.map-entry-test
+  (:refer-clojure :exclude [iter])
+  (:require [cljs.test :refer-macros [deftest testing is are]]))
+
+(defn map-entry-interface-tests
+  "Tests that a MapEntry implements all the expected interfaces correctly.
+  Expects a MapEntry type with key `:key` and a val `:val`." 
+  [e]
+  (testing "map entry interfaces"
+    (testing "IMapEntry"
+      (testing "-key"
+        (is (= :key (-key e))))
+      (testing "-val"
+        (is (= :val (-val e)))))
+
+    (testing "IEquiv"
+      (testing "-equiv"
+        (are [x y] (-equiv x y)
+          e [:key :val]
+          e '(:key :val))))
+
+    (testing "ILookup"
+      (testing "-lookup 2-arity"
+        (are [x y] (= x y)
+          :key (-lookup e 0)
+          :val (-lookup e 1)
+          nil  (-lookup e 2)
+          nil  (-lookup e -1)))
+      (testing "-lookup 3-arity"
+        (are [x y] (= x y)
+          :key (-lookup e 0 :not-found)
+          :val (-lookup e 1 :not-found)
+          :not-found (-lookup e 2 :not-found)
+          :not-found (-lookup e -1 :not-found))))
+
+    (testing "IStack"
+      (testing "-peek"
+        (is (= :val (-peek e))))
+      (testing "-pop"
+        (is (vector? (-pop e)))
+        (is (= [:key] (-pop e)))))
+
+    (testing "ICollection"
+      (testing "-conj"
+        (is (vector? (-conj e :thing)))
+        (is (= [:key :val :thing] (-conj e :thing)))))
+
+    (testing "IEmptyableCollection"
+      (testing "-empty"
+        (is (= [] (empty e)))))
+
+    (testing "ISequential"
+      (is (satisfies? ISequential e)))
+
+    (testing "ISeqable"
+      (testing "-seq"
+        (is (= (list :key :val) (-seq e)))))
+
+    (testing "ICounted"
+      (testing "-count"
+        (is (= 2 (-count e)))))
+
+    (testing "IIndexed"
+      (testing "-nth 2-arity"
+        (are [x y] (= x y)
+          :key (-nth e 0)
+          :val (-nth e 1))
+        (is (thrown? js/Error (-nth e 2)))
+        (is (thrown? js/Error (-nth e -1))))
+      (testing "-nth 3-arity"
+        (are [x y] (= x y)
+          :key (-nth e 0 :not-found)
+          :val (-nth e 1 :not-found)
+          :not-found (-nth e 2 :not-found)
+          :not-found (-nth e -1 :not-found))))
+
+    (testing "IAssociative"
+      (testing "-assoc"
+        (are [x y] (= x y)
+          [:new :val] (-assoc e 0 :new)
+          [:key :new] (-assoc e 1 :new)
+          [:key :val :new] (-assoc e 2 :new)))
+      (testing "-contains-key?"
+        (are [x y] (= x y)
+          true (-contains-key? e 0)
+          true (-contains-key? e 1)
+          false (-contains-key? e 2)
+          false (-contains-key? e -1))))
+
+    (testing "IVector"
+      (testing "-assoc-n"
+        (are [x y] (= x y)
+          [:new :val] (-assoc-n e 0 :new)
+          [:key :new] (-assoc-n e 1 :new)
+          [:key :val :new] (-assoc-n e 2 :new))))
+
+    (testing "IReduce"
+      (testing "-reduce 2-arity"
+        (is (= [:key :val] (-reduce e (fn [r e] [r e])))))
+      (testing "-reduce 3-arity"
+        (is (= [:key :val] (-reduce e conj [])))))
+
+    (testing "IFind"
+      (testing "-find"
+        (are [x y] (= x y)
+          [0 :key] (-find e 0)
+          [1 :val] (-find e 1)
+          ;; Commented out as unsure about contract of -find 
+          ;; in the case where key is not present.
+          ;nil (-find e 2)
+          ;nil (-find e -1)
+          ;; So testing `find` in this case instead as contract is clear.
+          nil (find e 2)
+          nil (find e -1))))
+
+    (testing "IFn"
+      (testing "-invoke 2-arity"
+        (are [x y] (= x y)
+          :key (e 0)
+          :val (e 1))
+        (is (thrown? js/Error (e 2)))
+        (is (thrown? js/Error (e -1))))
+      (testing "-invoke 3-arity"
+        (are [x y] (= x y)
+          :key (e 0 :not-found)
+          :val (e 1 :not-found)
+          :not-found (e 2 :not-found)
+          :not-found (e -1 :not-found))))))
+
+(deftest all-map-entry-tests
+  (testing "BlackNode"
+    (map-entry-interface-tests (BlackNode. :key :val nil nil nil)))
+  (testing "RedNode"
+    (map-entry-interface-tests (RedNode. :key :val nil nil nil)))
+  (testing "Vector"
+    (map-entry-interface-tests [:key :val]))
+  (testing "MapEntry"
+    (map-entry-interface-tests (MapEntry. :key :val nil))))

src/test/cljs/test_runner.cljs

@@ -37,6 +37,7 @@
             [cljs.spec.test-test]
             [cljs.clojure-alias-test]
             [cljs.hash-map-test]
+            [cljs.map-entry-test]
             [cljs.predicates-test]
             [cljs.tagged-literals-test]
             [cljs.test-test]
@@ -73,6 +74,7 @@
   'cljs.spec.test-test
   'cljs.clojure-alias-test
   'cljs.hash-map-test
+  'cljs.map-entry-test
   'cljs.pprint-test
   'cljs.predicates-test
   'cljs.syntax-quote-test