derivations: 'derivation' and related procedures return a single value.

* guix/derivations.scm (derivation->output-path,
  derivation->output-paths): New procedures.
  (derivation-path->output-path): Use 'derivation->output-path'.
  (derivation-path->output-paths): Use 'derivation->output-paths'.
  (derivation): Accept 'derivation?' objects as inputs.  Return a single
  value.
  (build-derivations): New procedure.
  (compiled-modules): Use 'derivation->output-paths'.
  (build-expression->derivation)[source-path]: Add case for when the
  input matches 'derivation?'.
  [prologue]: Accept 'derivation?' objects in INPUTS.
  [mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
  'derivation-path?', pass it through 'read-derivation'.
  Use 'derivation-file-name' to print out the .drv file names, and to
  register them.  Use 'derivation->output-path' instead of
  'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
  return.
  (guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
  objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
  'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
  tests/store.scm, tests/union.scm: Adjust to the new calling
  convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
  accordingly.

1 files changed, 56 insertions, 23 deletions

diff --git a/guix/derivations.scm b/guix/derivations.scm
index 43ea328b0e..433a8f145e 100644
--- a/guix/derivations.scm
+++ b/guix/derivations.scm
@@ -58,6 +58,8 @@
 
             read-derivation
             write-derivation
+            derivation->output-path
+            derivation->output-paths
             derivation-path->output-path
             derivation-path->output-paths
             derivation
@@ -66,7 +68,8 @@
             imported-modules
             compiled-modules
             build-expression->derivation
-            imported-files))
+            imported-files)
+  #:replace (build-derivations))
 
 ;;;
 ;;; Nix derivations, as implemented in Nix's `derivations.cc'.
@@ -420,25 +423,30 @@ that form."
                  port)
      (display ")" port))))
 
+(define* (derivation->output-path drv #:optional (output "out"))
+  "Return the store path of its output OUTPUT."
+  (let ((outputs (derivation-outputs drv)))
+    (and=> (assoc-ref outputs output) derivation-output-path)))
+
+(define (derivation->output-paths drv)
+  "Return the list of name/path pairs of the outputs of DRV."
+  (map (match-lambda
+        ((name . output)
+         (cons name (derivation-output-path output))))
+       (derivation-outputs drv)))
+
 (define derivation-path->output-path
   ;; This procedure is called frequently, so memoize it.
   (memoize
    (lambda* (path #:optional (output "out"))
      "Read the derivation from PATH (`/nix/store/xxx.drv'), and return the store
 path of its output OUTPUT."
-     (let* ((drv     (call-with-input-file path read-derivation))
-            (outputs (derivation-outputs drv)))
-       (and=> (assoc-ref outputs output) derivation-output-path)))))
+     (derivation->output-path (call-with-input-file path read-derivation)))))
 
 (define (derivation-path->output-paths path)
   "Read the derivation from PATH (`/nix/store/xxx.drv'), and return the
 list of name/path pairs of its outputs."
-  (let* ((drv     (call-with-input-file path read-derivation))
-         (outputs (derivation-outputs drv)))
-    (map (match-lambda
-          ((name . output)
-           (cons name (derivation-output-path output))))
-         outputs)))
+  (derivation->output-paths (call-with-input-file path read-derivation)))
 
 
 ;;;
@@ -522,10 +530,10 @@ the derivation called NAME with hash HASH."
                      (inputs '()) (outputs '("out"))
                      hash hash-algo hash-mode
                      references-graphs)
-  "Build a derivation with the given arguments.  Return the resulting
-store path and <derivation> object.  When HASH, HASH-ALGO, and HASH-MODE
-are given, a fixed-output derivation is created---i.e., one whose result is
-known in advance, such as a file download.
+  "Build a derivation with the given arguments, and return the resulting
+<derivation> object.  When HASH, HASH-ALGO, and HASH-MODE are given, a
+fixed-output derivation is created---i.e., one whose result is known in
+advance, such as a file download.
 
 When REFERENCES-GRAPHS is true, it must be a list of file name/store path
 pairs.  In that case, the reference graph of each store path is exported in
@@ -610,6 +618,12 @@ the build environment in the corresponding file, in a simple text format."
                                   (make-derivation-output "" hash-algo hash)))
                           outputs))
          (inputs     (map (match-lambda
+                           (((? derivation? drv))
+                            (make-derivation-input (derivation-file-name drv)
+                                                   '("out")))
+                           (((? derivation? drv) sub-drvs ...)
+                            (make-derivation-input (derivation-file-name drv)
+                                                   sub-drvs))
                            (((? direct-store-path? input))
                             (make-derivation-input input '("out")))
                            (((? direct-store-path? input) sub-drvs ...)
@@ -638,7 +652,21 @@ the build environment in the corresponding file, in a simple text format."
                                     (cut write-derivation drv <>))
                                    (map derivation-input-path
                                         inputs))))
-      (values file (set-file-name drv file)))))
+      (set-file-name drv file))))
+
+
+;;;
+;;; Store compatibility layer.
+;;;
+
+(define (build-derivations store derivations)
+  "Build DERIVATIONS, a list of <derivation> objects or .drv file names."
+  (let ((build (@ (guix store) build-derivations)))
+    (build store (map (match-lambda
+                       ((? string? file) file)
+                       ((and drv ($ <derivation>))
+                        (derivation-file-name drv)))
+                      derivations))))
 
 
 ;;;
@@ -730,7 +758,7 @@ they can refer to each other."
                                        #:system system
                                        #:guile guile
                                        #:module-path module-path))
-         (module-dir (derivation-path->output-path module-drv))
+         (module-dir (derivation->output-path module-drv))
          (files      (map (lambda (m)
                             (let ((f (string-join (map symbol->string m)
                                                   "/")))
@@ -794,7 +822,7 @@ See the `derivation' procedure for the meaning of REFERENCES-GRAPHS."
     (or guile-for-build (%guile-for-build)))
 
   (define guile
-    (string-append (derivation-path->output-path guile-drv)
+    (string-append (derivation->output-path guile-drv)
                    "/bin/guile"))
 
   (define module-form?
@@ -806,6 +834,8 @@ See the `derivation' procedure for the meaning of REFERENCES-GRAPHS."
     ;; When passed an input that is a source, return its path; otherwise
     ;; return #f.
     (match-lambda
+     ((_ (? derivation?) _ ...)
+      #f)
      ((_ path _ ...)
       (and (not (derivation-path? path))
            path))))
@@ -830,10 +860,13 @@ See the `derivation' procedure for the meaning of REFERENCES-GRAPHS."
                                               (() "out")
                                               ((x) x))))
                                    (cons name
-                                         (if (derivation-path? drv)
-                                             (derivation-path->output-path drv
-                                                                           sub)
-                                             drv)))))
+                                         (cond
+                                          ((derivation? drv)
+                                           (derivation->output-path drv sub))
+                                          ((derivation-path? drv)
+                                           (derivation-path->output-path drv
+                                                                         sub))
+                                          (else drv))))))
                                inputs))
 
                       ,@(if (null? modules)
@@ -878,13 +911,13 @@ See the `derivation' procedure for the meaning of REFERENCES-GRAPHS."
                                           #:guile guile-drv
                                           #:system system)))
          (mod-dir  (and mod-drv
-                        (derivation-path->output-path mod-drv)))
+                        (derivation->output-path mod-drv)))
          (go-drv   (and (pair? modules)
                         (compiled-modules store modules
                                           #:guile guile-drv
                                           #:system system)))
          (go-dir   (and go-drv
-                        (derivation-path->output-path go-drv))))
+                        (derivation->output-path go-drv))))
     (derivation store name guile
                 `("--no-auto-compile"
                   ,@(if mod-dir `("-L" ,mod-dir) '())