5 files changed, 19 insertions(+), 16 deletions(-)

M guix/scripts/environment.scm
M guix/scripts/gc.scm
M guix/scripts/size.scm
M guix/store.scm
M tests/store.scm

@@ 333,11 333,11 @@ requisite store items i.e. the union closure of all the inputs."
     (requisites*
      (match input
        ((drv output)
-        (derivation->output-path drv output))
+        (list (derivation->output-path drv output)))
        ((drv)
-        (derivation->output-path drv))
+        (list (derivation->output-path drv)))
        ((? direct-store-path? path)
-        path))))
+        (list path)))))
 
   (mlet %store-monad ((reqs (sequence %store-monad
                                       (map input->requisites inputs))))

@@ 229,7 229,8 @@ Invoke the garbage collector.\n"))
         ((list-references)
          (list-relatives references))
         ((list-requisites)
-         (list-relatives requisites))
+         (list-relatives (lambda (store item)
+                           (requisites store (list item)))))
         ((list-referrers)
          (list-relatives referrers))
         ((optimize)

@@ 122,7 122,7 @@ substitutes."
     (guard (c ((nix-protocol-error? c)
                (values (substitutable-requisites store item)
                        store)))
-      (values (requisites store item) store))))
+      (values (requisites store (list item)) store))))
 
 (define (mappend-map mproc lst)
   "Apply MPROC to each item of LST and concatenate the resulting list."

@@ 803,12 803,12 @@ the list of references")
             (loop items tail
                   (cons head result)))))))))
 
-(define* (fold-path store proc seed path
+(define* (fold-path store proc seed paths
                     #:optional (relatives (cut references store <>)))
-  "Call PROC for each of the RELATIVES of PATH, exactly once, and return the
+  "Call PROC for each of the RELATIVES of PATHS, exactly once, and return the
 result formed from the successive calls to PROC, the first of which is passed
 SEED."
-  (let loop ((paths  (list path))
+  (let loop ((paths  paths)
              (result seed)
              (seen   vlist-null))
     (match paths


@@ 822,10 822,10 @@ SEED."
       (()
        result))))
 
-(define (requisites store path)
-  "Return the requisites of PATH, including PATH---i.e., its closure (all its
-references, recursively)."
-  (fold-path store cons '() path))
+(define (requisites store paths)
+  "Return the requisites of PATHS, including PATHS---i.e., their closures (all
+its references, recursively)."
+  (fold-path store cons '() paths))
 
 (define (topologically-sorted store paths)
   "Return a list containing PATHS and all their references sorted in

@@ 244,10 244,12 @@
       (and (= (length x) (length y))
            (lset= equal? x y)))
 
-    (and (same? (requisites %store t1) (list t1))
-         (same? (requisites %store t2) (list t1 t2))
-         (same? (requisites %store t3) (list t1 t2 t3))
-         (same? (requisites %store t4) (list t1 t2 t3 t4)))))
+    (and (same? (requisites %store (list t1)) (list t1))
+         (same? (requisites %store (list t2)) (list t1 t2))
+         (same? (requisites %store (list t3)) (list t1 t2 t3))
+         (same? (requisites %store (list t4)) (list t1 t2 t3 t4))
+         (same? (requisites %store (list t1 t2 t3 t4))
+                (list t1 t2 t3 t4)))))
 
 (test-assert "derivers"
   (let* ((b (add-text-to-store %store "build" "echo $foo > $out" '()))