Merge pull request schani#24 from jolby/add_imeta_and_other_fns

Added more core fns ported from JS impl

Author: schani

src/cljc/cljc/core.cljc

@@ -848,6 +848,10 @@ reduces them without incurring seq initialization"
     false
     (satisfies? ISet x)))
 
+(defn ^boolean associative?
+ "Returns true if coll implements Associative"
+  [x] (satisfies? IAssociative x))
+
 (defn ^boolean sequential?
   "Returns true if coll satisfies ISequential"
   [x] (satisfies? ISequential x))
@@ -867,6 +871,22 @@ reduces them without incurring seq initialization"
 (defn ^boolean chunked-seq?
   [x] (satisfies? IChunkedSeq x))
 
+(defn ^boolean distinct?
+  "Returns true if no two of the arguments are ="
+  ([x] true)
+  ([x y] (not (= x y)))
+  ([x y & more]
+     (if (not (= x y))
+     (loop [s #{x y} xs more]
+       (let [x (first xs)
+             etc (next xs)]
+         (if xs
+           (if (contains? s x)
+             false
+             (recur (conj s x) etc))
+           true)))
+     false)))
+
 (defn- accumulating-seq-count [coll]
   (loop [s (seq coll) acc 0]
     (if (counted? s) ; assumes nil is counted, which it currently is
@@ -935,6 +955,14 @@ reduces them without incurring seq initialization"
   ([o k not-found]
      (-lookup o k not-found)))
 
+(defn find
+  "Returns the map entry for key, or nil if key not present."
+  [coll k]
+  (when (and coll
+             (associative? coll)
+             (contains? coll k))
+    [k (-lookup coll k)]))
+
 (defn assoc
   "assoc[iate]. When applied to a map, returns a new map of the
    same (hashed/sorted) type, that contains the mapping of key(s) to
@@ -960,6 +988,31 @@ reduces them without incurring seq initialization"
          (recur ret (first ks) (next ks))
          ret))))
 
+(defn with-meta
+  "Returns an object of the same type and value as obj, with
+  map m as its metadata."
+  [o meta]
+  (-with-meta o meta))
+
+(defn meta
+  "Returns the metadata of obj, returns nil if there is no metadata."
+  [o]
+  (when (satisfies? IMeta o)
+    (-meta o)))
+
+(defn peek
+  "For a list or queue, same as first, for a vector, same as, but much
+  more efficient than, last. If the collection is empty, returns nil."
+  [coll]
+  (-peek coll))
+
+(defn pop
+  "For a list or queue, returns a new list/queue without the first
+  item, for a vector, returns a new vector without the last item.
+  Note - not the same as next/butlast."
+  [coll]
+  (-pop coll))
+
 (defn disj
   "disj[oin]. Returns a new set of the same (hashed/sorted) type, that
   does not contain key(s)."

test/clojurec/core_test.clj

@@ -422,6 +422,8 @@
                           (recur (rest l)))))
            [13 0 10]))
     (is (= (core-run '(print (-count nil))) [0]))
+    (is (= (core-run '(let [v ["A" "B" "C"] vm (with-meta v {:a 33})] (pr ((meta vm) :a))))
+           [33]))
     (is (= (core-run '(pr (filter #(> % 3) (list 1 2 3 4 5))))
            ['(4 5)]))
     (is (= (core-run '(do
@@ -559,7 +561,11 @@
     (is (= (core-run '(pr ((set '(1 2 3)) 1)
                           ((set '(1 2 3)) 4)
                           ((set '(1 2 3)) 4 5)))
-           [1 nil 5]))))
+           [1 nil 5]))
+    (is (= (core-run '(pr
+                       (distinct? 1 2 3 1)
+                       (distinct? 1 2 3)))
+           [false true]))))
 
 (deftest functions
   (testing "functions"

test/clojurec/persistent_hash_map_test.clj

@@ -31,7 +31,7 @@
                    (= (get m2 f2 "NOT FOUND") "Baz")
                    (= (get m3 2 "NOT FOUND") "V2"))))))
 
-    (is (= [100 100 true true false nil false 99 true]
+    (is (= [100 100 true true true false nil 3 false 99 true]
            (clojurec.core/run-expr
             'clojurec.core-test true
             '(loop [m1 cljc.core.PersistentHashMap/EMPTY
@@ -53,9 +53,11 @@
                    (pr (count m1)
                        (count m2)
                        (= m1 m2)
+                       (associative? m1)
                        (contains? m1 3)
                        (contains? m1 333)
                        (get m1 333)
+                       (first (find m1 3))
                        (contains? (dissoc m1 3) 3)
                        (count (dissoc m1 3))
                        (every? boolean v))))))))))

test/clojurec/vector_test.clj

@@ -38,13 +38,13 @@
            (core-run '(let [v1 (conj [] 123)
                             v100 (loop [i 1 v v1]
                                    (if (< i 100) (recur (inc i) (conj v i)) v))]
-                        (print (-peek v1))
-                        (print (count (-pop v1)))
-                        (print (-peek v100))
-                        (print (count (-pop v100)))
+                        (print (peek v1))
+                        (print (count (pop v1)))
+                        (print (peek v100))
+                        (print (count (pop v100)))
                         (print (count (loop [i 1 v v100]
                                         (if (< i 100)
-                                          (recur (inc i) (-pop v))
+                                          (recur (inc i) (pop v))
                                           v)))))))))
 
   (testing "PersistentVector assoc"