 (defn include?
   "Check if val exists in coll."
   [val coll]
-  (some (partial = val) coll))
+  (some #{val} coll))
 
 (defn extract
   "Extracts the first item that matches pred from coll, returning a vector of that item
    followed by coll with the items removed."
   [pred coll]
-  (loop [head ()
-         tail (seq coll)]
-    (let [item (first tail)
-          tail (next tail)]
-      (if (or (nil? tail) (pred item))
-        [item (into tail head)]
-        (recur (conj head item) tail)))))
+  (let [[head [item & tail]] (split-with (complement pred) coll)]
+    [item (concat head tail)]))
 
 (defn separate
   "Split coll into two sequences, one that matches pred and one that doesn't. Unlike, the
   version in clojure.contrib.seq-utils, this is not lazy, but pred is only called once per item."
   [pred coll]
-  (loop [tail (seq coll)
-         yes () no ()]
-    (if (nil? tail)
-      [(reverse yes) (reverse no)]
-      (let [item (first tail)
-            tail (next tail)]
-        (if (pred item)
-          (recur tail (conj yes item) no)
-          (recur tail yes (conj no item)))))))
+  (reduce (fn [[yes no] item]
+            (if (pred item)
+              [(conj yes item) no]
+              [yes (conj no item)]))
+          [[] []]
+          coll))
 
 (defmacro if-ns [ns-reference then-form & [else-form]]
-  "Try to load a namespace reference. If sucessful, evaluate then-form otherwise evaluate else-form."
+  "Try to load a namespace reference. If successful, evaluate then-form otherwise evaluate else-form."
   `(try (ns ~(ns-name *ns*) ~ns-reference)
         (eval '~then-form)
         (catch Exception e#
-          (when (not (instance? java.io.FileNotFoundException e#))
+          (when-not (instance? java.io.FileNotFoundException e#)
             (println "Error loading" '~ns-reference (.getMessage e#)))
           (eval '~else-form))))
 

  "Returns a lazy sequence of vectors of corresponding items from each collection.
   Stops when the shortest collection runs out."
  [& colls]
  (partition
   (count colls)
   (apply interleave colls)))

(defn find-with
  "Returns the val corresponding to the first key where (pred key) returns true."

  (last (first (filter (comp pred first) (zip keys vals)))))

(defn filter-keys-by-val
  "Returns all keys in map for which (pred value) returns true."
  [pred map]
  (when map
    (for [[key val] map :when (pred val)] key)))

(defn remove-keys-by-val
