35 files changed, 134 insertions(+), 298 deletions(-)

M guix/build-system.scm
M guix/build-system/agda.scm
M guix/build-system/android-ndk.scm
M guix/build-system/ant.scm
M guix/build-system/cargo.scm
M guix/build-system/chicken.scm
M guix/build-system/composer.scm
M guix/build-system/dub.scm
M guix/build-system/elm.scm
M guix/build-system/emacs.scm
M guix/build-system/glib-or-gtk.scm
M guix/build-system/go.scm
M guix/build-system/haskell.scm
M guix/build-system/julia.scm
M guix/build-system/linux-module.scm
M guix/build-system/luanti.scm
M guix/build-system/maven.scm
M guix/build-system/meson.scm
M guix/build-system/minify.scm
M guix/build-system/mix.scm
M guix/build-system/node.scm
M guix/build-system/ocaml.scm
M guix/build-system/perl.scm
M guix/build-system/pyproject.scm
M guix/build-system/qt.scm
M guix/build-system/r.scm
M guix/build-system/rakudo.scm
M guix/build-system/rebar.scm
M guix/build-system/renpy.scm
M guix/build-system/ruby.scm
M guix/build-system/scons.scm
M guix/build-system/texlive.scm
M guix/build-system/tree-sitter.scm
M guix/build-system/vim.scm
M guix/build-system/zig.scm

@@ 20,7 20,9 @@
   #:use-module (guix records)
   #:use-module (srfi srfi-1)
   #:use-module (ice-9 match)
-  #:export (build-system
+  #:export (@*
+
+            build-system
             build-system?
             build-system-name
             build-system-description


@@ 42,6 44,10 @@
 
             build-system-with-c-toolchain))
 
+(define-syntax-rule (@* module name)
+  "Like (@ MODULE NAME), but resolves at run time."
+  (module-ref (resolve-interface 'module) 'name))
+
 (define-record-type* <build-system> build-system make-build-system
   build-system?
   (name        build-system-name)         ; symbol

@@ 33,8 33,7 @@
 
 (define (default-agda)
   ;; Lazily resolve the binding to avoid a circular dependency.
-  (let ((agda (resolve-interface '(gnu packages agda))))
-    (module-ref agda 'agda)))
+  (@* (gnu packages agda) agda))
 
 (define %agda-build-system-modules
   `((guix build agda-build-system)

@@ 35,15 35,12 @@
   `((guix build android-ndk-build-system)
     ,@%default-gnu-imported-modules))
 
+;; Lazily resolve bindings to avoid circular dependencies.
 (define (default-android-build)
-  ;; Lazily resolve the binding to avoid a circular dependency.
-  (let ((android (resolve-interface '(gnu packages android))))
-    (module-ref android 'android-make-stub)))
+  (@* (gnu packages android) android-make-stub))
 
 (define (default-android-googletest)
-  ;; Lazily resolve the binding to avoid a circular dependency.
-  (let ((android (resolve-interface '(gnu packages android))))
-    (module-ref android 'android-googletest)))
+  (@* (gnu packages android) android-googletest))
 
 (define* (android-ndk-build name inputs
                             #:key

@@ 45,23 45,18 @@
     (guix build java-utils)
     ,@%default-gnu-imported-modules))
 
+;; Lazily resolve bindings to avoid a circular dependencies.
 (define (default-jdk)
-  "Return the default JDK package."
-  ;; Lazily resolve the binding to avoid a circular dependency.
-  (let ((jdk-mod (resolve-interface '(gnu packages java))))
-    (module-ref jdk-mod 'icedtea)))
+  "Return the default JDK package, resolved lazily."
+  (@* (gnu packages java) icedtea))
 
 (define (default-ant)
-  "Return the default Ant package."
-  ;; Lazily resolve the binding to avoid a circular dependency.
-  (let ((jdk-mod (resolve-interface '(gnu packages java))))
-    (module-ref jdk-mod 'ant)))
+  "Return the default Ant package, resolved lazily."
+  (@* (gnu packages java) ant))
 
 (define (default-zip)
-  "Return the default ZIP package."
-  ;; Lazily resolve the binding to avoid a circular dependency.
-  (let ((zip-mod (resolve-interface '(gnu packages compression))))
-    (module-ref zip-mod 'zip)))
+  "Return the default ZIP package, resolved lazily."
+  (@* (gnu packages compression) zip))
 
 (define* (lower name
                 #:key source inputs native-inputs outputs system target

@@ 108,10 108,8 @@ unavailable."
           '()))))
 
 (define (default-rust target)
-  "Return the default Rust package."
-  ;; Lazily resolve the binding to avoid a circular dependency.
-  (let ((rust (resolve-interface '(gnu packages rust))))
-    (module-ref rust 'rust)))
+  "Return the default Rust package, resolved lazily."
+  (@* (gnu packages rust) rust))
 
 (define (default-rust-sysroot target)
   "Return the default Rust sysroot for <target>."

@@ 46,9 46,7 @@ EXTENSION is the file name extension, such as '.tar.gz'."
 
 (define (default-chicken)
   ;; Lazily resolve the binding to avoid a circular dependency.
-  ;; TODO is this actually needed in every build system?
-  (let ((chicken (resolve-interface '(gnu packages chicken))))
-      (module-ref chicken 'chicken)))
+  (@* (gnu packages chicken) chicken))
 
 (define* (lower name
                 #:key source inputs native-inputs outputs system target

@@ 40,23 40,18 @@
 ;;
 ;; Code:
 
+;; Lazily resolve bindings to avoid circular dependencies.
 (define (default-php)
-  "Return the default PHP package."
-
-  ;; Do not use `@' to avoid introducing circular dependencies.
-  (let ((module (resolve-interface '(gnu packages php))))
-    (module-ref module 'php)))
+  "Return the default PHP package, resolved lazily."
+  (@* (gnu packages php) php))
 
 (define (default-findclass)
   "Return the default findclass script."
   (search-auxiliary-file "findclass.php"))
 
 (define (default-composer-classloader)
-  "Return the default composer-classloader package."
-
-  ;; Do not use `@' to avoid introducing circular dependencies.
-  (let ((module (resolve-interface '(gnu packages php-xyz))))
-    (module-ref module 'composer-classloader)))
+  "Return the default composer-classloader package, resolved lazily."
+  (@* (gnu packages php-xyz) composer-classloader))
 
 (define %composer-build-system-modules
   ;; Build-side modules imported by default.

@@ 31,30 31,20 @@
   #:use-module (guix build-system gnu)
   #:export (dub-build-system))
 
+;; Lazily resolve bindings to avoid a circular dependencies.
 (define (default-ldc)
-  "Return the default ldc package."
-  ;; Lazily resolve the binding to avoid a circular dependency.
-  (let ((ldc (resolve-interface '(gnu packages dlang))))
-    (module-ref ldc 'ldc)))
+  (@* (gnu packages dlang) ldc))
 
 (define (default-dub)
-  "Return the default dub package."
-  ;; Lazily resolve the binding to avoid a circular dependency.
-  (let ((ldc (resolve-interface '(gnu packages dlang))))
-    (module-ref ldc 'dub)))
+  (@* (gnu packages dlang) dub))
 
 (define (default-pkg-config)
-  "Return the default pkg-config package."
-  ;; Lazily resolve the binding to avoid a circular dependency.
-  (let ((pkg-config (resolve-interface '(gnu packages pkg-config))))
-    (module-ref pkg-config 'pkg-config)))
+  (@* (gnu packages pkg-config) pkg-config))
 
 (define (default-ld-gold-wrapper)
-  "Return the default ld-gold-wrapper package."
   ;; LDC doesn't work with Guix's default (BFD) linker.
   ;; Lazily resolve the binding to avoid a circular dependency.
-  (let ((commencement (resolve-interface '(gnu packages commencement))))
-    (module-ref commencement 'ld-gold-wrapper)))
+  (@* (gnu packages commencement) ld-gold-wrapper))
 
 (define %dub-build-system-modules
   ;; Build-side modules imported by default.

@@ 97,23 97,15 @@ given VERSION with sha256 checksum HASH."
     (guix build json)
     (guix build union)))
 
+;; Lazily resolve bindings to avoid circular dependencies.
 (define (default-elm)
-  "Return the default Elm package for builds."
-  ;; Lazily resolve the binding to avoid a circular dependency.
-  (let ((elm (resolve-interface '(gnu packages elm))))
-    (module-ref elm 'elm-sans-reactor)))
+  (@* (gnu packages elm) elm-sans-reactor))
 
 (define (default-elm-core)
-  "Return the default elm-core package."
-  ;; Lazily resolve the binding to avoid a circular dependency.
-  (let ((elm (resolve-interface '(gnu packages elm))))
-    (module-ref elm 'elm-core)))
+  (@* (gnu packages elm) elm-core))
 
 (define (default-elm-json)
-  "Return the default elm-json package."
-  ;; Lazily resolve the binding to avoid a circular dependency.
-  (let ((elm (resolve-interface '(gnu packages elm))))
-    (module-ref elm 'elm-json)))
+  (@* (gnu packages elm) elm-json))
 
 (define* (lower name
                 #:key source inputs native-inputs outputs system target

@@ 49,10 49,8 @@
     ,@%default-gnu-imported-modules))
 
 (define (default-emacs)
-  "Return the default Emacs package."
-  ;; Lazily resolve the binding to avoid a circular dependency.
-  (let ((emacs-mod (resolve-interface '(gnu packages emacs))))
-    (module-ref emacs-mod 'emacs-minimal)))
+  "Return the default Emacs package, resolved lazily."
+  (@* (gnu packages emacs) emacs-minimal))
 
 (define* (lower name
                 #:key source inputs native-inputs outputs system target

@@ 77,10 77,8 @@
 
 (define (default-glib)
   "Return the default glib package from which we use
-\"glib-compile-schemas\"."
-  ;; Do not use `@' to avoid introducing circular dependencies.
-  (let ((module (resolve-interface '(gnu packages glib))))
-    (module-ref module 'glib)))
+\"glib-compile-schemas\", resolved lazily."
+  (@* (gnu packages glib) glib))
 
 (define* (lower name
                 #:key source inputs native-inputs outputs system target

@@ 130,17 130,13 @@ commit hash and its date rather than a proper release tag."
     ,@%default-gnu-imported-modules))
 
 (define (default-go)
-  ;; Lazily resolve the binding to avoid a circular dependency.
-  (let ((go (resolve-interface '(gnu packages golang))))
-    (module-ref go 'go)))
+  (@* (gnu packages golang) go))
 
 (define (default-gccgo)
-  ;; Lazily resolve the binding to avoid a circular dependency.
-  (let ((gcc (resolve-interface '(gnu packages gcc))))
-    (module-ref gcc 'gccgo-12)))
+  (@* (gnu packages gcc) gccgo-12))
 
 (define (make-go-std)
-  (module-ref (resolve-interface '(gnu packages golang)) 'make-go-std))
+  (@* (gnu packages golang) make-go-std))
 
 (define* (lower name
                 #:key source inputs native-inputs outputs system target

@@ 58,10 58,8 @@ to NAME and VERSION."
     ,@%default-gnu-imported-modules))
 
 (define (default-haskell)
-  "Return the default Haskell package."
-  ;; Lazily resolve the binding to avoid a circular dependency.
-  (let ((haskell (resolve-interface '(gnu packages haskell))))
-    (module-ref haskell 'ghc)))
+  "Return the default Haskell package, resolved lazily."
+  (@* (gnu packages haskell) ghc))
 
 (define (source-url->revision-url url revision)
   "Convert URL (a Hackage source URL) to the URL for the Cabal file at

@@ 45,10 45,8 @@
     ,@%default-gnu-imported-modules))
 
 (define (default-julia)
-  "Return the default Julia package."
-  ;; Lazily resolve the binding to avoid a circular dependency.
-  (let ((julia-mod (resolve-interface '(gnu packages julia))))
-    (module-ref julia-mod 'julia)))
+  "Return the default Julia package, resolved lazily."
+  (@* (gnu packages julia) julia))
 
 (define* (lower name
                 #:key source inputs native-inputs outputs system target

@@ 45,11 45,8 @@
     ,@%default-gnu-imported-modules))
 
 (define (default-linux)
-  "Return the default Linux package."
-
-  ;; Do not use `@' to avoid introducing circular dependencies.
-  (let ((module (resolve-interface '(gnu packages linux))))
-    (module-ref module 'linux-libre)))
+  "Return the default Linux package, resolved lazily."
+  (@* (gnu packages linux) linux-libre))
 
 (define (system->arch system)
   (platform-linux-architecture (lookup-platform-by-target-or-system system)))

@@ 30,20 30,6 @@
 ;;
 ;; Code:
 
-;; Lazily resolve the bindings to avoid circular dependencies.
-(define (default-optipng)
-  ;; Lazily resolve the binding to avoid a circular dependency.
-  (module-ref (resolve-interface '(gnu packages image)) 'optipng))
-
-(define (default-luanti)
-  (module-ref (resolve-interface '(gnu packages luanti)) 'luanti))
-
-(define (default-luanti-game)
-  (module-ref (resolve-interface '(gnu packages luanti)) 'minetest-game))
-
-(define (default-xvfb-run)
-  (module-ref (resolve-interface '(gnu packages xorg)) 'xvfb-run))
-
 (define %luanti-build-system-modules
   ;; Build-side modules imported by default.
   `((guix build luanti-build-system)


@@ 57,11 43,12 @@
 
 (define (standard-luanti-packages)
   "Return the list of (NAME PACKAGE OUTPUT) or (NAME PACKAGE) tuples of
-standard packages used as implicit inputs of the Luanti build system."
-  `(("xvfb-run" ,(default-xvfb-run))
-    ("optipng" ,(default-optipng))
-    ("luanti" ,(default-luanti))
-    ("luanti-game" ,(default-luanti-game))
+standard packages used as implicit inputs of the Luanti build system,
+resolved lazily."
+  `(("xvfb-run" ,(@* (gnu packages xorg) xvfb-run))
+    ("optipng" ,(@* (gnu packages image) optipng))
+    ("luanti" ,(@* (gnu packages luanti) luanti))
+    ("luanti-game" ,(@* (gnu packages luanti) minetest-game))
     ,@(filter (lambda (input)
                 (member (car input)
                         '("libc" "tar" "gzip" "bzip2" "xz" "locales")))

@@ 49,61 49,22 @@
     ,@%default-gnu-imported-modules))
 
 (define (default-maven)
-  "Return the default maven package."
-
-  ;; Do not use `@' to avoid introducing circular dependencies.
-  (let ((module (resolve-interface '(gnu packages maven))))
-    (module-ref module 'maven)))
-
-(define (default-maven-compiler-plugin)
-  "Return the default maven compiler plugin package."
-  ;; Do not use `@' to avoid introducing circular dependencies.
-  (let ((module (resolve-interface '(gnu packages maven))))
-    (module-ref module 'maven-compiler-plugin)))
-
-(define (default-maven-jar-plugin)
-  "Return the default maven jar plugin package."
-  ;; Do not use `@' to avoid introducing circular dependencies.
-  (let ((module (resolve-interface '(gnu packages maven))))
-    (module-ref module 'maven-jar-plugin)))
-
-(define (default-maven-resources-plugin)
-  "Return the default maven resources plugin package."
-  ;; Do not use `@' to avoid introducing circular dependencies.
-  (let ((module (resolve-interface '(gnu packages maven))))
-    (module-ref module 'maven-resources-plugin)))
-
-(define (default-maven-surefire-plugin)
-  "Return the default maven surefire plugin package."
-  ;; Do not use `@' to avoid introducing circular dependencies.
-  (let ((module (resolve-interface '(gnu packages maven))))
-    (module-ref module 'maven-surefire-plugin)))
-
-(define (default-java-surefire-junit4)
-  "Return the default surefire junit4 provider package."
-  ;; Do not use `@' to avoid introducing circular dependencies.
-  (let ((module (resolve-interface '(gnu packages maven))))
-    (module-ref module 'java-surefire-junit4)))
-
-(define (default-maven-install-plugin)
-  "Return the default maven install plugin package."
-  ;; Do not use `@' to avoid introducing circular dependencies.
-  (let ((module (resolve-interface '(gnu packages maven))))
-    (module-ref module 'maven-install-plugin)))
+  "Return the default maven package, resolved lazily."
+  (@* (gnu packages maven) maven))
 
 (define (default-jdk)
-  "Return the default JDK package."
-  ;; Lazily resolve the binding to avoid a circular dependency.
-  (let ((jdk-mod (resolve-interface '(gnu packages java))))
-    (module-ref jdk-mod 'icedtea)))
+  "Return the default JDK package, resolved lazily."
+  (@* (gnu packages java) icedtea))
 
 (define (default-maven-plugins)
-  `(("maven-compiler-plugin" ,(default-maven-compiler-plugin))
-    ("maven-jar-plugin" ,(default-maven-jar-plugin))
-    ("maven-resources-plugin" ,(default-maven-resources-plugin))
-    ("maven-surefire-plugin" ,(default-maven-surefire-plugin))
-    ("java-surefire-junit4" ,(default-java-surefire-junit4))
-    ("maven-install-plugin" ,(default-maven-install-plugin))))
+  "Return the default maven plugins, resolved lazily."
+  `(("maven-compiler-plugin" ,(@* (gnu packages maven) maven-compiler-plugin))
+    ("maven-jar-plugin" ,(@* (gnu packages maven) maven-jar-plugin))
+    ("maven-surefire-plugin" ,(@* (gnu packages maven) maven-surefire-plugin))
+    ("java-surefire-junit4" ,(@* (gnu packages maven) java-surefire-junit4))
+    ("maven-install-plugin" ,(@* (gnu packages maven) maven-install-plugin))
+    ("maven-resources-plugin"
+     ,(@* (gnu packages maven) maven-resources-plugin))))
 
 (define %default-exclude
   `(("org.apache.maven.plugins" .

@@ 134,16 134,12 @@ TRIPLET."
     ,@%glib-or-gtk-build-system-modules))
 
 (define (default-ninja)
-  "Return the default ninja package."
-  ;; Lazily resolve the binding to avoid a circular dependency.
-  (let ((module (resolve-interface '(gnu packages ninja))))
-    (module-ref module 'ninja/pinned)))
+  "Return the default ninja package, resolved lazily."
+  (@* (gnu packages ninja) ninja/pinned))
 
 (define (default-meson)
-  "Return the default meson package."
-  ;; Lazily resolve the binding to avoid a circular dependency.
-  (let ((module (resolve-interface '(gnu packages build-tools))))
-    (module-ref module 'meson)))
+  "Return the default meson package, resolved lazily."
+  (@* (gnu packages build-tools) meson))
 
 (define* (lower name
                 #:key source inputs native-inputs outputs system target

@@ 43,9 43,7 @@
 
 (define (default-esbuild)
   "Return the default package to minify JavaScript source files."
-  ;; Lazily resolve the binding to avoid a circular dependency.
-  (let ((mod (resolve-interface '(gnu packages web))))
-    (module-ref mod 'esbuild)))
+  (@* (gnu packages web) esbuild))
 
 (define* (lower name
                 #:key source inputs native-inputs outputs system


@@ 54,7 52,7 @@
                 #:rest arguments)
   "Return a bag for NAME."
   (define private-keywords
-    '(#:target #:inputs #:native-inputs))
+    '(#:target #:inputs #:native-inputs #:esbuild))
 
   (bag
     (name name)

@@ 39,16 39,13 @@
   #:export (mix-build-system hexpm-uri))
 
 (define (default-elixir-hex)
-  (let ((elixir (resolve-interface '(gnu packages elixir))))
-    (module-ref elixir 'elixir-hex)))
+  (@* (gnu packages elixir) elixir-hex))
 
 (define (default-rebar3)
-  (let ((erlang (resolve-interface '(gnu packages erlang))))
-    (module-ref erlang 'rebar3)))
+  (@* (gnu packages erlang) rebar3))
 
 (define (default-elixir)
-  (let ((elixir (resolve-interface '(gnu packages elixir))))
-    (module-ref elixir 'elixir)))
+  (@* (gnu packages elixir) elixir))
 
 (define* (strip-prefix name #:optional (prefix "elixir-"))
   "Return NAME without the prefix PREFIX."

@@ 44,10 44,8 @@
     ,@%default-gnu-imported-modules))
 
 (define (default-node)
-  "Return the default Node package."
-  ;; Lazily resolve the binding to avoid a circular dependency.
-  (let ((node (resolve-interface '(gnu packages node))))
-    (module-ref node 'node-lts)))
+  "Return the default Node package, resolved lazily."
+  (@* (gnu packages node) node-lts))
 
 (define* (lower name
                 #:key source inputs native-inputs outputs system target

@@ 68,61 68,43 @@
     ,@%default-gnu-imported-modules))
 
 (define (default-ocaml)
-  "Return the default OCaml package."
-
-  ;; Do not use `@' to avoid introducing circular dependencies.
-  (let ((module (resolve-interface '(gnu packages ocaml))))
-    (module-ref module 'ocaml)))
+  "Return the default OCaml package, resolved lazily."
+  (@* (gnu packages ocaml) ocaml))
 
 (define (default-findlib)
-  "Return the default OCaml-findlib package."
-
-  ;; Do not use `@' to avoid introducing circular dependencies.
-  (let ((module (resolve-interface '(gnu packages ocaml))))
-    (module-ref module 'ocaml-findlib)))
+  "Return the default OCaml-findlib package, resolved lazily."
+  (@* (gnu packages ocaml) ocaml-findlib))
 
 (define (default-dune-build-system)
-  "Return the dune-build-system."
-
-  ;; Do not use `@' to avoid introducing circular dependencies.
-  (let ((module (resolve-interface '(guix build-system dune))))
-    (module-ref module 'dune-build-system)))
+  "Return the dune-build-system, resolved lazily."
+  (@* (guix build-system dune) dune-build-system))
 
 (define (default-ocaml4.07)
-  (let ((ocaml (resolve-interface '(gnu packages ocaml))))
-    (module-ref ocaml 'ocaml-4.07)))
+  (@* (gnu packages ocaml) ocaml-4.07))
 
 (define (default-ocaml4.07-findlib)
-  (let ((module (resolve-interface '(gnu packages ocaml))))
-    (module-ref module 'ocaml4.07-findlib)))
+  (@* (gnu packages ocaml) ocaml4.07-findlib))
 
 (define (default-ocaml4.07-dune)
-  (let ((module (resolve-interface '(gnu packages ocaml))))
-    (module-ref module 'ocaml4.07-dune)))
+  (@* (gnu packages ocaml) ocaml4.07-dune))
 
 (define (default-ocaml4.09)
-  (let ((ocaml (resolve-interface '(gnu packages ocaml))))
-    (module-ref ocaml 'ocaml-4.09)))
+  (@* (gnu packages ocaml) ocaml-4.09))
 
 (define (default-ocaml4.09-findlib)
-  (let ((module (resolve-interface '(gnu packages ocaml))))
-    (module-ref module 'ocaml4.09-findlib)))
+  (@* (gnu packages ocaml) ocaml4.09-findlib))
 
 (define (default-ocaml4.09-dune)
-  (let ((module (resolve-interface '(gnu packages ocaml))))
-    (module-ref module 'ocaml4.09-dune)))
+  (@* (gnu packages ocaml) ocaml4.09-dune))
 
 (define (default-ocaml5.0)
-  (let ((ocaml (resolve-interface '(gnu packages ocaml))))
-    (module-ref ocaml 'ocaml-5.0)))
+  (@* (gnu packages ocaml) ocaml-5.0))
 
 (define (default-ocaml5.0-findlib)
-  (let ((module (resolve-interface '(gnu packages ocaml))))
-    (module-ref module 'ocaml5.0-findlib)))
+  (@* (gnu packages ocaml) ocaml5.0-findlib))
 
 (define (default-ocaml5.0-dune)
-  (let ((module (resolve-interface '(gnu packages ocaml))))
-    (module-ref module 'ocaml5.0-dune)))
+  (@* (gnu packages ocaml) ocaml5.0-dune))
 
 (define* (package-with-explicit-ocaml ocaml findlib dune old-prefix new-prefix
                                        #:key variant-property)

@@ 48,11 48,8 @@
     ,@%default-gnu-imported-modules))
 
 (define (default-perl)
-  "Return the default Perl package."
-
-  ;; Do not use `@' to avoid introducing circular dependencies.
-  (let ((module (resolve-interface '(gnu packages perl))))
-    (module-ref module 'perl)))
+  "Return the default Perl package, resolved lazily."
+  (@* (gnu packages perl) perl))
 
 (define* (lower name
                 #:key source inputs native-inputs outputs

@@ 51,15 51,13 @@
     ,@%python-build-system-modules))
 
 (define (default-python)
-  "Return the default Python package."
-  ;; Lazily resolve the binding to avoid a circular dependency.
-  (let ((python (resolve-interface '(gnu packages python))))
-    ;; We are using python-sans-pip-wrapper, because it does not contain
-    ;; setuptools. This allows us to skip the dependency on setuptools for
-    ;; packages which don’t need it. And it allows us to more easily swap
-    ;; out setuptools if a different version is required.
-    ;; Using python-toolchain here might cause dependency cycles.
-    (module-ref python 'python-sans-pip-wrapper)))
+  "Return the default Python package, resolved lazily."
+  ;; We are using python-sans-pip-wrapper, because it does not contain
+  ;; setuptools. This allows us to skip the dependency on setuptools for
+  ;; packages which don’t need it. And it allows us to more easily swap
+  ;; out setuptools if a different version is required.
+  ;; Using python-toolchain here might cause dependency cycles.
+  (@* (gnu packages python) python-sans-pip-wrapper))
 
 ;; TODO: On the next iteration of python-team, migrate the sanity-check to
 ;; importlib_metadata instead of setuptools.

@@ 62,11 62,8 @@
     ,@%cmake-build-system-modules))
 
 (define (default-qtbase)
-  "Return the default qtbase package."
-
-  ;; Do not use `@' to avoid introducing circular dependencies.
-  (let ((module (resolve-interface '(gnu packages qt))))
-    (module-ref module 'qtbase-5)))
+  "Return the default qtbase package, resolved lazily."
+  (@* (gnu packages qt) qtbase-5))
 
 ;; This barely is a copy from (guix build-system cmake), only adjusted to use
 ;; the variables defined here.

@@ 71,10 71,8 @@ release corresponding to NAME and VERSION."
     ,@%default-gnu-imported-modules))
 
 (define (default-r)
-  "Return the default R package."
-  ;; Lazily resolve the binding to avoid a circular dependency.
-  (let ((r-mod (resolve-interface '(gnu packages statistics))))
-    (module-ref r-mod 'r-minimal)))
+  "Return the default R package, resolved lazily."
+  (@* (gnu packages statistics) r-minimal))
 
 (define* (lower name
                 #:key source inputs native-inputs outputs system target

@@ 44,21 44,16 @@
     ,@%default-gnu-imported-modules))
 
 (define (default-rakudo)
-  "Return the default Rakudo package."
-
-  ;; Do not use `@' to avoid introducing circular dependencies.
-  (let ((module (resolve-interface '(gnu packages perl6))))
-    (module-ref module 'rakudo)))
+  "Return the default Rakudo package, resolved lazily."
+  (@* (gnu packages perl6) rakudo))
 
 (define (default-prove6)
-  "Return the default perl6-tap-harness package for tests."
-  (let ((module (resolve-interface '(gnu packages perl6))))
-    (module-ref module 'perl6-tap-harness)))
+  "Return the default perl6-tap-harness package for tests, resolved lazily."
+  (@* (gnu packages perl6) perl6-tap-harness))
 
 (define (default-zef)
   "Return the default perl6-zef package."
-  (let ((module (resolve-interface '(gnu packages perl6))))
-    (module-ref module 'perl6-zef)))
+  (@* (gnu packages perl6) perl6-zef))
 
 (define* (lower name
                 #:key source inputs native-inputs outputs

@@ 59,16 59,12 @@ and VERSION."
     ,@%default-gnu-imported-modules))
 
 (define (default-rebar3)
-  "Return the default Rebar3 package."
-  ;; Lazily resolve the binding to avoid a circular dependency.
-  (let ((erlang-mod (resolve-interface '(gnu packages erlang))))
-    (module-ref erlang-mod 'rebar3)))
+  "Return the default Rebar3 package, resolved lazily."
+  (@* (gnu packages erlang) rebar3))
 
 (define (default-erlang)
-  "Return the default Erlang package."
-  ;; Lazily resolve the binding to avoid a circular dependency.
-  (let ((erlang-mod (resolve-interface '(gnu packages erlang))))
-    (module-ref erlang-mod 'erlang)))
+  "Return the default Erlang package, resolved lazily."
+  (@* (gnu packages erlang) erlang))
 
 (define* (lower name
                 #:key source inputs native-inputs outputs system target

@@ 34,10 34,8 @@
             renpy-build-system))
 
 (define (default-renpy)
-  "Return the default Ren'py package."
-  ;; Lazily resolve the binding to avoid a circular dependency.
-  (let ((module (resolve-interface '(gnu packages game-development))))
-    (module-ref module 'renpy)))
+  "Return the default Ren'py package, resolved lazily."
+  (@* (gnu packages game-development) renpy))
 
 (define %renpy-build-system-modules
   ;; Build-side modules imported by default.

@@ 43,10 43,8 @@ NAME and VERSION."
     ,@%default-gnu-imported-modules))
 
 (define (default-ruby)
-  "Return the default Ruby package."
-  ;; Lazily resolve the binding to avoid a circular dependency.
-  (let ((ruby (resolve-interface '(gnu packages ruby))))
-    (module-ref ruby 'ruby)))
+  "Return the default Ruby package, resolved lazily."
+  (@* (gnu packages ruby) ruby))
 
 (define* (lower name
                 #:key source inputs native-inputs outputs system target

@@ 42,10 42,8 @@
     ,@%default-gnu-imported-modules))
 
 (define (default-scons)
-  "Return the default SCons package."
-  ;; Lazily resolve the binding to avoid a circular dependency.
-  (let ((build-tools (resolve-interface '(gnu packages build-tools))))
-    (module-ref build-tools 'scons)))
+  "Return the default SCons package, resolved lazily."
+  (@* (gnu packages build-tools) scons))
 
 (define* (lower name
                 #:key source inputs native-inputs outputs system target

@@ 54,16 54,12 @@
     ,@%default-gnu-imported-modules))
 
 (define (default-texlive-bin)
-  "Return the default texlive-bin package."
-  ;; Lazily resolve the binding to avoid a circular dependency.
-  (let ((tex-mod (resolve-interface '(gnu packages tex))))
-    (module-ref tex-mod 'texlive-bin)))
+  "Return the default texlive-bin package, resolved lazily."
+  (@* (gnu packages tex) texlive-bin))
 
 (define (texlive-latex-bin)
-  "Return the default texlive-latex-bin package."
-  ;; Lazily resolve the binding to avoid a circular dependency.
-  (let ((tex-mod (resolve-interface '(gnu packages tex))))
-    (module-ref tex-mod 'texlive-latex-bin)))
+  "Return the default texlive-latex-bin package, resolved lazily."
+  (@* (gnu packages tex) texlive-latex-bin))
 
 (define* (lower name
                 #:key

@@ 41,20 41,16 @@
 
 ;; Lazily resolve the bindings to avoid circular dependencies.
 (define (default-guile-json)
-  (let ((mod (resolve-interface '(gnu packages guile))))
-    (module-ref mod 'guile-json-4)))
+  (@* (gnu packages guile) guile-json-4))
 
 (define (default-node)
-  (let ((mod (resolve-interface '(gnu packages node))))
-    (module-ref mod 'node-lts)))
+  (@* (gnu packages node) node-lts))
 
 (define (default-tree-sitter)
-  (let ((mod (resolve-interface '(gnu packages tree-sitter))))
-    (module-ref mod 'tree-sitter)))
+  (@* (gnu packages tree-sitter) tree-sitter))
 
 (define (default-tree-sitter-cli)
-  (let ((mod (resolve-interface '(gnu packages tree-sitter))))
-    (module-ref mod 'tree-sitter-cli)))
+  (@* (gnu packages tree-sitter) tree-sitter-cli))
 
 (define* (lower name
                 #:key source inputs native-inputs outputs system target

@@ 45,15 45,12 @@
     ,@%copy-build-system-modules))
 
 (define (default-vim)
-  "Return the default Vim package."
-  ;; Lazily resolve the binding to avoid a circular dependency.
-  (let ((vim (resolve-interface '(gnu packages vim))))
-    (module-ref vim 'vim)))
+  "Return the default Vim package, resolved lazily."
+  (@* (gnu packages vim) vim))
 
 (define (default-neovim)
-  "Return the default Neovim package."
-  (let ((vim (resolve-interface '(gnu packages vim))))
-    (module-ref vim 'neovim)))
+  "Return the default Neovim package, resolved lazily."
+  (@* (gnu packages vim) neovim))
 
 (define* (lower name
                 #:key source

@@ 32,10 32,8 @@
 
 
 (define (default-zig)
-  "Return the default zig package."
-  ;; Lazily resolve the binding to avoid a circular dependency.
-  (let ((zig (resolve-interface '(gnu packages zig))))
-    (module-ref zig 'zig)))
+  "Return the default zig package, resolved lazily."
+  (@* (gnu packages zig) zig))
 
 (define %zig-build-system-modules
   ;; Build-side modules imported by default.