Merge branch 'master' into core-updates

1 files changed, 597 insertions, 170 deletions

diff --git a/gnu/packages/lisp-xyz.scm b/gnu/packages/lisp-xyz.scm
index 737ab6cae9..dbb95ce387 100644
--- a/gnu/packages/lisp-xyz.scm
+++ b/gnu/packages/lisp-xyz.scm
@@ -16,6 +16,7 @@
 ;;; Copyright © 2019 Jesse Gildersleve <jessejohngildersleve@protonmail.com>
 ;;; Copyright © 2019, 2020 Guillaume Le Vaillant <glv@posteo.net>
 ;;; Copyright © 2019 Brett Gilio <brettg@gnu.org>
+;;; Copyright © 2020 Konrad Hinsen <konrad.hinsen@fastmail.net>
 ;;;
 ;;; This file is part of GNU Guix.
 ;;;
@@ -166,29 +167,27 @@ interactive development model in mind.")
   (sbcl-package->ecl-package sbcl-fiveam))
 
 (define-public sbcl-bordeaux-threads
-  (let ((commit "5dce49fbc829f4d136a734f5ef4f5d599660984f")
-        (revision "1"))
-    (package
-      (name "sbcl-bordeaux-threads")
-      (version (git-version "0.8.6" revision commit))
-      (source (origin
-                (method git-fetch)
-                (uri (git-reference
-                      (url "https://github.com/sionescu/bordeaux-threads.git")
-                      (commit commit)))
-                (sha256
-                 (base32 "1gkh9rz7zw57n3110ikcf4835950wr4hgp8l79id5ai6nd86x7wv"))
-                (file-name
-                 (git-file-name "bordeaux-threads" version))))
-      (inputs `(("alexandria" ,sbcl-alexandria)))
-      (native-inputs `(("fiveam" ,sbcl-fiveam)))
-      (build-system asdf-build-system/sbcl)
-      (synopsis "Portable shared-state concurrency library for Common Lisp")
-      (description "BORDEAUX-THREADS is a proposed standard for a minimal
+  (package
+    (name "sbcl-bordeaux-threads")
+    (version "0.8.7")
+    (source (origin
+              (method git-fetch)
+              (uri (git-reference
+                    (url "https://github.com/sionescu/bordeaux-threads.git")
+                    (commit (string-append "v" version))))
+              (sha256
+               (base32 "1whpfmyxp2fsw6viqj45fqgsifgr534c575bfh5vaqw5m84b6alp"))
+              (file-name
+               (git-file-name "bordeaux-threads" version))))
+    (inputs `(("alexandria" ,sbcl-alexandria)))
+    (native-inputs `(("fiveam" ,sbcl-fiveam)))
+    (build-system asdf-build-system/sbcl)
+    (synopsis "Portable shared-state concurrency library for Common Lisp")
+    (description "BORDEAUX-THREADS is a proposed standard for a minimal
 MP/Threading interface.  It is similar to the CLIM-SYS threading and lock
 support.")
-      (home-page "https://common-lisp.net/project/bordeaux-threads/")
-      (license license:x11))))
+    (home-page "https://common-lisp.net/project/bordeaux-threads/")
+    (license license:x11)))
 
 (define-public cl-bordeaux-threads
   (sbcl-package->cl-source-package sbcl-bordeaux-threads))
@@ -267,7 +266,7 @@ logical continuation of Stefil.  It focuses on interactive debugging.")
 (define-public sbcl-flexi-streams
   (package
     (name "sbcl-flexi-streams")
-    (version "1.0.16")
+    (version "1.0.18")
     (source
      (origin
        (method git-fetch)
@@ -276,7 +275,7 @@ logical continuation of Stefil.  It focuses on interactive debugging.")
              (commit (string-append "v" version))))
        (file-name (git-file-name "flexi-streams" version))
        (sha256
-        (base32 "0gvykjlmja060zqq6nn6aqxlshh6r6ijahmmgf20q0d839rwpgxc"))))
+        (base32 "0bjv7fd2acknidc5dyi3h85pn10krxv5jyxs1xg8jya2rlfv7f1j"))))
     (build-system asdf-build-system/sbcl)
     (arguments
      `(#:phases
@@ -304,7 +303,7 @@ streams which are similar to string streams.")
 (define-public sbcl-cl-ppcre
   (package
     (name "sbcl-cl-ppcre")
-    (version "2.0.11")
+    (version "2.1.1")
     (source
      (origin
        (method git-fetch)
@@ -313,7 +312,7 @@ streams which are similar to string streams.")
              (commit (string-append "v" version))))
        (file-name (git-file-name "cl-ppcre" version))
        (sha256
-        (base32 "0q3iany07vgqm144lw6pj0af2d3vsikpbkwcxr30fci3kzsq4f49"))))
+        (base32 "0dwvr29diqzcg5n6jvbk2rnd90i05l7n828hhw99khmqd0kz7xsi"))))
     (build-system asdf-build-system/sbcl)
     (native-inputs `(("flexi-streams" ,sbcl-flexi-streams)))
     (synopsis "Portable regular expression library for Common Lisp")
@@ -330,32 +329,30 @@ compatible with ANSI-compliant Common Lisp implementations.")
   (sbcl-package->ecl-package sbcl-cl-ppcre))
 
 (define sbcl-cl-unicode-base
-  (let ((revision "1")
-        (commit "9fcd06fba1ddc9e66aed2f2d6c32dc9b764f03ea"))
-    (package
-      (name "sbcl-cl-unicode-base")
-      (version (string-append "0.1.5-" revision "." (string-take commit 7)))
-      (source (origin
-                (method git-fetch)
-                (uri (git-reference
-                      (url "https://github.com/edicl/cl-unicode.git")
-                      (commit commit)))
-                (file-name (string-append "cl-unicode-" version "-checkout"))
-                (sha256
-                 (base32
-                  "1jicprb5b3bv57dy1kg03572gxkcaqdjhak00426s76g0plmx5ki"))))
-      (build-system asdf-build-system/sbcl)
-      (arguments
-       '(#:asd-file "cl-unicode.asd"
-         #:asd-system-name "cl-unicode/base"))
-      (inputs
-       `(("cl-ppcre" ,sbcl-cl-ppcre)))
-      (home-page "http://weitz.de/cl-unicode/")
-      (synopsis "Portable Unicode library for Common Lisp")
-      (description "CL-UNICODE is a portable Unicode library Common Lisp, which
+  (package
+    (name "sbcl-cl-unicode-base")
+    (version "0.1.6")
+    (source (origin
+              (method git-fetch)
+              (uri (git-reference
+                    (url "https://github.com/edicl/cl-unicode.git")
+                    (commit (string-append "v" version))))
+              (file-name (git-file-name name version))
+              (sha256
+               (base32
+                "0ykx2s9lqfl74p1px0ik3l2izd1fc9jd1b4ra68s5x34rvjy0hza"))))
+    (build-system asdf-build-system/sbcl)
+    (arguments
+     '(#:asd-file "cl-unicode.asd"
+       #:asd-system-name "cl-unicode/base"))
+    (inputs
+     `(("cl-ppcre" ,sbcl-cl-ppcre)))
+    (home-page "http://weitz.de/cl-unicode/")
+    (synopsis "Portable Unicode library for Common Lisp")
+    (description "CL-UNICODE is a portable Unicode library Common Lisp, which
 is compatible with perl.  It is pretty fast, thread-safe, and compatible with
 ANSI-compliant Common Lisp implementations.")
-      (license license:bsd-2))))
+    (license license:bsd-2)))
 
 (define-public sbcl-cl-unicode
   (package
@@ -629,6 +626,9 @@ from other CLXes around the net.")
      `(("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
        ("sbcl-cl-unicode" ,sbcl-cl-unicode)))))
 
+(define-public ecl-cl-ppcre-unicode
+  (sbcl-package->ecl-package sbcl-cl-ppcre-unicode))
+
 ;; The slynk that users expect to install includes all of slynk's contrib
 ;; modules.  Therefore, we build the base module and all contribs first; then
 ;; we expose the union of these as `sbcl-slynk'.  The following variable
@@ -1417,7 +1417,7 @@ In addition to regular Packrat / Parsing Grammar / TDPL features ESRAP supports:
 (define-public sbcl-split-sequence
   (package
     (name "sbcl-split-sequence")
-    (version "1.4.1")
+    (version "2.0.0")
     (source
      (origin
        (method git-fetch)
@@ -1426,13 +1426,11 @@ In addition to regular Packrat / Parsing Grammar / TDPL features ESRAP supports:
              (commit (string-append "v" version))))
        (sha256
         (base32
-         "0c3zp6b7fmmp93sfhq112ind4zkld49ycw68z409xpnz3gc0wpf0"))
+         "0jcpnx21hkfwqj5fvp7kc6pn1qcz9hk7g2s5x8h0349x1j2irln0"))
        (file-name (git-file-name "split-sequence" version))))
     (build-system asdf-build-system/sbcl)
-    (arguments
-     ;; TODO: Tests seem to be broken.
-     ;; https://github.com/sharplispers/split-sequence/issues/8
-     `(#:tests? #f))
+    (native-inputs
+     `(("fiveam" ,sbcl-fiveam)))
     (synopsis "Member of the Common Lisp Utilities family of programs")
     (description
      "Splits sequence into a list of subsequences delimited by objects
@@ -1570,7 +1568,7 @@ with @command{colorize} support."))))
 (define-public sbcl-cl-fad
   (package
     (name "sbcl-cl-fad")
-    (version "0.7.5")
+    (version "0.7.6")
     (source
      (origin
        (method git-fetch)
@@ -1579,7 +1577,7 @@ with @command{colorize} support."))))
              (commit (string-append "v" version))))
        (sha256
         (base32
-         "1l1qmk9z57q84bz5r04sxsksggsnd7dgkxlybzh9imz6ma7sm52m"))
+         "1gc8i82v6gks7g0lnm54r4prk2mklidv2flm5fvbr0a7rsys0vpa"))
        (file-name (string-append "cl-fad" version "-checkout"))))
     (build-system asdf-build-system/sbcl)
     (inputs
@@ -3180,44 +3178,43 @@ Lisp (from GBBopen project).")
 (define-public ecl-portable-threada
   (sbcl-package->ecl-package sbcl-portable-threads))
 
-(define-public sbcl-usocket-boot0
+(define sbcl-usocket-boot0
   ;; usocket's test rely on usocket-server which depends on usocket itself.
   ;; We break this cyclic dependency with -boot0 that packages usocket.
-  (let ((commit "86e7efbfe50101931edf4b67cdcfa7e221ecfde9"))
-    (package
-      (name "sbcl-usocket-boot0")
-      (version (git-version "0.7.1" "1" commit))
-      (source
-       (origin
-         (method git-fetch)
-         (uri (git-reference
-               (url "https://github.com/usocket/usocket/")
-               (commit commit)))
-         (file-name (git-file-name "usocket" version))
-         (sha256
-          (base32
-           "1lk6ipakrib7kdgzw44hrgmls9akp5pz4h35yynw0k5zwmmq6374"))))
-      (build-system asdf-build-system/sbcl)
-      (inputs
-       `(("split-sequence" ,sbcl-split-sequence)))
-      (arguments
-       `(#:tests? #f
-         #:asd-system-name "usocket"))
-      (home-page "https://common-lisp.net/project/usocket/")
-      (synopsis "Universal socket library for Common Lisp (server side)")
-      (description
-       "This library strives to provide a portable TCP/IP and UDP/IP socket
+  (package
+    (name "sbcl-usocket-boot0")
+    (version "0.8.3")
+    (source
+     (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/usocket/usocket/")
+             (commit (string-append "v" version))))
+       (file-name (git-file-name "usocket" version))
+       (sha256
+        (base32
+         "0x746wr2324l6bn7skqzgkzcbj5kd0zp2ck0c8rldrw0rzabg826"))))
+    (build-system asdf-build-system/sbcl)
+    (inputs
+     `(("split-sequence" ,sbcl-split-sequence)))
+    (arguments
+     `(#:tests? #f
+       #:asd-system-name "usocket"))
+    (home-page "https://common-lisp.net/project/usocket/")
+    (synopsis "Universal socket library for Common Lisp (server side)")
+    (description
+     "This library strives to provide a portable TCP/IP and UDP/IP socket
 interface for as many Common Lisp implementations as possible, while keeping
 the abstraction and portability layer as thin as possible.")
-      (license license:expat))))
+    (license license:expat)))
 
 (define-public sbcl-usocket-server
   (package
     (inherit sbcl-usocket-boot0)
     (name "sbcl-usocket-server")
     (inputs
-     `(("usocket" ,sbcl-usocket-boot0)
-       ("portable-threads" ,sbcl-portable-threads)))
+     `(("bordeaux-threads" ,sbcl-bordeaux-threads)
+       ("usocket" ,sbcl-usocket-boot0)))
     (arguments
      '(#:asd-system-name "usocket-server"))
     (synopsis "Universal socket library for Common Lisp (server side)")))
@@ -3243,7 +3240,7 @@ the abstraction and portability layer as thin as possible.")
 (define-public cl-usocket
   (sbcl-package->cl-source-package sbcl-usocket))
 
-(define-public ecl-socket
+(define-public ecl-usocket
   (sbcl-package->ecl-package sbcl-usocket))
 
 (define-public sbcl-s-xml
@@ -3666,45 +3663,45 @@ the format used by the popular compression tool bzip2.")
   (sbcl-package->cl-source-package sbcl-chipz))
 
 (define-public sbcl-drakma
-  (let ((version "2.0.4")
-        (commit "7647c0ae842ff2058624e53979c7f297760c97a7")
-        (revision "1"))
-    (package
-      (name "sbcl-drakma")
-      (version (git-version version revision commit))
-      (source
-       (origin
-         (method git-fetch)
-         (uri (git-reference
-               (url "https://github.com/edicl/drakma.git")
-               (commit commit)))
-         (file-name (git-file-name name version))
-         (sha256
-          (base32
-           "1c4i9wakhj5pxfyyykxshdmv3180sbkrx6fcyynikmc0jd0rh84r"))))
-      (build-system asdf-build-system/sbcl)
-      (inputs
-       `(("sbcl-puri" ,sbcl-puri)
-         ("sbcl-cl-base64" ,sbcl-cl-base64)
-         ("sbcl-chunga" ,sbcl-chunga)
-         ("sbcl-flexi-streams" ,sbcl-flexi-streams)
-         ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
-         ("sbcl-chipz" ,sbcl-chipz)
-         ("sbcl-usocket" ,sbcl-usocket)
-         ("sbcl-cl+ssl" ,sbcl-cl+ssl)))
-      (native-inputs
-       `(("sbcl-fiveam" ,sbcl-fiveam)))
-      (home-page "https://edicl.github.io/drakma/")
-      (synopsis "HTTP client written in Common Lisp")
-      (description
-       "Drakma is a full-featured HTTP client implemented in Common Lisp.  It
+  (package
+    (name "sbcl-drakma")
+    (version "2.0.7")
+    (source
+     (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/edicl/drakma.git")
+             (commit (string-append "v" version))))
+       (file-name (git-file-name name version))
+       (sha256
+        (base32
+         "1441idnyif9xzx3ln1p3fg36k2v9h4wasjqrzc8y52j61420qpci"))))
+    (build-system asdf-build-system/sbcl)
+    (inputs
+     `(("sbcl-puri" ,sbcl-puri)
+       ("sbcl-cl-base64" ,sbcl-cl-base64)
+       ("sbcl-chunga" ,sbcl-chunga)
+       ("sbcl-flexi-streams" ,sbcl-flexi-streams)
+       ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
+       ("sbcl-chipz" ,sbcl-chipz)
+       ("sbcl-usocket" ,sbcl-usocket)
+       ("sbcl-cl+ssl" ,sbcl-cl+ssl)))
+    (native-inputs
+     `(("sbcl-fiveam" ,sbcl-fiveam)))
+    (home-page "https://edicl.github.io/drakma/")
+    (synopsis "HTTP client written in Common Lisp")
+    (description
+     "Drakma is a full-featured HTTP client implemented in Common Lisp.  It
 knows how to handle HTTP/1.1 chunking, persistent connections, re-usable
 sockets, SSL, continuable uploads, file uploads, cookies, and more.")
-      (license license:bsd-2))))
+    (license license:bsd-2)))
 
 (define-public cl-drakma
   (sbcl-package->cl-source-package sbcl-drakma))
 
+(define-public ecl-drakma
+  (sbcl-package->ecl-package sbcl-drakma))
+
 (define-public sbcl-hunchentoot
   (package
     (name "sbcl-hunchentoot")
@@ -4105,36 +4102,37 @@ Lisp.")
   (sbcl-package->cl-source-package sbcl-fast-http))
 
 (define-public sbcl-static-vectors
-  (let ((commit "0681eac1f49370cde03e64b077251e8abf47d702")
-        (revision "1"))
-    (package
-     (name "sbcl-static-vectors")
-     (version (git-version "1.8.3" revision commit))
-     (source
-      (origin
+  (package
+    (name "sbcl-static-vectors")
+    (version "1.8.4")
+    (source
+     (origin
        (method git-fetch)
        (uri (git-reference
              (url "https://github.com/sionescu/static-vectors.git")
-             (commit commit)))
+             (commit (string-append "v" version))))
        (file-name (git-file-name name version))
        (sha256
-        (base32 "138nlsq14hv8785ycjm6jw3i6ablhq8vcwys7q09y80arcgrg6r3"))))
-     (native-inputs
-      `(("sbcl-fiveam" ,sbcl-fiveam)))
-     (inputs
-      `(("sbcl-cffi-grovel" ,sbcl-cffi-grovel)
-        ("sbcl-cffi" ,sbcl-cffi)))
-     (build-system asdf-build-system/sbcl)
-     (home-page "http://common-lisp.net/projects/iolib/")
-     (synopsis "Allocate SIMPLE-ARRAYs in static memory")
-     (description
-      "With @code{static-vectors}, you can create vectors allocated in static
+        (base32 "0qvf9z6bhwhm8n45fjwkm7j8dcb58szfvndky65cyn4lpdval7m1"))))
+    (native-inputs
+     `(("sbcl-fiveam" ,sbcl-fiveam)))
+    (inputs
+     `(("sbcl-cffi-grovel" ,sbcl-cffi-grovel)
+       ("sbcl-cffi" ,sbcl-cffi)))
+    (build-system asdf-build-system/sbcl)
+    (home-page "https://github.com/sionescu/static-vectors")
+    (synopsis "Allocate SIMPLE-ARRAYs in static memory")
+    (description
+     "With @code{static-vectors}, you can create vectors allocated in static
 memory.")
-     (license license:expat))))
+    (license license:expat)))
 
 (define-public cl-static-vectors
   (sbcl-package->cl-source-package sbcl-static-vectors))
 
+(define-public ecl-static-vectors
+  (sbcl-package->ecl-package sbcl-static-vectors))
+
 (define-public sbcl-marshal
   (let ((commit "eff1b15f2b0af2f26f71ad6a4dd5c4beab9299ec")
         (revision "1"))
@@ -5225,7 +5223,7 @@ decoding routines for IDNA, the International Domain Names in Applications.")
   (package
     (name "sbcl-swap-bytes")
     (build-system asdf-build-system/sbcl)
-    (version "1.1")
+    (version "1.2")
     (home-page "https://github.com/sionescu/swap-bytes")
     (source
      (origin
@@ -5236,14 +5234,11 @@ decoding routines for IDNA, the International Domain Names in Applications.")
        (file-name (git-file-name name version))
        (sha256
         (base32
-         "1qysbv0jngdfkv53y874qjhcxc4qi8ixaqq6j8bzxh5z0931wv55"))))
+         "1hw1v1lw26rifyznpnj1csphha9jgzwpiic16ni3pvs6hcsni9rz"))))
     (inputs
      `(("trivial-features" ,sbcl-trivial-features)))
     (native-inputs
      `(("fiveam" ,sbcl-fiveam)))
-    (arguments
-     ;; TODO: Tests fail, why?
-     `(#:tests? #f))
     (synopsis "Efficient endianness conversion for Common Lisp")
     (description "This Common Lisp library provides optimized byte-swapping
 primitives.  The library can change endianness of unsigned integers of length
@@ -5970,6 +5965,42 @@ This package uses fare-quasiquote with named-readtable.")))
   (sbcl-package->cl-source-package sbcl-fare-quasiquote-readtable))
 
 ;; TODO: Add support for component-less system in asdf-build-system/sbcl.
+(define-public sbcl-fare-quasiquote-extras
+  (package
+    (inherit sbcl-fare-quasiquote)
+    (name "sbcl-fare-quasiquote-extras")
+    (build-system asdf-build-system/sbcl)
+    (inputs
+     `(("fare-quasiquote-optima" ,sbcl-fare-quasiquote-optima)
+       ("fare-quasiquote-readtable" ,sbcl-fare-quasiquote-readtable)))
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+         (replace 'build
+           (lambda* (#:key outputs #:allow-other-keys)
+             (let* ((out (assoc-ref outputs "out"))
+                    (lib (string-append out "/lib/" (%lisp-type))))
+               (mkdir-p lib)
+               (install-file "fare-quasiquote-extras.asd" lib)
+               #t)))
+         (add-after 'create-asd-file 'fix-asd-file
+           (lambda* (#:key outputs #:allow-other-keys)
+             (let* ((out (assoc-ref outputs "out"))
+                    (lib (string-append out "/lib/" (%lisp-type)))
+                    (asd (string-append lib "/fare-quasiquote-extras.asd")))
+               (substitute* asd
+                 ((":class")
+                  "")
+                 (("asdf/bundle:prebuilt-system")
+                  "")
+                 ((":components")
+                  "")
+                 (("\\(\\(:compiled-file \"fare-quasiquote-extras--system\"\\)\\)")
+                  "")))
+             #t)))))
+    (description "This library combines @code{fare-quasiquote-readtable} and
+@code{fare-quasiquote-optima}.")))
+
 (define-public cl-fare-quasiquote-extras
   (package
     (inherit cl-fare-quasiquote)
@@ -5983,7 +6014,7 @@ This package uses fare-quasiquote with named-readtable.")))
 @code{fare-quasiquote-optima}.")))
 
 (define-public sbcl-trivia.level0
-  (let ((commit "902e0c65602bbfe96ae82e679330b3771ddc7603")
+  (let ((commit "574901ac376ae54c9d37169fd5efab9b3b8fcc63")
         (revision "1"))
     (package
       (name "sbcl-trivia.level0")
@@ -5999,7 +6030,7 @@ This package uses fare-quasiquote with named-readtable.")))
          (file-name (git-file-name name version))
          (sha256
           (base32
-           "11qbab30qqnfy9mx3x9fvgcw1jbvh1qn2cqv3p8xdn2m8981jvhr"))))
+           "0hf53n71xzr9sjwrxis5fivx3drclf4s39h5ck8vh21ndqj9zvdk"))))
       (inputs
        `(("alexandria" ,sbcl-alexandria)))
       (synopsis "Pattern matching in Common Lisp")
@@ -6877,8 +6908,8 @@ compression/decompression using bindings to the lzlib C library.")
   (sbcl-package->ecl-package sbcl-lzlib))
 
 (define-public sbcl-chanl
-  (let ((commit "2362b57550c2c9238cc882d03553aaa1040b7340")
-        (revision "0"))
+  (let ((commit "56e90a126c78b39bb621a01585e8d3b985238e8c")
+        (revision "1"))
     (package
       (name "sbcl-chanl")
       (version (git-version "0.4.1" revision commit))
@@ -6891,7 +6922,7 @@ compression/decompression using bindings to the lzlib C library.")
          (file-name (git-file-name name version))
          (sha256
           (base32
-           "0ag3wz7yrqwp0s5069wwda98z3rrqd25spg8sa8rdqghj084w28w"))))
+           "0b1cf6c12qx5cy1fw2z42jgh566rp3l8nv5qf0qqc569s7bgmrh4"))))
       (build-system asdf-build-system/sbcl)
       (native-inputs
        `(("fiveam" ,sbcl-fiveam)))
@@ -6909,26 +6940,7 @@ threads.")
   (sbcl-package->cl-source-package sbcl-chanl))
 
 (define-public ecl-chanl
-  (let ((base (sbcl-package->ecl-package sbcl-chanl)))
-    (package
-      (inherit base)
-      (arguments
-       (substitute-keyword-arguments (package-arguments base)
-         ;; The CHANL.ACTORS package uses the :ARGUMENTS option of
-         ;; DEFINE-METHOD-COMBINATION, which is not implemented in ECL yet
-         ;; (see https://gitlab.com/embeddable-common-lisp/ecl/issues/305).
-         ;; So let's disable it for now, as it allows compiling the library
-         ;; and using the rest of it.
-         ((#:phases phases '%standard-phases)
-          `(modify-phases ,phases
-             (add-after 'unpack 'disable-chanl-actors
-               (lambda _
-                 (substitute* "chanl.asd"
-                   (("\\(:file \"actors\"\\)") ""))
-                 #t))))
-         ;; Disable the tests for now, as the SEND-SEQUENCE test seems to
-         ;; never end.
-         ((#:tests? _ #f) #f))))))
+  (sbcl-package->ecl-package sbcl-chanl))
 
 (define-public sbcl-cl-store
   (let ((commit "c787337a16ea8cf8a06227f35933a4ec774746b3")
@@ -7181,7 +7193,7 @@ implementation specific equivalent.")
          ("trivial-garbage" ,sbcl-trivial-garbage)
          ("bordeaux-threads" ,sbcl-bordeaux-threads)
          ("named-readtables" ,sbcl-named-readtables)
-         ("fare-quasiquote-extras" ,cl-fare-quasiquote-extras)
+         ("fare-quasiquote-extras" ,sbcl-fare-quasiquote-extras)
          ("parse-declarations-1.0" ,sbcl-parse-declarations)
          ("global-vars" ,sbcl-global-vars)
          ("trivial-file-size" ,sbcl-trivial-file-size)
@@ -7543,6 +7555,9 @@ docstrings for your library.")
 (define-public cl-documentation-utils
   (sbcl-package->cl-source-package sbcl-documentation-utils))
 
+(define-public ecl-documentation-utils
+  (sbcl-package->ecl-package sbcl-documentation-utils))
+
 (define-public sbcl-form-fiddle
   (let ((commit "e0c23599dbb8cff3e83e012f3d86d0764188ad18")
         (revision "0"))
@@ -10163,3 +10178,415 @@ them as PNG files.")
 
 (define-public ecl-cl-qrencode
   (sbcl-package->ecl-package sbcl-cl-qrencode))
+
+(define-public sbcl-hdf5-cffi
+  (let ((commit "5b5c88f191e470e4fe96b462334e3ce0806eed5c")
+        (revision "1"))
+    (package
+      (name "sbcl-hdf5-cffi")
+      (version (git-version "1.8.18" revision commit))
+      (source
+       (origin
+         (method git-fetch)
+         (uri (git-reference
+               (url "https://github.com/hdfgroup/hdf5-cffi.git")
+               (commit commit)))
+         (file-name (git-file-name name version))
+         (sha256
+          (base32
+           "0vda3075423xz83qky998lpac5b04dwfv7bwgh9jq8cs5v0zrxjf"))))
+      (build-system asdf-build-system/sbcl)
+      (synopsis "Common Lisp bindings for the HDF5 library")
+      (description
+       "@code{hdf5-cffi} is a CFFI wrapper for the HDF5 library.")
+      (home-page "https://github.com/hdfgroup/hdf5-cffi")
+      (license (license:non-copyleft
+                (string-append "https://github.com/HDFGroup/hdf5-cffi/raw/"
+                               commit
+                               "/LICENSE")))
+      (inputs
+       `(("cffi" ,sbcl-cffi)
+         ("cffi-grovel" ,sbcl-cffi-grovel)
+         ("hdf5" ,hdf5-1.10)))
+      (native-inputs
+       `(("fiveam" ,sbcl-fiveam)))
+      (arguments
+       `(#:asd-system-name "hdf5-cffi"
+         #:asd-file "hdf5-cffi.asd"
+         #:test-asd-file "hdf5-cffi.test.asd"
+         ;; Tests depend on hdf5-cffi.examples.asd in addition to hdf5-cffi.asd,
+         ;; I don't know if there is a way to tell asdf-build-system to load
+         ;; an additional system first, so tests are disabled.
+         #:tests? #f
+         #:phases
+         (modify-phases %standard-phases
+           (add-after 'unpack 'fix-paths
+             (lambda* (#:key inputs #:allow-other-keys)
+               (substitute* "src/library.lisp"
+                 (("libhdf5.so")
+                  (string-append
+                   (assoc-ref inputs "hdf5")
+                   "/lib/libhdf5.so")))))
+           (add-after 'unpack 'fix-dependencies
+             (lambda* (#:key inputs #:allow-other-keys)
+               (substitute* "hdf5-cffi.asd"
+                 ((":depends-on \\(:cffi\\)")
+                  ":depends-on (:cffi :cffi-grovel)"))
+               (substitute* "hdf5-cffi.test.asd"
+                 ((":depends-on \\(:cffi :hdf5-cffi")
+                  ":depends-on (:cffi :cffi-grovel :hdf5-cffi"))))))))))
+
+(define-public cl-hdf5-cffi
+  (sbcl-package->cl-source-package sbcl-hdf5-cffi))
+
+(define-public ecl-hdf5-cffi
+  (sbcl-package->ecl-package sbcl-hdf5-cffi))
+
+(define-public sbcl-cl-randist
+  (package
+    (name "sbcl-cl-randist")
+    (version "0.4.2")
+    (source
+     (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/lvaruzza/cl-randist.git")
+             (commit "f088a54b540a7adefab7c04094a6103f9edda3d0")))
+       (file-name (git-file-name name version))
+       (sha256
+        (base32
+         "0l8hyd6nbxb7f50vyxz3rbbm7kgr1fnadc40jywy4xj5vi5kpj5g"))))
+    (build-system asdf-build-system/sbcl)
+    (synopsis "Random distributions for Common Lisp")
+    (description
+     "Manual translation from C to Common Lisp of some random number
+generation functions from the GSL library.")
+    (home-page "https://github.com/lvaruzza/cl-randist")
+    (license license:bsd-2)
+    (arguments
+     `(#:asd-system-name "cl-randist"
+       #:asd-file "cl-randist.asd"
+       #:tests? #f))))
+
+(define-public cl-randist
+  (sbcl-package->cl-source-package sbcl-cl-randist))
+
+(define-public ecl-cl-randist
+  (sbcl-package->ecl-package sbcl-cl-randist))
+
+(define-public sbcl-float-features
+  (package
+    (name "sbcl-float-features")
+    (version "1.0.0")
+    (source
+     (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/Shinmera/float-features.git")
+             (commit "d3ef60181635b0849aa28cfc238053b7ca4644b0")))
+       (file-name (git-file-name name version))
+       (sha256
+        (base32
+         "0yj419k7n59x6rh3grwr6frgwwyria2il6f7wxpfazm8cskv4lzr"))))
+    (build-system asdf-build-system/sbcl)
+    (synopsis "Common Lisp IEEE float portability library")
+    (description
+     "Portability library for IEEE float features that are not
+covered by the Common Lisp standard.")
+    (home-page "https://github.com/Shinmera/float-features")
+    (license license:zlib)
+    (inputs
+     `(("documentation-utils" ,sbcl-documentation-utils)))
+    (arguments
+     `(#:asd-system-name "float-features"
+       #:asd-file "float-features.asd"
+       #:tests? #f))))
+
+(define-public cl-float-features
+  (sbcl-package->cl-source-package sbcl-float-features))
+
+(define-public ecl-float-features
+  (sbcl-package->ecl-package sbcl-float-features))
+
+(define-public sbcl-function-cache
+  (package
+    (name "sbcl-function-cache")
+    (version "1.0.3")
+    (source
+     (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/AccelerationNet/function-cache.git")
+             (commit "6a5ada401e57da2c8abf046f582029926e61fce8")))
+       (file-name (git-file-name name version))
+       (sha256
+        (base32
+         "000vmd3f5rx5hs9nvphfric0gkzaadns31c6mxaslpv0k7pkrmc6"))))
+    (build-system asdf-build-system/sbcl)
+    (synopsis "Function caching / memoization library for Common Lisp")
+    (description
+     "A common lisp library that provides extensible function result
+caching based on arguments (an expanded form of memoization).")
+    (home-page "https://github.com/AccelerationNet/function-cache")
+    (license
+     (license:non-copyleft
+      "https://github.com/AccelerationNet/function-cache/blob/master/README.md"))
+    (inputs
+     `(("alexandria" ,sbcl-alexandria)
+       ("cl-interpol" ,sbcl-cl-interpol)
+       ("iterate" ,sbcl-iterate)
+       ("symbol-munger" ,sbcl-symbol-munger)
+       ("closer-mop" ,sbcl-closer-mop)))
+    (arguments
+     `(#:asd-system-name "function-cache"
+       #:asd-file "function-cache.asd"
+       #:tests? #f))))
+
+(define-public cl-function-cache
+  (sbcl-package->cl-source-package sbcl-function-cache))
+
+(define-public ecl-function-cache
+  (sbcl-package->ecl-package sbcl-function-cache))
+
+(define-public sbcl-type-r
+  (let ((commit "83c89e38f2f7a7b16f1012777ecaf878cfa6a267")
+        (revision "1"))
+    (package
+      (name "sbcl-type-r")
+      (version (git-version "0.0.0" revision commit))
+      (source
+       (origin
+         (method git-fetch)
+         (uri (git-reference
+               (url "https://github.com/guicho271828/type-r.git")
+               (commit commit)))
+         (file-name (git-file-name name version))
+         (sha256
+          (base32
+           "1arsxc2539rg8vbrdirz4xxj1b06mc6g6rqndz7a02g127qvk2sm"))))
+      (build-system asdf-build-system/sbcl)
+      (synopsis "Parser interface for Common Lisp built-in compound types")
+      (description
+       "Collections of accessor functions and patterns to access
+the elements in compound type specifier, e.g. @code{dimensions} in
+@code{(array element-type dimensions)}")
+      (home-page "https://github.com/guicho271828/type-r")
+      (license license:lgpl3+)
+      (inputs
+       `(("trivia" ,sbcl-trivia)
+         ("alexandria" ,sbcl-alexandria)))
+      (native-inputs
+       `(("fiveam" ,sbcl-fiveam)))
+      (arguments
+       `(#:asd-system-name "type-r"
+         #:asd-file "type-r.asd"
+         #:test-asd-file "type-r.test.asd")))))
+
+(define-public cl-type-r
+  (sbcl-package->cl-source-package sbcl-type-r))
+
+(define-public sbcl-trivialib-type-unify
+  (let ((commit "62492ebf04db567dcf435ae84c50b7b8202ecf99")
+        (revision "1"))
+    (package
+      (name "sbcl-trivialib-type-unify")
+      (version (git-version "0.1" revision commit))
+      (source
+       (origin
+         (method git-fetch)
+         (uri (git-reference
+               (url "https://github.com/guicho271828/trivialib.type-unify.git")
+               (commit commit)))
+         (file-name (git-file-name name version))
+         (sha256
+          (base32
+           "1bkyfzbwv75p50zp8n1n9rh2r29pw3vgz91gmn2gzzkyq3khj1vh"))))
+      (build-system asdf-build-system/sbcl)
+      (synopsis "Common Lisp type unification")
+      (description
+       "Unifies a parametrized type specifier against an actual type specifier.
+Importantly, it handles complicated array-subtypes and number-related types
+correctly.")
+      (home-page "https://github.com/guicho271828/trivialib.type-unify")
+      (license license:lgpl3+)
+      (inputs
+       `(("alexandria" ,sbcl-alexandria)
+         ("trivia" ,sbcl-trivia)
+         ("introspect-environment" ,sbcl-introspect-environment)
+         ("type-r" ,sbcl-type-r)))
+      (native-inputs
+       `(("fiveam" ,sbcl-fiveam)))
+      (arguments
+       `(#:asd-system-name "trivialib.type-unify"
+         #:asd-file "trivialib.type-unify.asd"
+         #:test-asd-file "trivialib.type-unify.test.asd")))))
+
+(define-public cl-trivialib-type-unify
+  (sbcl-package->cl-source-package sbcl-trivialib-type-unify))
+
+(define-public sbcl-specialized-function
+  (let ((commit "b96b6afaf8358bf91cc0703e62a5a4ee20d2b7bc")
+        (revision "1"))
+    (package
+      (name "sbcl-specialized-function")
+      (version (git-version "0.0.0" revision commit))
+      (source
+       (origin
+         (method git-fetch)
+         (uri (git-reference
+               (url "https://github.com/numcl/specialized-function.git")
+               (commit commit)))
+         (file-name (git-file-name name version))
+         (sha256
+          (base32
+           "12j45ff0n26578vmfbhb9mfbdchw4wy023k0m2ppgl9s0z4bhjaj"))))
+      (build-system asdf-build-system/sbcl)
+      (synopsis "Julia-like dispatch for Common Lisp")
+      (description
+       "This library is part of NUMCL.  It provides a macro
+@code{SPECIALIZED} that performs a Julia-like dispatch on the arguments,
+lazily compiling a type-specific version of the function from the same
+code.  The main target of this macro is speed.")
+      (home-page "https://github.com/numcl/specialized-function")
+      (license license:lgpl3+)
+      (inputs
+       `(("trivia" ,sbcl-trivia)
+         ("alexandria" ,sbcl-alexandria)
+         ("iterate" ,sbcl-iterate)
+         ("lisp-namespace" ,sbcl-lisp-namespace)
+         ("type-r" ,sbcl-type-r)
+         ("trivial-cltl2" ,sbcl-trivial-cltl2)))
+      (native-inputs
+       `(("fiveam" ,sbcl-fiveam)))
+      (arguments
+       `(#:asd-system-name "specialized-function"
+         #:asd-file "specialized-function.asd"
+         #:test-asd-file "specialized-function.test.asd")))))
+
+(define-public cl-specialized-function
+  (sbcl-package->cl-source-package sbcl-specialized-function))
+
+(define-public sbcl-constantfold
+  (let ((commit "0ff1d97a3fbcb89264f6a2af6ce62b73e7b421f4")
+        (revision "1"))
+    (package
+      (name "sbcl-constantfold")
+      (version (git-version "0.1" revision commit))
+      (source
+       (origin
+         (method git-fetch)
+         (uri (git-reference
+               (url "https://github.com/numcl/constantfold.git")
+               (commit commit)))
+         (file-name (git-file-name name version))
+         (sha256
+          (base32
+           "153h0569z6bff1qbad0bdssplwwny75l7ilqwcfqfdvzsxf9jh06"))))
+      (build-system asdf-build-system/sbcl)
+      (synopsis "Support library for numcl")
+      (description
+       "Support library for numcl.  Registers a function as an
+additional form that is considered as a candidate for a constant.")
+      (home-page "https://github.com/numcl/constantfold")
+      (license license:lgpl3+)
+      (inputs
+       `(("trivia" ,sbcl-trivia)
+         ("alexandria" ,sbcl-alexandria)
+         ("iterate" ,sbcl-iterate)
+         ("lisp-namespace" ,sbcl-lisp-namespace)))
+      (native-inputs
+       `(("fiveam" ,sbcl-fiveam)))
+      (arguments
+       `(#:asd-system-name "constantfold"
+         #:asd-file "constantfold.asd"
+         #:test-asd-file "constantfold.test.asd")))))
+
+(define-public cl-constantfold
+  (sbcl-package->cl-source-package sbcl-constantfold))
+
+(define-public sbcl-gtype
+  (let ((commit "42275e3606242ae91e9c8dfa30c18ced50a35b66")
+        (revision "1"))
+    (package
+      (name "sbcl-gtype")
+      (version (git-version "0.1" revision commit))
+      (source
+       (origin
+         (method git-fetch)
+         (uri (git-reference
+               (url "https://github.com/numcl/gtype.git")
+               (commit commit)))
+         (file-name (git-file-name name version))
+         (sha256
+          (base32
+           "1f56dba998v945jcxhha391557n6md1ql25b7icfwwfivhmlaa9b"))))
+      (build-system asdf-build-system/sbcl)
+      (synopsis "C++/Julia-like parametric types in Common Lisp")
+      (description
+       "Support library for numcl that provides Julia-like runtime parametric
+type correctness in Common Lisp.  It is based on CLtL2 extensions.")
+      (home-page "https://github.com/numcl/gtype")
+      (license license:lgpl3+)
+      (inputs
+       `(("trivialib.type-unify" ,sbcl-trivialib-type-unify)
+         ("trivial-cltl2" ,sbcl-trivial-cltl2)
+         ("trivia" ,sbcl-trivia)
+         ("alexandria" ,sbcl-alexandria)
+         ("iterate" ,sbcl-iterate)
+         ("type-r" ,sbcl-type-r)))
+      (native-inputs
+       `(("fiveam" ,sbcl-fiveam)))
+      (arguments
+       `(#:asd-system-name "gtype"
+         #:asd-file "gtype.asd"
+         #:test-asd-file "gtype.test.asd")))))
+
+(define-public cl-gtype
+  (sbcl-package->cl-source-package sbcl-gtype))
+
+(define-public sbcl-numcl
+  (let ((commit "1cf7dfa59f763a24a501092870e9c5ee745d0c17")
+        (revision "1"))
+    (package
+      (name "sbcl-numcl")
+      (version (git-version "0.1.0" revision commit))
+      (source
+       (origin
+         (method git-fetch)
+         (uri (git-reference
+               (url "https://github.com/numcl/numcl.git")
+               (commit commit)))
+         (file-name (git-file-name name version))
+         (sha256
+          (base32
+           "0i3jby9hf4ii7blivgyza80g0vmjfhk8537i5i7kqqk0i5sdnym2"))))
+      (build-system asdf-build-system/sbcl)
+      (synopsis "Numpy clone in Common Lisp")
+      (description
+       "This is a Numpy clone in Common Lisp.  At the moment the
+library is written in pure Common Lisp, focusing more on correctness
+and usefulness, not speed.  Track the progress at
+@url{https://github.com/numcl/numcl/projects/1}.")
+      (home-page "https://github.com/numcl/numcl")
+      (license license:lgpl3+)
+      (inputs
+       `(("trivia" ,sbcl-trivia)
+         ("alexandria" ,sbcl-alexandria)
+         ("iterate" ,sbcl-iterate)
+         ("lisp-namespace" ,sbcl-lisp-namespace)
+         ("type-r" ,sbcl-type-r)
+         ("constantfold" ,sbcl-constantfold)
+         ("cl-randist" ,sbcl-cl-randist)
+         ("float-features" ,sbcl-float-features)
+         ("function-cache" ,sbcl-function-cache)
+         ("specialized-function" ,sbcl-specialized-function)
+         ("gtype" ,sbcl-gtype)))
+      (native-inputs
+       `(("fiveam" ,sbcl-fiveam)))
+      (arguments
+       `(#:asd-system-name "numcl"
+         #:asd-file "numcl.asd"
+         #:test-asd-file "numcl.test.asd")))))
+
+(define-public cl-numcl
+  (sbcl-package->cl-source-package sbcl-numcl))