     alternatives
     (let [partn
           (group-by
-            (fn [term]
-              (let [id (get term :id)]
-                (cond
+           (fn [term]
+             (let [id (get term :id)]
+               (cond
+                 (get
+                  absent-specs
+                  id)
+                 :absent
+                 (or
                   (get
-                    absent-specs
-                    id)
-                  :absent
-                  (or
-                    (get
-                      found-packages
-                      id)
-                    (get
-                      present-packages
-                      id))
-                  :present
-                  :else
-                  :unspecified)))
-            alternatives)]
+                   found-packages
+                   id)
+                  (get
+                   present-packages
+                   id))
+                 :present
+                 :else
+                 :unspecified)))
+           alternatives)]
       (concat (:absent partn) (:present partn) (:unspecified partn)))))
 
+                                        ; If transformed value passes test,
+                                        ; return a singleton list of those;
+                                        ; otherwise, return the full list of transformed stuffs.
+                                        ; This is because lazy seqs in clojure aren't exactly lazy;
+                                        ; they're chunked lazy, which is sad.
+(defn- first-found
+  [f pred coll]
+  (reduce
+   (fn find-first
+     [c v]
+     (let [new-v (f v)]
+       (if (pred new-v)
+         (reduced [new-v])
+         (conj c new-v))))
+   []
+   coll))
 
 (defn resolve-dependencies
   [requirements

                 allow-alternatives true}}]
  (let [safe-spec-call (make-spec-call compare)
        cull (case strategy
                 :thorough
                 cull-nothing
                 :fast
                 cull-all-but-first
                 (throw
                  (ex-info (str
                            "Invalid strategy `"
                            strategy
                            "`.")
                           {:strategy strategy})))
        cull-alternatives
        (if allow-alternatives
          cull-nothing

                                                   :found-packages found-packages
                                                   :present-packages present-packages
                                                   :absent-specs absent-specs}]}])))
                           successful?
                           ;; Hoisting
                           (hoist (cull-alternatives
                                   fclause)
                                  absent-specs
                                  found-packages
                                  present-packages))]
