diff mbox series

[bug#36131] Add Multiple Common Lisp Packages

Message ID 87pnnpey6c.fsf@gmail.com
State Accepted
Headers show
Series [bug#36131] Add Multiple Common Lisp Packages | expand

Checks

Context Check Description
cbaines/applying patch fail Apply failed

Commit Message

Katherine Cox-Buday June 8, 2019, 12:08 a.m. UTC

Comments

Ludovic Courtès June 25, 2019, 3:39 p.m. UTC | #1 
Hello Katherine,

Thanks for this patch series!

I’ve applied all of them until #7 included (fare-utils), fixing minor
issues that ‘guix lint’ reported.

I’d be grateful if someone reading this could do their share of
review/apply work!  :-)

I noticed that ‘ecl-hu.dwim.asdf’ and ‘ecl-rt’ fail to build, so I
couldn’t test all the ‘ecl-*’ variants.  Could you take a look at these
two packages?

More generally, does it make sense to have ECL variants for each and
every package?  Or should we trim that down?  I’m under the impression
that ECL is typically used with rather small code bases since it’s meant
to be embedded, but then I’m not a Common Lisper.

Thanks!

Ludo’.
Katherine Cox-Buday June 25, 2019, 5:56 p.m. UTC | #2 
Ludovic Courtès <ludo@gnu.org> writes:

> Hello Katherine,
>
> Thanks for this patch series!

You bet! Power to the Guix :)

> I’ve applied all of them until #7 included (fare-utils), fixing minor
> issues that ‘guix lint’ reported.

Thank you, and sorry for the linting issues. I get busy and then rushed
and I make these stupid mistakes.

> I’d be grateful if someone reading this could do their share of
> review/apply work!  :-)
>
> I noticed that ‘ecl-hu.dwim.asdf’ and ‘ecl-rt’ fail to build, so I
> couldn’t test all the ‘ecl-*’ variants.  Could you take a look at these
> two packages?

I focused on the SBCL packages and then retroactively went back and
added all the ECL packages, trying to be a good citizen. In retrospect,
this was not a good idea. Common Lisp code is not guaranteed to work
across runtimes.

If you're OK with it, I would just go ahead and delete any ECL package
that doesn't immediately work. I can do this myself, but I'm currently
on holiday and won't be able to take a look for another week and a half.

> More generally, does it make sense to have ECL variants for each and
> every package?  Or should we trim that down?  I’m under the impression
> that ECL is typically used with rather small code bases since it’s meant
> to be embedded, but then I’m not a Common Lisper.

I think ECL is used outside embedded contexts, but I haven't found a
reason to use it yet. If I remember correctly, I think one compiles
faster than the other, and the other runs faster, so some people switch
between the two when developing and then deploying.
Ludovic Courtès June 26, 2019, 8:56 a.m. UTC | #3 
Hello,

Cc’ing Andy as the original author of all this.  :-)

Katherine Cox-Buday <cox.katherine.e@gmail.com> skribis:

> Ludovic Courtès <ludo@gnu.org> writes:

[...]

>> I noticed that ‘ecl-hu.dwim.asdf’ and ‘ecl-rt’ fail to build, so I
>> couldn’t test all the ‘ecl-*’ variants.  Could you take a look at these
>> two packages?
>
> I focused on the SBCL packages and then retroactively went back and
> added all the ECL packages, trying to be a good citizen. In retrospect,
> this was not a good idea. Common Lisp code is not guaranteed to work
> across runtimes.
>
> If you're OK with it, I would just go ahead and delete any ECL package
> that doesn't immediately work. I can do this myself, but I'm currently
> on holiday and won't be able to take a look for another week and a half.

Sure, removing packages that don’t build sounds good to me.  Andy, WDYT?

>> More generally, does it make sense to have ECL variants for each and
>> every package?  Or should we trim that down?  I’m under the impression
>> that ECL is typically used with rather small code bases since it’s meant
>> to be embedded, but then I’m not a Common Lisper.
>
> I think ECL is used outside embedded contexts, but I haven't found a
> reason to use it yet. If I remember correctly, I think one compiles
> faster than the other, and the other runs faster, so some people switch
> between the two when developing and then deploying.

OK, I see.

Thanks for explaining!

Ludo’.
Ludovic Courtès July 2, 2019, 3:51 p.m. UTC | #4 
Hi again,

Katherine Cox-Buday <cox.katherine.e@gmail.com> skribis:

>>From b62c757389b1b6eee909c7c121d4aef3515b17b8 Mon Sep 17 00:00:00 2001
> From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
> Date: Fri, 7 Jun 2019 15:24:58 -0500
> Subject: [PATCH 08/15] gnu: Add trivial-utf-8.
>
> * gnu/packages/lisp.scm (trivial-utf-8): New variable.

Applied with synopsis/description adjustments.

>>From 2c56db1e5ea59dd82e07065515d1a576255a88cc Mon Sep 17 00:00:00 2001
> From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
> Date: Fri, 7 Jun 2019 15:48:30 -0500
> Subject: [PATCH 09/15] gnu: Add antik.
>
> * gnu/packages/lisp.scm (antik): New variable.

This commit log does not mention the other variables that are added:
quite a few packages are added by this patch.  Could you turn it into
several patches?

Also, could you please run ‘guix lint’ on all the remaining packages and
address any issues, in particular descriptions/synopses (info "(guix)
Synopses and Descriptions")?

Also perhaps omit the ‘ecl-’ variants if you deem them unnecessary.

Hopefully that’ll make the whole review/apply process smoother.  :-)

Thanks in advance,
Ludo’.
Guillaume Le Vaillant Jan. 3, 2020, 8:14 p.m. UTC | #5 
Hi,

I reviewed and pushed the remaining patches (9 to 15), after splitting
in several commits or fixing things when necessary. I also removed the
packages for ECL that didn't build.
Ludovic Courtès Jan. 6, 2020, 9:34 a.m. UTC | #6 
Hi Guillaume,

Guillaume Le Vaillant <glv@posteo.net> skribis:

> I reviewed and pushed the remaining patches (9 to 15), after splitting
> in several commits or fixing things when necessary. I also removed the
> packages for ECL that didn't build.

Thanks a lot for taking care of these patches, this was long overdue!

Ludo’.
Katherine Cox-Buday Jan. 6, 2020, 12:06 p.m. UTC | #7 
Yes, thank you so much. I apologize for letting these linger.

On Mon, Jan 6, 2020, 03:34 Ludovic Courtès <ludo@gnu.org> wrote:

> Hi Guillaume,
>
> Guillaume Le Vaillant <glv@posteo.net> skribis:
>
> > I reviewed and pushed the remaining patches (9 to 15), after splitting
> > in several commits or fixing things when necessary. I also removed the
> > packages for ECL that didn't build.
>
> Thanks a lot for taking care of these patches, this was long overdue!
>
> Ludo’.
>
diff mbox series

Patch

From e563a4232336ff8e777e946cd093122c356e51da Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 7 Jun 2019 17:24:08 -0500
Subject: [PATCH 15/15] gnu: Add cl-ana.

* gnu/packages/lisp.scm (cl-ana): New variable.
---
 gnu/packages/lisp.scm | 1146 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 1146 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index fa67417f90..d8423907e3 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -6161,3 +6161,1149 @@  sacrificing much in the way of power.")
 
 (define-public ecl-external-program
   (sbcl-package->ecl-package sbcl-external-program))
+
+(define-public sbcl-cl-ana-boot0
+  (let ((commit "fa7cee4c50aa1c859652813049ba0da7c18a0df9")
+        (revision "1"))
+    (package
+     (name "sbcl-cl-ana-boot0")
+     (version (git-version "0.0.0" revision commit))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/ghollisjr/cl-ana.git")
+             (commit commit)))
+       (file-name (git-file-name name version))
+       (sha256
+        (base32
+         "0mr47l57m276dbpap7irr4fcnk5fgknhf6mgv4043s8h73amk5qh"))))
+     (build-system asdf-build-system/sbcl)
+     (synopsis
+      "Free (GPL) Common Lisp data analysis library with emphasis on
+modularity and conceptual clarity.")
+     (description
+      "cl-ana is a free (GPL) data analysis library in Common Lisp
+providing tabular & binned data analysis along with nonlinear least
+squares fitting & visualization.")
+     (home-page "https://github.com/ghollisjr/cl-ana")
+     (license license:gpl3))))
+
+(define-public sbcl-cl-ana.pathname-utils
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.pathname-utils")
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "pathname-utils/cl-ana.pathname-utils.asd")
+       ((#:asd-system-name _ #f) "cl-ana.pathname-utils")))))
+
+(define-public cl-cl-ana.pathname-utils
+  (sbcl-package->cl-source-package sbcl-cl-ana.pathname-utils))
+
+(define-public ecl-cl-ana.pathname-utils
+  (sbcl-package->ecl-package sbcl-cl-ana.pathname-utils))
+
+(define-public sbcl-cl-ana.package-utils
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.package-utils")
+    (inputs
+     `(("sbcl-alexandria" ,sbcl-alexandria)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "package-utils/cl-ana.package-utils.asd")
+       ((#:asd-system-name _ #f) "cl-ana.package-utils")))))
+
+(define-public cl-cl-ana.package-utils
+  (sbcl-package->cl-source-package sbcl-cl-ana.package-utils))
+
+(define-public ecl-cl-ana.package-utils
+  (sbcl-package->ecl-package sbcl-cl-ana.package-utils))
+
+(define-public sbcl-cl-ana.string-utils
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.string-utils")
+    (inputs
+     `(("sbcl-split-sequence" ,sbcl-split-sequence)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "string-utils/cl-ana.string-utils.asd")
+       ((#:asd-system-name _ #f) "cl-ana.string-utils")))))
+
+(define-public cl-cl-ana.string-utils
+  (sbcl-package->cl-source-package sbcl-cl-ana.string-utils))
+
+(define-public ecl-cl-ana.string-utils
+  (sbcl-package->ecl-package sbcl-cl-ana.string-utils))
+
+(define-public sbcl-cl-ana.functional-utils
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.functional-utils")
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "functional-utils/cl-ana.functional-utils.asd")
+       ((#:asd-system-name _ #f) "cl-ana.functional-utils")))))
+
+(define-public cl-cl-ana.functional-utils
+  (sbcl-package->cl-source-package sbcl-cl-ana.functional-utils))
+
+(define-public ecl-cl-ana.functional-utils
+  (sbcl-package->ecl-package sbcl-cl-ana.functional-utils))
+
+(define-public sbcl-cl-ana.list-utils
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.list-utils")
+    (inputs
+     `(("sbcl-alexandria" ,sbcl-alexandria)
+       ("sbcl-cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
+       ("sbcl-cl-ana.string-utils" ,sbcl-cl-ana.string-utils)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "list-utils/cl-ana.list-utils.asd")
+       ((#:asd-system-name _ #f) "cl-ana.list-utils")))))
+
+(define-public cl-cl-ana.list-utils
+  (sbcl-package->cl-source-package sbcl-cl-ana.list-utils))
+
+(define-public ecl-cl-ana.list-utils
+  (sbcl-package->ecl-package sbcl-cl-ana.list-utils))
+
+(define-public sbcl-cl-ana.generic-math
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.generic-math")
+    (inputs
+     `(("sbcl-cl-ana.package-utils" ,sbcl-cl-ana.package-utils)
+       ("sbcl-cl-ana.list-utils" ,sbcl-cl-ana.list-utils)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "generic-math/cl-ana.generic-math.asd")
+       ((#:asd-system-name _ #f) "cl-ana.generic-math")))))
+
+(define-public cl-cl-ana.generic-math
+  (sbcl-package->cl-source-package sbcl-cl-ana.generic-math))
+
+(define-public ecl-cl-ana.generic-math
+  (sbcl-package->ecl-package sbcl-cl-ana.generic-math))
+
+(define-public sbcl-cl-ana.math-functions
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.math-functions")
+    (inputs
+     `(("sbcl-cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
+       ("sbcl-gsll" ,sbcl-gsll)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "math-functions/cl-ana.math-functions.asd")
+       ((#:asd-system-name _ #f) "cl-ana.math-functions")))))
+
+(define-public cl-cl-ana.math-functions
+  (sbcl-package->cl-source-package sbcl-cl-ana.math-functions))
+
+(define-public ecl-cl-ana.math-functions
+  (sbcl-package->ecl-package sbcl-cl-ana.math-functions))
+
+(define-public sbcl-cl-ana.calculus
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.calculus")
+    (inputs
+     `(("sbcl-cl-ana.generic-math" ,sbcl-cl-ana.generic-math)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "calculus/cl-ana.calculus.asd")
+       ((#:asd-system-name _ #f) "cl-ana.calculus")))))
+
+(define-public cl-cl-ana.calculus
+  (sbcl-package->cl-source-package sbcl-cl-ana.calculus))
+
+(define-public ecl-cl-ana.calculus
+  (sbcl-package->ecl-package sbcl-cl-ana.calculus))
+
+(define-public sbcl-cl-ana.symbol-utils
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.symbol-utils")
+    (inputs
+     `(("sbcl-cl-ana.list-utils" ,sbcl-cl-ana.list-utils)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "symbol-utils/cl-ana.symbol-utils.asd")
+       ((#:asd-system-name _ #f) "cl-ana.symbol-utils")))))
+
+(define-public cl-cl-ana.symbol-utils
+  (sbcl-package->cl-source-package sbcl-cl-ana.symbol-utils))
+
+(define-public ecl-cl-ana.symbol-utils
+  (sbcl-package->ecl-package sbcl-cl-ana.symbol-utils))
+
+(define-public sbcl-cl-ana.macro-utils
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.macro-utils")
+    (inputs
+     `(("sbcl-split-sequence" ,sbcl-split-sequence)
+       ("sbcl-alexandria" ,sbcl-alexandria)
+       ("sbcl-cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
+       ("sbcl-cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
+       ("sbcl-cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "macro-utils/cl-ana.macro-utils.asd")
+       ((#:asd-system-name _ #f) "cl-ana.macro-utils")))))
+
+(define-public cl-cl-ana.macro-utils
+  (sbcl-package->cl-source-package sbcl-cl-ana.macro-utils))
+
+(define-public ecl-cl-ana.macro-utils
+  (sbcl-package->ecl-package sbcl-cl-ana.macro-utils))
+
+(define-public sbcl-cl-ana.binary-tree
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.binary-tree")
+    (inputs
+     `(("sbcl-cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
+       ("sbcl-cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
+       ("sbcl-cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "binary-tree/cl-ana.binary-tree.asd")
+       ((#:asd-system-name _ #f) "cl-ana.binary-tree")))))
+
+(define-public cl-cl-ana.binary-tree
+  (sbcl-package->cl-source-package sbcl-cl-ana.binary-tree))
+
+(define-public ecl-cl-ana.binary-tree
+  (sbcl-package->ecl-package sbcl-cl-ana.binary-tree))
+
+(define-public sbcl-cl-ana.tensor
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.tensor")
+    (inputs
+     `(("sbcl-alexandria" ,sbcl-alexandria)
+       ("sbcl-cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
+       ("sbcl-cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
+       ("sbcl-cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
+       ("sbcl-cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "tensor/cl-ana.tensor.asd")
+       ((#:asd-system-name _ #f) "cl-ana.tensor")))))
+
+(define-public cl-cl-ana.tensor
+  (sbcl-package->cl-source-package sbcl-cl-ana.tensor))
+
+(define-public ecl-cl-ana.tensor
+  (sbcl-package->ecl-package sbcl-cl-ana.tensor))
+
+(define-public sbcl-cl-ana.error-propogation
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.error-propogation")
+    (inputs
+     `(("sbcl-cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
+       ("sbcl-cl-ana.math-functions" ,sbcl-cl-ana.math-functions)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "error-propogation/cl-ana.error-propogation.asd")
+       ((#:asd-system-name _ #f) "cl-ana.error-propogation")))))
+
+(define-public cl-cl-ana.error-propogation
+  (sbcl-package->cl-source-package sbcl-cl-ana.error-propogation))
+
+(define-public ecl-cl-ana.error-propogation
+  (sbcl-package->ecl-package sbcl-cl-ana.error-propogation))
+
+(define-public sbcl-cl-ana.quantity
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.quantity")
+    (inputs
+     `(("sbcl-alexandria" ,sbcl-alexandria)
+       ("sbcl-cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
+       ("sbcl-cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
+       ("sbcl-cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
+       ("sbcl-cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
+       ("sbcl-cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "quantity/cl-ana.quantity.asd")
+       ((#:asd-system-name _ #f) "cl-ana.quantity")))))
+
+(define-public cl-cl-ana.quantity
+  (sbcl-package->cl-source-package sbcl-cl-ana.quantity))
+
+(define-public ecl-cl-ana.quantity
+  (sbcl-package->ecl-package sbcl-cl-ana.quantity))
+
+(define-public sbcl-cl-ana.table
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.table")
+    (inputs
+     `(("sbcl-alexandria" ,sbcl-alexandria)
+       ("sbcl-cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
+       ("sbcl-cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
+       ("sbcl-cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
+       ("sbcl-cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
+       ("sbcl-cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "table/cl-ana.table.asd")
+       ((#:asd-system-name _ #f) "cl-ana.table")))))
+
+(define-public cl-cl-ana.table
+  (sbcl-package->cl-source-package sbcl-cl-ana.table))
+
+(define-public ecl-cl-ana.table
+  (sbcl-package->ecl-package sbcl-cl-ana.table))
+
+(define-public sbcl-cl-ana.table-utils
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.table-utils")
+    (inputs
+     `(("sbcl-cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
+       ("sbcl-cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
+       ("sbcl-cl-ana.table" ,sbcl-cl-ana.table)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "table-utils/cl-ana.table-utils.asd")
+       ((#:asd-system-name _ #f) "cl-ana.table-utils")))))
+
+(define-public cl-cl-ana.table-utils
+  (sbcl-package->cl-source-package sbcl-cl-ana.table-utils))
+
+(define-public ecl-cl-ana.table-utils
+  (sbcl-package->ecl-package sbcl-cl-ana.table-utils))
+
+(define-public sbcl-cl-ana.hdf-cffi
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.hdf-cffi")
+    (inputs
+     `(("sbcl-cffi" ,sbcl-cffi)
+       ("hdf5" ,hdf5-parallel-openmpi)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "hdf-cffi/cl-ana.hdf-cffi.asd")
+       ((#:asd-system-name _ #f) "cl-ana.hdf-cffi")
+       ((#:phases phases '%standard-phases)
+        `(modify-phases ,phases
+           (add-after 'unpack 'fix-paths
+             (lambda* (#:key inputs #:allow-other-keys)
+               (substitute* "hdf-cffi/hdf-cffi.lisp"
+                 (("/usr/lib/i386-linux-gnu/hdf5/serial/libhdf5.so")
+                  (string-append
+                   (assoc-ref inputs "hdf5")
+                   "/lib/libhdf5.so")))))))))))
+
+(define-public cl-cl-ana.hdf-cffi
+  (sbcl-package->cl-source-package sbcl-cl-ana.hdf-cffi))
+
+(define-public ecl-cl-ana.hdf-cffi
+  (sbcl-package->ecl-package sbcl-cl-ana.hdf-cffi))
+
+(define-public sbcl-cl-ana.int-char
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.int-char")
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "int-char/cl-ana.int-char.asd")
+       ((#:asd-system-name _ #f) "cl-ana.int-char")))))
+
+(define-public cl-cl-ana.int-char
+  (sbcl-package->cl-source-package sbcl-cl-ana.int-char))
+
+(define-public ecl-cl-ana.int-char
+  (sbcl-package->ecl-package sbcl-cl-ana.int-char))
+
+(define-public sbcl-cl-ana.memoization
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.memoization")
+    (inputs
+     `(("sbcl-alexandria" ,sbcl-alexandria)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "memoization/cl-ana.memoization.asd")
+       ((#:asd-system-name _ #f) "cl-ana.memoization")))))
+
+(define-public cl-cl-ana.memoization
+  (sbcl-package->cl-source-package sbcl-cl-ana.memoization))
+
+(define-public ecl-cl-ana.memoization
+  (sbcl-package->ecl-package sbcl-cl-ana.memoization))
+
+(define-public sbcl-cl-ana.typespec
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.typespec")
+    (inputs
+     `(("sbcl-alexandria" ,sbcl-alexandria)
+       ("sbcl-cffi" ,sbcl-cffi)
+       ("sbcl-cl-ana.int-char" ,sbcl-cl-ana.int-char)
+       ("sbcl-cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
+       ("sbcl-cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
+       ("sbcl-cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
+       ("sbcl-cl-ana.tensor" ,sbcl-cl-ana.tensor)
+       ("sbcl-cl-ana.memoization" ,sbcl-cl-ana.memoization)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "typespec/cl-ana.typespec.asd")
+       ((#:asd-system-name _ #f) "cl-ana.typespec")))))
+
+(define-public cl-cl-ana.typespec
+  (sbcl-package->cl-source-package sbcl-cl-ana.typespec))
+
+(define-public ecl-cl-ana.typespec
+  (sbcl-package->ecl-package sbcl-cl-ana.typespec))
+
+(define-public sbcl-cl-ana.hdf-typespec
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.hdf-typespec")
+    (inputs
+     `(("sbcl-cffi" ,sbcl-cffi)
+       ("sbcl-alexandria" ,sbcl-alexandria)
+       ("sbcl-cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
+       ("sbcl-cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
+       ("sbcl-cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
+       ("sbcl-cl-ana.memoization" ,sbcl-cl-ana.memoization)
+       ("sbcl-cl-ana.hdf-cffi" ,sbcl-cl-ana.hdf-cffi)
+       ("sbcl-cl-ana.typespec" ,sbcl-cl-ana.typespec)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "hdf-typespec/cl-ana.hdf-typespec.asd")
+       ((#:asd-system-name _ #f) "cl-ana.hdf-typespec")))))
+
+(define-public cl-cl-ana.hdf-typespec
+  (sbcl-package->cl-source-package sbcl-cl-ana.hdf-typespec))
+
+(define-public ecl-cl-ana.hdf-typespec
+  (sbcl-package->ecl-package sbcl-cl-ana.hdf-typespec))
+
+(define-public sbcl-cl-ana.hdf-utils
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.hdf-utils")
+    (inputs
+     `(("sbcl-cffi" ,sbcl-cffi)
+       ("sbcl-alexandria" ,sbcl-alexandria)
+       ("sbcl-cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
+       ("sbcl-cl-ana.memoization" ,sbcl-cl-ana.memoization)
+       ("sbcl-cl-ana.typespec" ,sbcl-cl-ana.typespec)
+       ("sbcl-cl-ana.hdf-typespec" ,sbcl-cl-ana.hdf-typespec)
+       ("sbcl-cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
+       ("sbcl-cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
+       ("sbcl-cl-ana.hdf-cffi" ,sbcl-cl-ana.hdf-cffi)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "hdf-utils/cl-ana.hdf-utils.asd")
+       ((#:asd-system-name _ #f) "cl-ana.hdf-utils")))))
+
+(define-public cl-cl-ana.hdf-utils
+  (sbcl-package->cl-source-package sbcl-cl-ana.hdf-utils))
+
+(define-public ecl-cl-ana.hdf-utils
+  (sbcl-package->ecl-package sbcl-cl-ana.hdf-utils))
+
+(define-public sbcl-cl-ana.typed-table
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.typed-table")
+    (inputs
+     `(("sbcl-alexandria" ,sbcl-alexandria)
+       ("sbcl-cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
+       ("sbcl-cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
+       ("sbcl-cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
+       ("sbcl-cl-ana.table" ,sbcl-cl-ana.table)
+       ("sbcl-cl-ana.typespec" ,sbcl-cl-ana.typespec)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "typed-table/cl-ana.typed-table.asd")
+       ((#:asd-system-name _ #f) "cl-ana.typed-table")))))
+
+(define-public cl-cl-ana.typed-table
+  (sbcl-package->cl-source-package sbcl-cl-ana.typed-table))
+
+(define-public ecl-cl-ana.typed-table
+  (sbcl-package->ecl-package sbcl-cl-ana.typed-table))
+
+(define-public sbcl-cl-ana.hdf-table
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.hdf-table")
+    (inputs
+     `(("sbcl-cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
+       ("sbcl-cl-ana.hdf-cffi" ,sbcl-cl-ana.hdf-cffi)
+       ("sbcl-cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
+       ("sbcl-cl-ana.table" ,sbcl-cl-ana.table)
+       ("sbcl-cl-ana.typed-table" ,sbcl-cl-ana.typed-table)
+       ("sbcl-cl-ana.typespec" ,sbcl-cl-ana.typespec)
+       ("sbcl-cl-ana.hdf-typespec" ,sbcl-cl-ana.hdf-typespec)
+       ("sbcl-cl-ana.binary-tree" ,sbcl-cl-ana.binary-tree)
+       ("sbcl-cl-ana.memoization" ,sbcl-cl-ana.memoization)
+       ("sbcl-alexandria" ,sbcl-alexandria)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "hdf-table/cl-ana.hdf-table.asd")
+       ((#:asd-system-name _ #f) "cl-ana.hdf-table")))))
+
+(define-public cl-cl-ana.hdf-table
+  (sbcl-package->cl-source-package sbcl-cl-ana.hdf-table))
+
+(define-public ecl-cl-ana.hdf-table
+  (sbcl-package->ecl-package sbcl-cl-ana.hdf-table))
+
+(define-public sbcl-cl-ana.gsl-cffi
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.gsl-cffi")
+    (inputs
+     `(("sbcl-cffi" ,sbcl-cffi)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "gsl-cffi/cl-ana.gsl-cffi.asd")
+       ((#:asd-system-name _ #f) "cl-ana.gsl-cffi")))))
+
+(define-public cl-cl-ana.gsl-cffi
+  (sbcl-package->cl-source-package sbcl-cl-ana.gsl-cffi))
+
+(define-public ecl-cl-ana.gsl-cffi
+  (sbcl-package->ecl-package sbcl-cl-ana.gsl-cffi))
+
+(define-public sbcl-cl-ana.ntuple-table
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.ntuple-table")
+    (inputs
+     `(("sbcl-cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
+       ("sbcl-cffi" ,sbcl-cffi)
+       ("sbcl-gsll" ,sbcl-gsll)
+       ("sbcl-cl-ana.gsl-cffi" ,sbcl-cl-ana.gsl-cffi)
+       ("sbcl-cl-ana.table" ,sbcl-cl-ana.table)
+       ("sbcl-cl-ana.typed-table" ,sbcl-cl-ana.typed-table)
+       ("sbcl-cl-ana.typespec" ,sbcl-cl-ana.typespec)
+       ("sbcl-alexandria" ,sbcl-alexandria)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "ntuple-table/cl-ana.ntuple-table.asd")
+       ((#:asd-system-name _ #f) "cl-ana.ntuple-table")))))
+
+(define-public cl-cl-ana.ntuple-table
+  (sbcl-package->cl-source-package sbcl-cl-ana.ntuple-table))
+
+(define-public ecl-cl-ana.ntuple-table
+  (sbcl-package->ecl-package sbcl-cl-ana.ntuple-table))
+
+(define-public sbcl-cl-ana.csv-table
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.csv-table")
+    (inputs
+     `(("sbcl-antik" ,sbcl-antik)
+       ("sbcl-iterate" ,sbcl-iterate)
+       ("sbcl-alexandria" ,sbcl-alexandria)
+       ("sbcl-cl-csv" ,sbcl-cl-csv)
+       ("sbcl-cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
+       ("sbcl-cl-ana.table" ,sbcl-cl-ana.table)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "csv-table/cl-ana.csv-table.asd")
+       ((#:asd-system-name _ #f) "cl-ana.csv-table")))))
+
+(define-public cl-cl-ana.csv-table
+  (sbcl-package->cl-source-package sbcl-cl-ana.csv-table))
+
+(define-public ecl-cl-ana.csv-table
+  (sbcl-package->ecl-package sbcl-cl-ana.csv-table))
+
+(define-public sbcl-cl-ana.reusable-table
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.reusable-table")
+    (inputs
+     `(("sbcl-cl-ana.table" ,sbcl-cl-ana.table)
+       ("sbcl-alexandria" ,sbcl-alexandria)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "reusable-table/cl-ana.reusable-table.asd")
+       ((#:asd-system-name _ #f) "cl-ana.reusable-table")))))
+
+(define-public cl-cl-ana.reusable-table
+  (sbcl-package->cl-source-package sbcl-cl-ana.reusable-table))
+
+(define-public ecl-cl-ana.reusable-table
+  (sbcl-package->ecl-package sbcl-cl-ana.reusable-table))
+
+(define-public sbcl-cl-ana.linear-algebra
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.linear-algebra")
+    (inputs
+     `(("sbcl-cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
+       ("sbcl-cl-ana.tensor" ,sbcl-cl-ana.tensor)
+       ("sbcl-cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
+       ("sbcl-cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
+       ("sbcl-gsll" ,sbcl-gsll)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "linear-algebra/cl-ana.linear-algebra.asd")
+       ((#:asd-system-name _ #f) "cl-ana.linear-algebra")))))
+
+(define-public cl-cl-ana.linear-algebra
+  (sbcl-package->cl-source-package sbcl-cl-ana.linear-algebra))
+
+(define-public ecl-cl-ana.linear-algebra
+  (sbcl-package->ecl-package sbcl-cl-ana.linear-algebra))
+
+(define-public sbcl-cl-ana.lorentz
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.lorentz")
+    (inputs
+     `(("sbcl-cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
+       ("sbcl-cl-ana.linear-algebra" ,sbcl-cl-ana.linear-algebra)
+       ("sbcl-cl-ana.tensor" ,sbcl-cl-ana.tensor)
+       ("sbcl-iterate" ,sbcl-iterate)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "lorentz/cl-ana.lorentz.asd")
+       ((#:asd-system-name _ #f) "cl-ana.lorentz")))))
+
+(define-public cl-cl-ana.lorentz
+  (sbcl-package->cl-source-package sbcl-cl-ana.lorentz))
+
+(define-public ecl-cl-ana.lorentz
+  (sbcl-package->ecl-package sbcl-cl-ana.lorentz))
+
+(define-public sbcl-cl-ana.clos-utils
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.clos-utils")
+    (inputs
+     `(("sbcl-closer-mop" ,sbcl-closer-mop)
+       ("sbcl-cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
+       ("sbcl-cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
+       ("sbcl-cl-ana.tensor" ,sbcl-cl-ana.tensor)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "clos-utils/cl-ana.clos-utils.asd")
+       ((#:asd-system-name _ #f) "cl-ana.clos-utils")))))
+
+(define-public cl-cl-ana.clos-utils
+  (sbcl-package->cl-source-package sbcl-cl-ana.clos-utils))
+
+(define-public ecl-cl-ana.clos-utils
+  (sbcl-package->ecl-package sbcl-cl-ana.clos-utils))
+
+(define-public sbcl-cl-ana.hash-table-utils
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.hash-table-utils")
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "hash-table-utils/cl-ana.hash-table-utils.asd")
+       ((#:asd-system-name _ #f) "cl-ana.hash-table-utils")))))
+
+(define-public cl-cl-ana.hash-table-utils
+  (sbcl-package->cl-source-package sbcl-cl-ana.hash-table-utils))
+
+(define-public ecl-cl-ana.hash-table-utils
+  (sbcl-package->ecl-package sbcl-cl-ana.hash-table-utils))
+
+(define-public sbcl-cl-ana.map
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.map")
+    (inputs
+     `(("sbcl-cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "map/cl-ana.map.asd")
+       ((#:asd-system-name _ #f) "cl-ana.map")))))
+
+(define-public cl-cl-ana.map
+  (sbcl-package->cl-source-package sbcl-cl-ana.map))
+
+(define-public ecl-cl-ana.map
+  (sbcl-package->ecl-package sbcl-cl-ana.map))
+
+(define-public sbcl-cl-ana.fitting
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.fitting")
+    (inputs
+     `(("sbcl-gsll" ,sbcl-gsll)
+       ("sbcl-alexandria" ,sbcl-alexandria)
+       ("sbcl-cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
+       ("sbcl-cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
+       ("sbcl-cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
+       ("sbcl-cl-ana.map" ,sbcl-cl-ana.map)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "fitting/cl-ana.fitting.asd")
+       ((#:asd-system-name _ #f) "cl-ana.fitting")))))
+
+(define-public cl-cl-ana.fitting
+  (sbcl-package->cl-source-package sbcl-cl-ana.fitting))
+
+(define-public ecl-cl-ana.fitting
+  (sbcl-package->ecl-package sbcl-cl-ana.fitting))
+
+(define-public sbcl-cl-ana.histogram
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.histogram")
+    (inputs
+     `(("sbcl-iterate" ,sbcl-iterate)
+       ("sbcl-alexandria" ,sbcl-alexandria)
+       ("sbcl-cl-ana.clos-utils" ,sbcl-cl-ana.clos-utils)
+       ("sbcl-cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
+       ("sbcl-cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
+       ("sbcl-cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
+       ("sbcl-cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
+       ("sbcl-cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
+       ("sbcl-cl-ana.binary-tree" ,sbcl-cl-ana.binary-tree)
+       ("sbcl-cl-ana.map" ,sbcl-cl-ana.map)
+       ("sbcl-cl-ana.tensor" ,sbcl-cl-ana.tensor)
+       ("sbcl-cl-ana.fitting" ,sbcl-cl-ana.fitting)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "histogram/cl-ana.histogram.asd")
+       ((#:asd-system-name _ #f) "cl-ana.histogram")))))
+
+(define-public cl-cl-ana.histogram
+  (sbcl-package->cl-source-package sbcl-cl-ana.histogram))
+
+(define-public ecl-cl-ana.histogram
+  (sbcl-package->ecl-package sbcl-cl-ana.histogram))
+
+(define-public sbcl-cl-ana.file-utils
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.file-utils")
+    (inputs
+     `(("sbcl-external-program" ,sbcl-external-program)
+       ("sbcl-split-sequence" ,sbcl-split-sequence)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "file-utils/cl-ana.file-utils.asd")
+       ((#:asd-system-name _ #f) "cl-ana.file-utils")))))
+
+(define-public cl-cl-ana.file-utils
+  (sbcl-package->cl-source-package sbcl-cl-ana.file-utils))
+
+(define-public ecl-cl-ana.file-utils
+  (sbcl-package->ecl-package sbcl-cl-ana.file-utils))
+
+(define-public sbcl-cl-ana.statistics
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.statistics")
+    (inputs
+     `(("sbcl-cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
+       ("sbcl-cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
+       ("sbcl-cl-ana.map" ,sbcl-cl-ana.map)
+       ("sbcl-cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
+       ("sbcl-cl-ana.histogram" ,sbcl-cl-ana.histogram)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "statistics/cl-ana.statistics.asd")
+       ((#:asd-system-name _ #f) "cl-ana.statistics")))))
+
+(define-public cl-cl-ana.statistics
+  (sbcl-package->cl-source-package sbcl-cl-ana.statistics))
+
+(define-public ecl-cl-ana.statistics
+  (sbcl-package->ecl-package sbcl-cl-ana.statistics))
+
+(define-public sbcl-cl-ana.gnuplot-interface
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.gnuplot-interface")
+    (inputs
+     `(("sbcl-external-program" ,sbcl-external-program)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "gnuplot-interface/cl-ana.gnuplot-interface.asd")
+       ((#:asd-system-name _ #f) "cl-ana.gnuplot-interface")))))
+
+(define-public cl-cl-ana.gnuplot-interface
+  (sbcl-package->cl-source-package sbcl-cl-ana.gnuplot-interface))
+
+(define-public ecl-cl-ana.gnuplot-interface
+  (sbcl-package->ecl-package sbcl-cl-ana.gnuplot-interface))
+
+(define-public sbcl-cl-ana.plotting
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.plotting")
+    (inputs
+     `(("sbcl-cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
+       ("sbcl-cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
+       ("sbcl-cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
+       ("sbcl-cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
+       ("sbcl-cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
+       ("sbcl-cl-ana.gnuplot-interface" ,sbcl-cl-ana.gnuplot-interface)
+       ("sbcl-cl-ana.map" ,sbcl-cl-ana.map)
+       ("sbcl-cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
+       ("sbcl-cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
+       ("sbcl-cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
+       ("sbcl-cl-ana.histogram" ,sbcl-cl-ana.histogram)
+       ("sbcl-cl-ana.tensor" ,sbcl-cl-ana.tensor)
+       ("sbcl-external-program" ,sbcl-external-program)
+       ("sbcl-split-sequence" ,sbcl-split-sequence)
+       ("sbcl-alexandria" ,sbcl-alexandria)
+       ;; For sb-posix
+       ("sbcl" ,sbcl)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "plotting/cl-ana.plotting.asd")
+       ((#:asd-system-name _ #f) "cl-ana.plotting")))))
+
+(define-public cl-cl-ana.plotting
+  (sbcl-package->cl-source-package sbcl-cl-ana.plotting))
+
+(define-public ecl-cl-ana.plotting
+  (sbcl-package->ecl-package sbcl-cl-ana.plotting))
+
+(define-public sbcl-cl-ana.table-viewing
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.table-viewing")
+    (inputs
+     `(("sbcl-alexandria" ,sbcl-alexandria)
+       ("sbcl-cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
+       ("sbcl-cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
+       ("sbcl-cl-ana.table" ,sbcl-cl-ana.table)
+       ("sbcl-cl-ana.histogram" ,sbcl-cl-ana.histogram)
+       ("sbcl-cl-ana.plotting" ,sbcl-cl-ana.plotting)
+       ("sbcl-cl-ana.generic-math" ,sbcl-cl-ana.generic-math)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "table-viewing/cl-ana.table-viewing.asd")
+       ((#:asd-system-name _ #f) "cl-ana.table-viewing")))))
+
+(define-public cl-cl-ana.table-viewing
+  (sbcl-package->cl-source-package sbcl-cl-ana.table-viewing))
+
+(define-public ecl-cl-ana.table-viewing
+  (sbcl-package->ecl-package sbcl-cl-ana.table-viewing))
+
+(define-public sbcl-cl-ana.serialization
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.serialization")
+    (inputs
+     `(("sbcl-cl-ana.typespec" ,sbcl-cl-ana.typespec)
+       ("sbcl-cl-ana.histogram" ,sbcl-cl-ana.histogram)
+       ("sbcl-cl-ana.int-char" ,sbcl-cl-ana.int-char)
+       ("sbcl-cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
+       ("sbcl-cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
+       ("sbcl-cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
+       ("sbcl-cl-ana.hdf-table" ,sbcl-cl-ana.hdf-table)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "serialization/cl-ana.serialization.asd")
+       ((#:asd-system-name _ #f) "cl-ana.serialization")))))
+
+(define-public cl-cl-ana.serialization
+  (sbcl-package->cl-source-package sbcl-cl-ana.serialization))
+
+(define-public ecl-cl-ana.serialization
+  (sbcl-package->ecl-package sbcl-cl-ana.serialization))
+
+(define-public sbcl-cl-ana.makeres
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.makeres")
+    (inputs
+     `(("sbcl-alexandria" ,sbcl-alexandria)
+       ("sbcl-cl-ana.memoization" ,sbcl-cl-ana.memoization)
+       ("sbcl-cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
+       ("sbcl-cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
+       ("sbcl-cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
+       ("sbcl-cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
+       ("sbcl-cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
+       ("sbcl-cl-ana.map" ,sbcl-cl-ana.map)
+       ("sbcl-cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
+       ("sbcl-cl-ana.plotting" ,sbcl-cl-ana.plotting)
+       ("sbcl-external-program" ,sbcl-external-program)
+       ("sbcl-cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
+       ("sbcl-cl-ana.serialization" ,sbcl-cl-ana.serialization)
+       ("sbcl-cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
+       ("sbcl-cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
+       ("sbcl-cl-ana.file-utils" ,sbcl-cl-ana.file-utils)
+       ("sbcl-cl-ana.histogram" ,sbcl-cl-ana.histogram)
+       ("sbcl-cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
+       ("sbcl-cl-ana.table" ,sbcl-cl-ana.table)
+       ("sbcl-cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)))
+    (native-inputs
+     `(("sbcl-cl-fad" ,sbcl-cl-fad)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "makeres/cl-ana.makeres.asd")
+       ((#:asd-system-name _ #f) "cl-ana.makeres")))))
+
+(define-public cl-cl-ana.makeres
+  (sbcl-package->cl-source-package sbcl-cl-ana.makeres))
+
+(define-public ecl-cl-ana.makeres
+  (sbcl-package->ecl-package sbcl-cl-ana.makeres))
+
+(define-public sbcl-cl-ana.makeres-macro
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.makeres-macro")
+    (inputs
+     `(("sbcl-cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
+       ("sbcl-cl-ana.makeres" ,sbcl-cl-ana.makeres)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "makeres-macro/cl-ana.makeres-macro.asd")
+       ((#:asd-system-name _ #f) "cl-ana.makeres-macro")))))
+
+(define-public cl-cl-ana.makeres-macro
+  (sbcl-package->cl-source-package sbcl-cl-ana.makeres-macro))
+
+(define-public ecl-cl-ana.makeres-macro
+  (sbcl-package->ecl-package sbcl-cl-ana.makeres-macro))
+
+(define-public sbcl-cl-ana.makeres-block
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.makeres-block")
+    (inputs
+     `(("sbcl-alexandria" ,sbcl-alexandria)
+       ("sbcl-cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
+       ("sbcl-cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
+       ("sbcl-cl-ana.makeres" ,sbcl-cl-ana.makeres)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "makeres-block/cl-ana.makeres-block.asd")
+       ((#:asd-system-name _ #f) "cl-ana.makeres-block")))))
+
+(define-public cl-cl-ana.makeres-block
+  (sbcl-package->cl-source-package sbcl-cl-ana.makeres-block))
+
+(define-public ecl-cl-ana.makeres-block
+  (sbcl-package->ecl-package sbcl-cl-ana.makeres-block))
+
+(define-public sbcl-cl-ana.makeres-progress
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.makeres-progress")
+    (inputs
+     `(("sbcl-cl-ana.makeres" ,sbcl-cl-ana.makeres)
+       ("sbcl-cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
+       ("sbcl-alexandria" ,sbcl-alexandria)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "makeres-progress/cl-ana.makeres-progress.asd")
+       ((#:asd-system-name _ #f) "cl-ana.makeres-progress")))))
+
+(define-public cl-cl-ana.makeres-progress
+  (sbcl-package->cl-source-package sbcl-cl-ana.makeres-progress))
+
+(define-public ecl-cl-ana.makeres-progress
+  (sbcl-package->ecl-package sbcl-cl-ana.makeres-progress))
+
+(define-public sbcl-cl-ana.makeres-table
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.makeres-table")
+    (inputs
+     `(("sbcl-cl-ana.memoization" ,sbcl-cl-ana.memoization)
+       ("sbcl-cl-ana.makeres" ,sbcl-cl-ana.makeres)
+       ("sbcl-cl-ana.makeres-macro" ,sbcl-cl-ana.makeres-macro)
+       ("sbcl-cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
+       ("sbcl-cl-ana.table" ,sbcl-cl-ana.table)
+       ("sbcl-cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
+       ("sbcl-cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
+       ("sbcl-cl-ana.csv-table" ,sbcl-cl-ana.csv-table)
+       ("sbcl-cl-ana.ntuple-table" ,sbcl-cl-ana.ntuple-table)
+       ("sbcl-cl-ana.hdf-table" ,sbcl-cl-ana.hdf-table)
+       ("sbcl-cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
+       ("sbcl-cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
+       ("sbcl-cl-ana.list-utils" ,sbcl-cl-ana.list-utils)))
+    (native-inputs
+     `(("sbcl-cl-fad" ,sbcl-cl-fad)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "makeres-table/cl-ana.makeres-table.asd")
+       ((#:asd-system-name _ #f) "cl-ana.makeres-table")))))
+
+(define-public cl-cl-ana.makeres-table
+  (sbcl-package->cl-source-package sbcl-cl-ana.makeres-table))
+
+(define-public ecl-cl-ana.makeres-table
+  (sbcl-package->ecl-package sbcl-cl-ana.makeres-table))
+
+(define-public sbcl-cl-ana.makeres-graphviz
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.makeres-graphviz")
+    (inputs
+     `(("sbcl-cl-ana.makeres" ,sbcl-cl-ana.makeres)
+       ("sbcl-external-program" ,sbcl-external-program)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "makeres-graphviz/cl-ana.makeres-graphviz.asd")
+       ((#:asd-system-name _ #f) "cl-ana.makeres-graphviz")))))
+
+(define-public cl-cl-ana.makeres-graphviz
+  (sbcl-package->cl-source-package sbcl-cl-ana.makeres-graphviz))
+
+(define-public ecl-cl-ana.makeres-graphviz
+  (sbcl-package->ecl-package sbcl-cl-ana.makeres-graphviz))
+
+(define-public sbcl-cl-ana.makeres-branch
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.makeres-branch")
+    (inputs
+     `(("sbcl-alexandria" ,sbcl-alexandria)
+       ("sbcl-cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
+       ("sbcl-cl-ana.makeres" ,sbcl-cl-ana.makeres)
+       ("sbcl-cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
+       ("sbcl-cl-ana.map" ,sbcl-cl-ana.map)
+       ("sbcl-cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "makeres-branch/cl-ana.makeres-branch.asd")
+       ((#:asd-system-name _ #f) "cl-ana.makeres-branch")))))
+
+(define-public cl-cl-ana.makres-branch
+  (sbcl-package->cl-source-package sbcl-cl-ana.makres-branch))
+
+(define-public ecl-cl-ana.makres-branch
+  (sbcl-package->ecl-package sbcl-cl-ana.makres-branch))
+
+(define-public sbcl-cl-ana.makeres-utils
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.makeres-utils")
+    (inputs
+     `(("sbcl-alexandria" ,sbcl-alexandria)
+       ("sbcl-cl-ana.makeres" ,sbcl-cl-ana.makeres)
+       ("sbcl-cl-ana.fitting" ,sbcl-cl-ana.fitting)
+       ("sbcl-cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
+       ("sbcl-cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
+       ("sbcl-cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
+       ("sbcl-cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
+       ("sbcl-cl-ana.map" ,sbcl-cl-ana.map)
+       ("sbcl-cl-ana.plotting" ,sbcl-cl-ana.plotting)
+       ("sbcl-cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
+       ("sbcl-cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
+       ("sbcl-cl-ana.file-utils" ,sbcl-cl-ana.file-utils)
+       ("sbcl-cl-ana.histogram" ,sbcl-cl-ana.histogram)
+       ("sbcl-cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
+       ("sbcl-cl-ana.table" ,sbcl-cl-ana.table)
+       ("sbcl-cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)))
+    (native-inputs
+     `(("sbcl-cl-fad" ,sbcl-cl-fad)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "makeres-utils/cl-ana.makeres-utils.asd")
+       ((#:asd-system-name _ #f) "cl-ana.makeres-utils")))))
+
+(define-public cl-cl-ana.makres-utils
+  (sbcl-package->cl-source-package sbcl-cl-ana.makres-utils))
+
+(define-public ecl-cl-ana.makres-utils
+  (sbcl-package->ecl-package sbcl-cl-ana.makres-utils))
+
+(define-public sbcl-cl-ana.statistical-learning
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana.statistical-learning")
+    (inputs
+     `(("sbcl-cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
+       ("sbcl-cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
+       ("sbcl-cl-ana.map" ,sbcl-cl-ana.map)
+       ("sbcl-cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
+       ("sbcl-cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
+       ("sbcl-cl-ana.histogram" ,sbcl-cl-ana.histogram)
+       ("sbcl-cl-ana.statistics" ,sbcl-cl-ana.statistics)
+       ("sbcl-cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
+       ("sbcl-cl-ana.linear-algebra" ,sbcl-cl-ana.linear-algebra)))
+    (native-inputs
+     `(("sbcl-cl-fad" ,sbcl-cl-fad)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "")
+        "statistical-learning/cl-ana.statistical-learning.asd")
+       ((#:asd-system-name _ #f) "cl-ana.statistical-learning")))))
+
+(define-public cl-cl-ana.statistical-learning
+  (sbcl-package->cl-source-package sbcl-cl-ana.statistical-learning))
+
+(define-public ecl-cl-ana.statistical-learning
+  (sbcl-package->ecl-package sbcl-cl-ana.statistical-learning))
+
+(define-public sbcl-cl-ana
+  (package
+    (inherit sbcl-cl-ana-boot0)
+    (name "sbcl-cl-ana")
+    (inputs
+     `(("sbcl-cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
+       ("sbcl-cl-ana.package-utils" ,sbcl-cl-ana.package-utils)
+       ("sbcl-cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
+       ("sbcl-cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
+       ("sbcl-cl-ana.calculus" ,sbcl-cl-ana.calculus)
+       ("sbcl-cl-ana.binary-tree" ,sbcl-cl-ana.binary-tree)
+       ("sbcl-cl-ana.tensor" ,sbcl-cl-ana.tensor)
+       ("sbcl-cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
+       ("sbcl-cl-ana.quantity" ,sbcl-cl-ana.quantity)
+       ("sbcl-cl-ana.table" ,sbcl-cl-ana.table)
+       ("sbcl-cl-ana.table-utils" ,sbcl-cl-ana.table-utils)
+       ("sbcl-cl-ana.hdf-table" ,sbcl-cl-ana.hdf-table)
+       ("sbcl-cl-ana.ntuple-table" ,sbcl-cl-ana.ntuple-table)
+       ("sbcl-cl-ana.csv-table" ,sbcl-cl-ana.csv-table)
+       ("sbcl-cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
+       ("sbcl-cl-ana.linear-algebra" ,sbcl-cl-ana.linear-algebra)
+       ("sbcl-cl-ana.lorentz" ,sbcl-cl-ana.lorentz)
+       ("sbcl-cl-ana.histogram" ,sbcl-cl-ana.histogram)
+       ("sbcl-cl-ana.fitting" ,sbcl-cl-ana.fitting)
+       ("sbcl-cl-ana.file-utils" ,sbcl-cl-ana.file-utils)
+       ("sbcl-cl-ana.statistics" ,sbcl-cl-ana.statistics)
+       ("sbcl-cl-ana.statistical-learning"
+        ,sbcl-cl-ana.statistical-learning)
+       ("sbcl-cl-ana.plotting" ,sbcl-cl-ana.plotting)
+       ("sbcl-cl-ana.table-viewing" ,sbcl-cl-ana.table-viewing)
+       ("sbcl-cl-ana.int-char" ,sbcl-cl-ana.int-char)
+       ("sbcl-cl-ana.clos-utils" ,sbcl-cl-ana.clos-utils)
+       ("sbcl-cl-ana.serialization" ,sbcl-cl-ana.serialization)
+       ("sbcl-cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
+       ("sbcl-cl-ana.map" ,sbcl-cl-ana.map)
+       ("sbcl-cl-ana.makeres" ,sbcl-cl-ana.makeres)
+       ("sbcl-cl-ana.makeres-macro" ,sbcl-cl-ana.makeres-macro)
+       ("sbcl-cl-ana.makeres-block" ,sbcl-cl-ana.makeres-block)
+       ("sbcl-cl-ana.makeres-progress" ,sbcl-cl-ana.makeres-progress)
+       ("sbcl-cl-ana.makeres-table" ,sbcl-cl-ana.makeres-table)
+       ("sbcl-cl-ana.makeres-graphviz" ,sbcl-cl-ana.makeres-graphviz)
+       ("sbcl-cl-ana.makeres-branch" ,sbcl-cl-ana.makeres-branch)
+       ("sbcl-cl-ana.makeres-utils" ,sbcl-cl-ana.makeres-utils)
+       ("libffi" ,libffi)))
+    (native-inputs
+     `(("sbcl-cl-fad" ,sbcl-cl-fad)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+       ((#:asd-file _ "") "cl-ana.asd")
+       ((#:asd-system-name _ #f) "cl-ana")))))
+
+(define-public cl-cl-ana
+  (sbcl-package->cl-source-package sbcl-cl-ana))
+
+(define-public ecl-cl-ana
+  (sbcl-package->ecl-package sbcl-cl-ana))
-- 
2.17.1