build-system/python: 'package-with-explicit-python' uses 'package-mapping'.

* guix/build-system/python.scm (package-with-explicit-python)
[package-variant, cut?]: New procedures.
[transform]: Remove 'mlambdaq' form and input tuple handling.
Use 'package-mapping'.

guix/build-system/python.scm

@@ -83,28 +83,17 @@ pre-defined variants of this transformation recorded in the 'properties' field
 of packages.  The property value must be the promise of a package.  This is a
 convenient way for package writers to force the transformation to use
 pre-defined variants."
-  (define transform
+  (define package-variant
-    ;; Memoize the transformations.  Failing to do that, we would build a huge
+    (if variant-property
-    ;; object graph with lots of duplicates, which in turns prevents us from
+        (lambda (package)
-    ;; benefiting from memoization in 'package-derivation'.
+          (assq-ref (package-properties package)
-    (mlambdaq (p)
+                    variant-property))
-      (let* ((rewrite-if-package
+        (const #f)))
-              (lambda (content)
-                ;; CONTENT may be a file name, in which case it is returned,
-                ;; or a package, which is rewritten with the new PYTHON and
-                ;; NEW-PREFIX.
-                (if (package? content)
-                    (transform content)
-                    content)))
-             (rewrite
-              (match-lambda
-                ((name content . rest)
-                 (append (list name (rewrite-if-package content)) rest)))))
 
+  (define (transform p)
     (cond
      ;; If VARIANT-PROPERTY is present, use that.
-         ((and variant-property
+     ((package-variant p)
-               (assoc-ref (package-properties p) variant-property))
       => force)
 
      ;; Otherwise build the new package object graph.
@@ -123,14 +112,14 @@ pre-defined variants."
                            (force python)
                            python)))
            (ensure-keyword-arguments (package-arguments p)
-                                         `(#:python ,python))))
+                                     `(#:python ,python))))))
-            (inputs (map rewrite (package-inputs p)))
+     (else p)))
-            (propagated-inputs (map rewrite (package-propagated-inputs p)))
-            (native-inputs (map rewrite (package-native-inputs p)))))
-         (else
-          p)))))
 
-  transform)
+  (define (cut? p)
+    (or (not (eq? (package-build-system p) python-build-system))
+        (package-variant p)))
+
+  (package-mapping transform cut?))
 
 (define package-with-python2
   ;; Note: delay call to 'default-python2' until after the 'arguments' field