[bug#34959] [PATCH] Add Multiple Common Lisp Packages

[Katherine Cox-Buday <cox.katherine.e@gmail.com>]

[-- Attachment #1: Type: text/plain, Size: 467 bytes --]

I packaged most of these in one day in a mad rush to try and get Clack
packaged. After verifying the packages built, I went back after the fact
and decorated all the packages with their metadata.

Because I rushed through some of this, I'm sure I've made a mistake
somewhere and I would greatly appreciate more eyes on these packages. If
we want to take the stance that something is better than nothing, and
that we can clean up any mistakes later, that's fine too.


[-- Attachment #2: 0001-Add-Multiple-Common-Lisp-Packages.patch --]
[-- Type: text/x-patch, Size: 56536 bytes --]

From c4b9394599c7cf9f6069fb3e8c3466858155e1c8 Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Sat, 23 Mar 2019 15:01:11 -0500
Subject: [PATCH] Add Multiple Common Lisp Packages

---
 gnu/packages/lisp.scm | 1210 ++++++++++++++++++++++++++++++++++++++++-
 guix/licenses.scm     |    7 +-
 2 files changed, 1214 insertions(+), 3 deletions(-)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index 3d43b7c509..837839c0f7 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -12,6 +12,7 @@
 ;;; Copyright © 2018 Alex Vong <alexvong1995@gmail.com>
 ;;; Copyright © 2018 Pierre Neidhardt <mail@ambrevar.xyz>
 ;;; Copyright © 2018 Pierre Langlois <pierre.langlois@gmx.com>
+;;; Copyright © 2019 Katherine Cox-Buday <cox.katherine.e@gmail.com>
 ;;;
 ;;; This file is part of GNU Guix.
 ;;;
@@ -65,6 +66,7 @@
   #:use-module (gnu packages sqlite)
   #:use-module (gnu packages tex)
   #:use-module (gnu packages texinfo)
+  #:use-module (gnu packages tls)
   #:use-module (gnu packages version-control)
   #:use-module (gnu packages xorg)
   #:use-module (gnu packages databases)
@@ -2554,8 +2556,7 @@ which causes everything printed in the body to be displayed with the provided
 color.  It further provides functions which will print the argument with the
 named color.")
       (home-page "https://github.com/pnathan/cl-ansi-text")
-      ;; REVIEW: The actual license is LLGPL.  Should we add it to Guix?
-      (license license:lgpl3+))))
+      (license license:llgpl))))
 
 (define-public cl-ansi-text
   (sbcl-package->cl-source-package sbcl-cl-ansi-text))
@@ -3840,3 +3841,1208 @@ client and server.")
 
 (define-public ecl-trivial-clipboard
   (sbcl-package->ecl-package sbcl-trivial-clipboard))
+
+(define-public sbcl-trivial-backtrace
+  (let ((commit-hash "ca81c011b86424a381a7563cea3b924f24e6fbeb"))
+    (package
+     (name "sbcl-trivial-backtrace")
+     (synopsis "Portable simple API to work with backtraces in Common Lisp")
+     (description "On of the many things that didn't quite get into the Common Lisp standard was how to get a Lisp to output its call stack when something has gone wrong. As such, each Lisp has developed its own notion of what to display, how to display it, and what sort of arguments can be used to customize it. trivial-backtrace is a simple solution to generating a backtrace portably.")
+     (home-page "https://common-lisp.net/project/trivial-backtrace/")
+     (license license:bsd-style)
+     (version (string-append "0.0.0-" (string-take commit-hash 7)))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/gwkkwg/trivial-backtrace.git")
+             (commit commit-hash)))
+       (sha256 (base32 "10p41p43skj6cimdg8skjy7372s8v2xpkg8djjy0l8rm45i654k1"))))
+     (inputs
+      `(("sbcl-lift" ,sbcl-lift)))
+     (build-system asdf-build-system/sbcl))))
+
+(define-public cl-trivial-backtrace
+  (sbcl-package->cl-source-package sbcl-trivial-backtrace))
+
+(define-public sbcl-rfc2388
+  (let ((commit-hash "591bcf7e77f2c222c43953a80f8c297751dc0c4e"))
+    (package
+     (name "sbcl-rfc2388")
+     (synopsis "An implementation of RFC 2388 in Common Lisp.")
+     (description "This package contains an implementation of RFC 2388, which is used to process form data posted with HTTP POST method using enctype \"multipart/form-data\".")
+     (home-page "https://github.com/jdz/rfc2388/")
+     (license license:bsd-2)
+     (version (string-append "0.0.0-" (string-take commit-hash 7)))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/jdz/rfc2388.git")
+             (commit commit-hash)))
+       (sha256 (base32 "0phh5n3clhl9ji8jaxrajidn22d3f0aq87mlbfkkxlnx2pnw694k"))))
+     (build-system asdf-build-system/sbcl))))
+
+(define-public cl-rfc2388
+  (sbcl-package->cl-source-package sbcl-rfc2388))
+
+(define-public sbcl-md5
+  (let ((version "2.0.4"))
+    (package
+      (name "sbcl-md5")
+      (synopsis "Common Lisp implementation of the MD5 Message-Digest Algorithm (RFC 1321).")
+      (description "This package implements The MD5 Message-Digest Algorithm, as defined in RFC 1321 by R. Rivest, published April 1992.")
+      (home-page "https://github.com/pmai/md5")
+      (license license:public-domain)
+      (version version)
+      (source
+       (origin
+         (method url-fetch)
+         (uri (string-append "https://github.com/pmai/md5/archive/release-" version ".tar.gz"))
+         (sha256 (base32 "19yl9n0pjdz5gw4qi711lka97xcd9f81ylg434hk7jwn9f2s6w11"))))
+      (build-system asdf-build-system/sbcl))))
+
+(define-public cl-md5
+  (sbcl-package->cl-source-package sbcl-md5))
+
+(define-public sbcl-cl+ssl
+  (let ((commit-hash "b81c1135cf5700e870ce2573d5035d249e491788"))
+    (package
+      (name "sbcl-cl+ssl")
+      (synopsis "Common Lisp bindings to OpenSSL.")
+      (description "This library is a fork of SSL-CMUCL. The original SSL-CMUCL source code was written by Eric Marsden and includes contributions by Jochen Schmidt. Development into CL+SSL was done by David Lichteblau.")
+      (home-page "http://common-lisp.net/project/cl-plus-ssl/")
+      (license license:expat)
+      (version (string-append "0.0.0-" (string-take commit-hash 7)))
+      (source
+       (origin
+         (method git-fetch)
+         (uri (git-reference
+               (url "https://github.com/cl-plus-ssl/cl-plus-ssl.git")
+               (commit commit-hash)))
+         (sha256 (base32 "1845i1pafmqb6cdlr53yaqy67kjrhkvbx6c37ca15cw70vhdr3z9"))))
+      (inputs
+       `(("sbcl-cffi" ,sbcl-cffi)
+         ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)
+         ("sbcl-flexi-streams" ,sbcl-flexi-streams)
+         ("sbcl-bordeaux-threads" ,sbcl-bordeaux-threads)
+         ("sbcl-trivial-garbage" ,sbcl-trivial-garbage)))
+      (propagated-inputs `(("openssl" ,openssl)))
+      (build-system asdf-build-system/sbcl)
+      (arguments
+       `(#:phases
+         (modify-phases
+             %standard-phases
+           (add-after 'unpack 'fix-paths
+             (lambda* (#:key inputs #:allow-other-keys)
+               (substitute* "src/reload.lisp"
+                 (("libssl.so" all) (string-append
+                                     (assoc-ref inputs "openssl") "/lib/" all)))))))))))
+
+(define-public cl-cl+ssl
+  (sbcl-package->cl-source-package sbcl-cl+ssl))
+
+(define-public sbcl-kmrcl
+  (let ((version "1.109.0")
+        (commit-hash "5260068b2eb735af6796740c2db4955afac21636"))
+    (package
+      (name "sbcl-kmrcl")
+      (synopsis "KMRCL is a collection of utilities used by a number of Kevin Rosenberg's CL packages.")
+      (description "KMRCL is a collection of utilities used by a number of Kevin Rosenberg's CL packages.")
+      (home-page "http://files.kpe.io/kmrcl/")
+      (license license:llgpl)
+      (version (string-append version "-" (string-take commit-hash 7)))
+      (source
+       (origin
+         (method git-fetch)
+         (uri (git-reference
+               (url "http://git.kpe.io/kmrcl.git/")
+               (commit commit-hash)))
+         (sha256 (base32 "1va7xjgzfv674bpsli674i7zj3f7wg5kxic41kz18r6hh4n52dfv"))))
+      (inputs
+       `(("sbcl-rt" ,sbcl-rt)))
+      (build-system asdf-build-system/sbcl)
+      (arguments
+       ;; Tests fail with: :FORCE and :FORCE-NOT arguments not allowed
+       ;; in a nested call to ASDF/OPERATE:OPERATE unless identically
+       ;; to toplevel
+       `(#:tests? #f)))))
+
+(define-public cl-kmrcl
+  (sbcl-package->cl-source-package sbcl-kmrcl))
+
+(define-public sbcl-cl-base64
+  (let ((version "3.3.3"))
+    (package
+      (name "sbcl-cl-base64")
+      (synopsis "Common Lisp package to encode and decode base64 with URI support")
+      (description "This package provides highly optimized base64 encoding and decoding. Besides conversion to and from strings, integer conversions are supported. Encoding with Uniform Resource Identifiers is supported by using a modified encoding table that uses only URI-compatible characters.")
+      (home-page "http://files.kpe.io/cl-base64/")
+      (license license:bsd-3)
+      (version version)
+      (source
+       (origin
+         (method git-fetch)
+         (uri (git-reference
+               (url "http://git.kpe.io/cl-base64.git")
+               (commit (string-append "v" version))))
+         (sha256 (base32 "1dw6j7n6gsd2qa0p0rbsjxj00acxx3i9ca1qkgl0liy8lpnwkypl"))))
+      (inputs
+       `(("sbcl-ptester" ,sbcl-ptester)
+         ("sbcl-kmrcl" ,sbcl-kmrcl)))
+      (build-system asdf-build-system/sbcl)
+      (arguments
+       ;; Tests fail with: :FORCE and :FORCE-NOT arguments not allowed
+       ;; in a nested call to ASDF/OPERATE:OPERATE unless identically
+       ;; to toplevel
+       `(#:tests? #f)))))
+
+(define-public cl-cl-base64
+  (sbcl-package->cl-source-package sbcl-cl-base64))
+
+(define-public sbcl-chunga
+  (let ((version "1.1.7"))
+    (package
+      (name "sbcl-chunga")
+      (synopsis "Portable chunked streams for Common Lisp")
+      (description "Chunga implements streams capable of chunked encoding on demand as defined in RFC 2616.")
+      (home-page "https://edicl.github.io/chunga/")
+      (license license:bsd-2)
+      (version version)
+      (source
+       (origin
+         (method url-fetch)
+         (uri (string-append "https://github.com/edicl/chunga/archive/v" version ".tar.gz"))
+         (sha256 (base32 "0ra17kyc9l7qbaw003ly111r1cbn4zixbfq1ydr9cxw10v30q1n7"))))
+      (inputs
+       `(("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)))
+      (build-system asdf-build-system/sbcl))))
+
+(define-public cl-chunga
+  (sbcl-package->cl-source-package sbcl-chunga))
+
+(define-public sbcl-cl-who
+  (let ((version "1.1.4")
+        (commit-hash "2c08caa4bafba720409af9171feeba3f32e86d32"))
+    (package
+     (name "sbcl-cl-who")
+     (synopsis "Yet another Lisp markup language.")
+     (description
+      "There are plenty of Lisp Markup Languages out there - every Lisp programmer seems to write at least one during his career - and CL-WHO (where WHO means \"with-html-output\" for want of a better acronym) is probably just as good or bad as the next one.")
+     (home-page "https://edicl.github.io/cl-who/")
+     (license license:bsd-2)
+     (version (string-append version (string-take commit-hash 7)))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/edicl/cl-who.git")
+             (commit commit-hash)))
+       (file-name (git-file-name name version))
+       (sha256
+        (base32
+         "0yjb6sr3yazm288m318kqvj9xk8rm9n1lpimgf65ymqv0i5agxsb"))))
+     (native-inputs
+      `(("sbcl-flexi-streams" ,sbcl-flexi-streams)))
+     (build-system asdf-build-system/sbcl))))
+
+(define-public cl-cl-who
+  (sbcl-package->cl-source-package sbcl-cl-who))
+
+(define-public sbcl-chipz
+  (let ((version "0.8")
+        (commit-hash "75dfbc660a5a28161c57f115adf74c8a926bfc4d"))
+    (package
+     (name "sbcl-chipz")
+     (synopsis "A Common Lisp library for decompressing deflate, zlib, gzip, and bzip2 data.")
+     (description
+      "DEFLATE data, defined in RFC1951, forms the core of popular compression formats such as zlib (RFC 1950) and gzip (RFC 1952). As such, Chipz also provides for decompressing data in those formats as well. BZIP2 is the format used by the popular compression tool bzip2.")
+     (home-page "http://method-combination.net/lisp/chipz/")
+     (license license:expat)   ; The author describes it as "MIT-like"
+     (version (string-append version (string-take commit-hash 7)))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/froydnj/chipz.git")
+             (commit commit-hash)))
+       (file-name (git-file-name name version))
+       (sha256
+        (base32
+         "0plx4rs39zbs4gjk77h4a2q11zpy75fh9v8hnxrvsf8fnakajhwg"))))
+     (native-inputs
+      `(("sbcl-flexi-streams" ,sbcl-flexi-streams)))
+     (build-system asdf-build-system/sbcl))))
+
+(define-public cl-chipz
+  (sbcl-package->cl-source-package sbcl-chipz))
+
+(define-public sbcl-drakma
+  (let ((version "2.0.4")
+        (commit-hash "7647c0ae842ff2058624e53979c7f297760c97a7"))
+    (package
+     (name "sbcl-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.")
+     (home-page "https://edicl.github.io/drakma/")
+     (license license:bsd-2)
+     (version (string-append version (string-take commit-hash 7)))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/edicl/drakma.git")
+             (commit commit-hash)))
+       (file-name (git-file-name name version))
+       (sha256
+        (base32
+         "1c4i9wakhj5pxfyyykxshdmv3180sbkrx6fcyynikmc0jd0rh84r"))))
+     (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)))
+     (build-system asdf-build-system/sbcl))))
+
+(define-public cl-drakma
+  (sbcl-package->cl-source-package sbcl-drakma))
+
+(define-public sbcl-hunchentoot
+  (let ((version "1.2.38"))
+    (package
+     (name "sbcl-hunchentoot")
+     (synopsis "Web server written in Common Lisp")
+     (description
+      "Hunchentoot is a web server written in Common Lisp and at the same time a toolkit for building dynamic websites. As a stand-alone web server, Hunchentoot is capable of HTTP/1.1 chunking (both directions), persistent connections (keep-alive), and SSL.")
+     (home-page "https://edicl.github.io/hunchentoot/")
+     (license license:bsd-2)
+     (version version)
+     (source
+      (origin
+       (method url-fetch)
+       (uri (string-append "https://github.com/edicl/hunchentoot/archive/v" version ".tar.gz"))
+       (sha256 (base32 "17z8rpd6b5w93jwrdwfwxjha617xnjqw8aq1hw2z76zp1fn8yrmh"))))
+     (inputs
+      `(("sbcl-chunga" ,sbcl-chunga)
+        ("sbcl-cl-base64" ,sbcl-cl-base64)
+        ("sbcl-cl-fad" ,sbcl-cl-fad)
+        ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
+        ("sbcl-flexi-streams" ,sbcl-flexi-streams)
+        ("sbcl-cl+ssl" ,sbcl-cl+ssl)
+        ("sbcl-md5" ,sbcl-md5)
+        ("sbcl-rfc2388" ,sbcl-rfc2388)
+        ("sbcl-trivial-backtrace" ,sbcl-trivial-backtrace)
+        ("sbcl-usocket" ,sbcl-usocket)))
+     (native-inputs
+      `(("sbcl-cl-who" ,sbcl-cl-who)
+        ("sbcl-drakma" ,sbcl-drakma)))
+     (build-system asdf-build-system/sbcl))))
+
+(define-public cl-hunchentoot
+  (sbcl-package->cl-source-package sbcl-hunchentoot))
+
+(define-public sbcl-trivial-types
+  (package
+   (name "sbcl-trivial-types")
+   (synopsis "Trivial type definitions for Common Lisp")
+   (description
+    "TRIVIAL-TYPES provides missing but important type definitions such as PROPER-LIST, ASSOCIATION-LIST, PROPERTY-LIST and TUPLE.")
+   (home-page "https://github.com/m2ym/trivial-types")
+   (license license:llgpl)
+   (version "0.0.1")
+   (source
+    (origin
+     (method git-fetch)
+     (uri (git-reference
+           (url "https://github.com/m2ym/trivial-types.git")
+           (commit "ee869f2b7504d8aa9a74403641a5b42b16f47d88")))
+     (sha256 (base32 "1s4cp9bdlbn8447q7w7f1wkgwrbvfzp20mgs307l5pxvdslin341"))))
+   (build-system asdf-build-system/sbcl)))
+
+(define-public cl-trivial-types
+  (sbcl-package->cl-source-package sbcl-trivial-types))
+
+(define-public sbcl-cl-syntax
+  (package
+   (name "sbcl-cl-syntax")
+   (synopsis "Reader Syntax Coventions for Common Lisp and SLIME")
+   (description "CL-SYNTAX provides Reader Syntax Coventions for Common Lisp and SLIME.")
+   (home-page "https://github.com/m2ym/cl-syntax")
+   (license license:llgpl)
+   (version "0.0.3")
+   (source
+    (origin
+     (method git-fetch)
+     (uri (git-reference
+           (url "https://github.com/m2ym/cl-syntax.git")
+           (commit "03f0c329bbd55b8622c37161e6278366525e2ccc")))
+     (sha256 (base32 "17ran8xp77asagl31xv8w819wafh6whwfc9p6dgx22ca537gyl4y"))))
+   (inputs `(("sbcl-trivial-types" ,sbcl-trivial-types)
+             ("sbcl-named-readtables" ,sbcl-named-readtables)))
+   (build-system asdf-build-system/sbcl)
+   (arguments
+    '(#:asd-file "cl-syntax.asd"
+      #:asd-system-name "cl-syntax"))))
+
+(define-public cl-cl-syntax
+  (sbcl-package->cl-source-package sbcl-cl-syntax))
+
+(define-public sbcl-cl-annot
+  (let ((commit-hash "c99e69c15d935eabc671b483349a406e0da9518d"))
+    (package
+     (name "sbcl-cl-annot")
+     (synopsis "Python-like Annotation Syntax for Common Lisp.")
+     (description "cl-annot is an general annotation library for Common Lisp.")
+     (home-page "https://github.com/m2ym/cl-annot")
+     (license license:llgpl)
+     (version (string-append "0.0.0-" (string-take commit-hash 7)))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/m2ym/cl-annot.git")
+             (commit commit-hash)))
+       (sha256 (base32 "1wq1gs9jjd5m6iwrv06c2d7i5dvqsfjcljgbspfbc93cg5xahk4n"))))
+     (inputs
+      `(("sbcl-alexandria" ,sbcl-alexandria)))
+     (build-system asdf-build-system/sbcl))))
+
+(define-public cl-cl-annot
+  (sbcl-package->cl-source-package sbcl-cl-annot))
+
+(define-public sbcl-cl-syntax-annot
+  (package
+   (name "sbcl-cl-syntax-annot")
+   (synopsis "Reader Syntax Coventions for Common Lisp and SLIME")
+   (description "CL-SYNTAX provides Reader Syntax Coventions for Common Lisp and SLIME.")
+   (home-page "https://github.com/m2ym/cl-syntax")
+   (license license:llgpl)
+   (version "0.0.3")
+   (source
+    (origin
+     (method git-fetch)
+     (uri (git-reference
+           (url "https://github.com/m2ym/cl-syntax.git")
+           (commit "03f0c329bbd55b8622c37161e6278366525e2ccc")))
+     (sha256 (base32 "17ran8xp77asagl31xv8w819wafh6whwfc9p6dgx22ca537gyl4y"))))
+   (inputs `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
+             ("sbcl-cl-annot" ,sbcl-cl-annot)))
+   (build-system asdf-build-system/sbcl)
+   (arguments
+    '(#:asd-file "cl-syntax-annot.asd"
+      #:asd-system-name "cl-syntax-annot"))))
+
+(define-public cl-cl-syntax-annot
+  (sbcl-package->cl-source-package sbcl-cl-syntax-annot))
+
+(define-public sbcl-myway
+  (let ((commit-hash "286230082a11f879c18b93f17ca571c5f676bfb7"))
+    (package
+     (name "sbcl-myway")
+     (synopsis "Sinatra-compatible URL routing library for Common Lisp")
+     (description "My Way is a Sinatra-compatible URL routing library.")
+     (home-page "https://github.com/fukamachi/myway")
+     (license license:llgpl)
+     (version (string-append "0.1.0-" (string-take commit-hash 7)))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/fukamachi/myway.git")
+             (commit commit-hash)))
+       (sha256 (base32 "0briia9bk3lbr0frnx39d1qg6i38dm4j6z9w3yga3d40k6df4a90"))))
+     (inputs
+      `(("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
+        ("sbcl-quri" ,sbcl-quri)
+        ("sbcl-map-set" ,sbcl-map-set)))
+     (native-inputs
+      `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+        ("sbcl-prove" ,sbcl-prove)))
+     (build-system asdf-build-system/sbcl)
+     (arguments
+      ;; Tests fail with: Component MYWAY-ASD::MYWAY-TEST not found,
+      ;; required by #<SYSTEM "myway">. Why?
+      '(#:tests? #f)))))
+
+(define-public cl-myway
+  (sbcl-package->cl-source-package sbcl-myway))
+
+(define-public sbcl-cl-utilities
+  (let ((commit-hash "dce2d2f6387091ea90357a130fa6d13a6776884b"))
+    (package
+     (name "sbcl-cl-utilities")
+     (synopsis "A collection of semi-standard utilities")
+     (description
+      "On Cliki.net <http://www.cliki.net/Common%20Lisp%20Utilities>, there is a collection of Common Lisp Utilities, things that everybody writes since they're not part of the official standard. There are some very useful things there; the only problems are that they aren't implemented as well as you'd like (some aren't implemented at all) and they aren't conveniently packaged and maintained. It takes quite a bit of work to carefully implement utilities for common use, commented and documented, with error checking placed everywhere some dumb user might make a mistake.")
+     (home-page "http://common-lisp.net/project/cl-utilities")
+     (license license:public-domain)
+     (version (string-append "0.0.0-" (string-take commit-hash 7)))
+     (source
+      (origin
+       (method url-fetch)
+       (uri (string-append "https://gitlab.common-lisp.net/cl-utilities/cl-utilities/-/archive/dce2d2f6387091ea90357a130fa6d13a6776884b/cl-utilities-" commit-hash ".tar.gz"))
+       (sha256 (base32 "1r46v730yf96nk2vb24qmagv9x96xvd08abqwhf02ghgydv1a7z2"))))
+     (build-system asdf-build-system/sbcl)
+     (arguments
+       `(#:phases
+         (modify-phases %standard-phases
+           (add-after 'unpack 'fix-paths
+             (lambda* (#:key inputs #:allow-other-keys)
+               (substitute* "rotate-byte.lisp"
+                            (("in-package :cl-utilities)" all)
+                             "in-package :cl-utilities)\n\n#+sbcl\n(require :sb-rotate-byte)"))))))))))
+
+(define-public cl-cl-utilities
+  (sbcl-package->cl-source-package sbcl-cl-utilities))
+
+(define-public sbcl-map-set
+  (let ((commit-hash "7b4b545b68b8"))
+    (package
+     (name "sbcl-map-set")
+     (synopsis "Implementation of a set-like data structure with constant time addition, removal, and random selection.")
+     (description "Implementation of a set-like data structure with constant time addition, removal, and random selection.")
+     (home-page "https://bitbucket.org/tarballs_are_good/map-set")
+     (license license:bsd-3)
+     (version (string-append "0.0.0-" (string-take commit-hash 7)))
+     (source
+      (origin
+       (method url-fetch)
+       (uri (string-append "https://bitbucket.org/tarballs_are_good/map-set/get/" commit-hash ".tar.gz"))
+       (sha256 (base32 "1sx5j5qdsy5fklspfammwb16kjrhkggdavm922a9q86jm5l0b239"))))
+     (build-system asdf-build-system/sbcl))))
+
+(define-public cl-map-set
+  (sbcl-package->cl-source-package sbcl-map-set))
+
+(define-public sbcl-quri
+  (let ((commit-hash "76b75103f21ead092c9f715512fa82441ef61185"))
+    (package
+     (name "sbcl-quri")
+     (synopsis "Yet another URI library for Common Lisp")
+     (description "QURI (pronounced \"Q-ree\") is yet another URI library for Common Lisp. It is intended to be a replacement of PURI.")
+     (home-page "https://github.com/fukamachi/quri")
+     (license license:bsd-3)
+     (version (string-append "0.1.0-" (string-take commit-hash 7)))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/fukamachi/quri.git")
+             (commit commit-hash)))
+       (sha256 (base32 "1ccbxsgzdibmzq33mmbmmz9vwl6l03xh6nbpsh1hkdvdcl7q0a60"))))
+     (inputs `(("sbcl-babel" ,sbcl-babel)
+               ("sbcl-split-sequence" ,sbcl-split-sequence)
+               ("sbcl-cl-utilities" ,sbcl-cl-utilities)
+               ("sbcl-alexandria" ,sbcl-alexandria)))
+     (native-inputs `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+                      ("sbcl-prove" ,sbcl-prove)))
+     (arguments
+      ;; Tests fail with: Component QURI-ASD::QURI-TEST not found,
+      ;; required by #<SYSTEM "quri">. Why?
+      '(#:tests? #f))
+     (build-system asdf-build-system/sbcl))))
+
+(define-public cl-quri
+  (sbcl-package->cl-source-package sbcl-quri))
+
+(define-public sbcl-smart-buffer
+  (let ((commit-hash "09b9a9a0b3abaa37abe9a730f5aac2643dca4e62"))
+    (package
+     (name "sbcl-smart-buffer")
+     (synopsis "Smart octets buffer.")
+     (description "Smart-buffer provides an output buffer which changes the destination depending on content size.")
+     (home-page "https://github.com/fukamachi/smart-buffer")
+     (license license:bsd-3)
+     (version (string-append "0.0.1-" (string-take commit-hash 7)))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/fukamachi/smart-buffer")
+             (commit commit-hash)))
+       (sha256 (base32 "0qz1zzxx0wm5ff7gpgsq550a59p0qj594zfmm2rglj97dahj54l7"))))
+     (inputs `(;; ("sbcl-alexandria" ,sbcl-alexandria)
+               ;; ("sbcl-proc-parse" ,sbcl-proc-parse)
+               ("sbcl-xsubseq" ,sbcl-xsubseq)
+               ("sbcl-flexi-streams" ,sbcl-flexi-streams)))
+     (native-inputs
+      `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+        ("sbcl-prove" ,sbcl-prove)))
+     (build-system asdf-build-system/sbcl)
+     (arguments
+      ;; Tests fail with: Component SMART-BUFFER-ASD::SMART-BUFFER-TEST not found,
+      ;; required by #<SYSTEM "smart-buffer">. Why?
+      `(#:tests? #f)))))
+
+(define-public cl-smart-buffer
+  (sbcl-package->cl-source-package sbcl-smart-buffer))
+
+(define-public sbcl-xsubseq
+  (let ((commit-hash "5ce430b3da5cda3a73b9cf5cee4df2843034422b"))
+    (package
+     (name "sbcl-xsubseq")
+     (synopsis "Efficient way to use \"subseq\"s in Common Lisp")
+     (description "XSubseq provides functions to be able to handle \"subseq\"s more effieiently.")
+     (home-page "https://github.com/fukamachi/xsubseq")
+     (license license:bsd-2)
+     (version (string-append "0.0.1-" (string-take commit-hash 7)))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/fukamachi/xsubseq")
+             (commit commit-hash)))
+       (sha256 (base32 "1xz79q0p2mclf3sqjiwf6izdpb6xrsr350bv4mlmdlm6rg5r99px"))))
+     (native-inputs
+      `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+        ("sbcl-prove" ,sbcl-prove)))
+     (build-system asdf-build-system/sbcl)
+     (arguments
+      ;; Tests fail with: Component XSUBSEQ-ASD::XSUBSEQ-TEST not found,
+      ;; required by #<SYSTEM "xsubseq">. Why?
+      `(#:tests? #f)))))
+
+(define-public cl-xsubseq
+  (sbcl-package->cl-source-package sbcl-xsubseq))
+
+(define-public sbcl-fast-http
+  (let ((commit-hash "f9e7597191bae380503e20724fd493a24d024935"))
+    (package
+     (name "sbcl-fast-http")
+     (synopsis "A fast HTTP request/response parser for Common Lisp.")
+     (description "This is a fast HTTP request/response protocol parser for Common Lisp.")
+     (home-page "https://github.com/fukamachi/fast-http")
+     (license license:expat)        ; Author specified the MIT license
+     (version (string-append "0.2.0-" (string-take commit-hash 7)))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/fukamachi/fast-http")
+             (commit commit-hash)))
+       (sha256 (base32 "0qdmwv2zm0sizxdb8nnclgwl0nfjcbjaimbakavikijw7lr9b4jp"))))
+     (inputs
+      `(("sbcl-alexandria" ,sbcl-alexandria)
+        ("sbcl-proc-parse" ,sbcl-proc-parse)
+        ("sbcl-xsubseq" ,sbcl-xsubseq)
+        ("sbcl-smart-buffer" ,sbcl-smart-buffer)
+        ("sbcl-cl-utilities" ,sbcl-cl-utilities)))
+     (native-inputs
+      `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+        ("sbcl-prove" ,sbcl-prove)))
+     (build-system asdf-build-system/sbcl)
+     (arguments
+      ;; Tests fail with: Component FAST-HTTP-ASD::FAST-HTTP-TEST not
+      ;; found, required by #<SYSTEM "fast-http">. Why?
+      `(#:tests? #f)))))
+
+(define-public cl-fast-http
+  (sbcl-package->cl-source-package sbcl-fast-http))
+
+(define-public sbcl-static-vectors
+  (let ((commit-hash "0681eac1f49370cde03e64b077251e8abf47d702"))
+    (package
+     (name "sbcl-static-vectors")
+     (synopsis "Allocate SIMPLE-ARRAYs in static memory")
+     (description "Allocate SIMPLE-ARRAYs in static memory")
+     (home-page "http://common-lisp.net/projects/iolib/")
+     (license license:expat)         ; Author specified an MIT license
+     (version (string-append "1.8.3-" (string-take commit-hash 7)))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/sionescu/static-vectors.git")
+             (commit commit-hash)))
+       (sha256 (base32 "138nlsq14hv8785ycjm6jw3i6ablhq8vcwys7q09y80arcgrg6r3"))))
+     (inputs
+      `(("sbcl-cffi-grovel" ,sbcl-cffi-grovel)
+        ("sbcl-cffi" ,sbcl-cffi)))
+     (native-inputs
+      `(("sbcl-fiveam" ,sbcl-fiveam)))
+     (build-system asdf-build-system/sbcl))))
+
+(define-public cl-static-vectors
+  (sbcl-package->cl-source-package sbcl-static-vectors))
+
+(define-public sbcl-marshal
+  (let ((commit-hash "eff1b15f2b0af2f26f71ad6a4dd5c4beab9299ec"))
+    (package
+     (name "sbcl-marshal")
+     (synopsis "Simple and fast serialization of all kinds of Common Lisp data structures.")
+     (description
+      "Simple and fast marshalling of Lisp datastructures. Convert any object into a string representation, put it on a stream an revive it from there. Only minimal changes required to make your CLOS objects serializable.")
+     (home-page "https://github.com/wlbr/cl-marshal")
+     (license license:expat)         ; Author specified an MIT license
+     (version (string-append "1.3.0-" (string-take commit-hash 7)))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/wlbr/cl-marshal.git")
+             (commit commit-hash)))
+       (sha256 (base32 "08qs6fhk38xpkkjkpcj92mxx0lgy4ygrbbzrmnivdx281syr0gwh"))))
+     (build-system asdf-build-system/sbcl))))
+
+(define-public cl-marshal
+  (sbcl-package->cl-source-package sbcl-marshal))
+
+(define-public sbcl-checkl
+  (let ((commit-hash "80328800d047fef9b6e32dfe6bdc98396aee3cc9"))
+    (package
+     (name "sbcl-checkl")
+     (synopsis "Why write programs in Common Lisp but tests like Java? Meet CheckL!")
+     (description "TODO")
+     (home-page "")
+     ;; The author specifies both LLGPL and "BSD", but the "BSD"
+     ;; license isn't specified anywhere, so I don't know which kind.
+     ;; LLGPL is the stronger of the two and so I think only listing
+     ;; this should suffice.
+     (license license:llgpl)
+     (version (string-append "0.0.0-" (string-take commit-hash 7)))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/rpav/CheckL.git")
+             (commit commit-hash)))
+       (sha256 (base32 "0bpisihx1gay44xmyr1dmhlwh00j0zzi04rp9fy35i95l2r4xdlx"))))
+     (inputs
+      `(("sbcl-marshal" ,sbcl-marshal)))
+     (native-inputs
+      `(("sbcl-fiveam" ,sbcl-fiveam)))
+     (build-system asdf-build-system/sbcl)
+     (arguments
+      ;; Error while trying to load definition for system checkl-test
+      ;; from pathname [...]/checkl-test.asd: The function
+      ;; CHECKL:DEFINE-TEST-OP is undefined.
+      '(#:tests? #f)))))
+
+(define-public cl-checkl
+  (sbcl-package->cl-source-package sbcl-checkl))
+
+(define-public sbcl-fast-io
+  (let ((commit-hash "dc3a71db7e9b756a88781ae9c342fe9d4bbab51c"))
+    (package
+     (name "sbcl-fast-io")
+     (synopsis "Fast octet-vector/stream I/O for Common Lisp")
+     (description
+      "Fast-io is about improving performance to octet-vectors and octet streams (though primarily the former, while wrapping the latter).")
+     (home-page "https://github.com/rpav/fast-io")
+     (license license:bsd-3) ; Author specifies this as NewBSD which is an alias
+     (version (string-append "1.0.0-" (string-take commit-hash 7)))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/rpav/fast-io.git")
+             (commit commit-hash)))
+       (sha256 (base32 "1jsp6xvi26ln6fdy5j5zi05xvan8jsqdhisv552dy6xg6ws8i1yq"))))
+     (inputs
+      `(("sbcl-alexandria" ,sbcl-alexandria)
+        ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)
+        ("sbcl-static-vectors" ,sbcl-static-vectors)))
+     (native-inputs
+      `(("sbcl-fiveam" ,sbcl-fiveam)
+        ("sbcl-checkl" ,sbcl-checkl)))
+     (build-system asdf-build-system/sbcl)
+     (arguments
+      ;; Error while trying to load definition for system fast-io-test
+      ;; from pathname [...]/fast-io-test.asd: The function
+      ;; CHECKL:DEFINE-TEST-OP is undefined.
+      '(#:tests? #f)))))
+
+(define-public cl-fast-io
+  (sbcl-package->cl-source-package sbcl-fast-io))
+
+(define-public sbcl-jonathan
+  (let ((commit-hash "1f448b4f7ac8265e56e1c02b32ce383e65316300"))
+    (package
+     (name "sbcl-jonathan")
+     (synopsis "JSON encoder and decoder.")
+     (description "It's faster than jsown - high performance Common Lisp json parser.")
+     (home-page "http://rudolph-miller.github.io/jonathan/overview.html")
+     (license license:expat)        ; Author specifies the MIT license
+     (version (string-append "0.1.0-" (string-take commit-hash 7)))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/Rudolph-Miller/jonathan.git")
+             (commit commit-hash)))
+       (sha256 (base32 "14x4iwz3mbag5jzzzr4sb6ai0m9r4q4kyypbq32jmsk2dx1hi807"))))
+     (inputs
+      `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
+        ("sbcl-cl-syntax-annot" ,sbcl-cl-syntax-annot)
+        ("sbcl-fast-io" ,sbcl-fast-io)
+        ("sbcl-proc-parse" ,sbcl-proc-parse)
+        ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)))
+     (native-inputs
+      `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+        ("sbcl-prove" ,sbcl-prove)))
+     (build-system asdf-build-system/sbcl)
+     (arguments
+      ;; Tests fail with: Component JONATHAN-ASD::JONATHAN-TEST not
+      ;; found, required by #<SYSTEM "jonathan">. Why?
+      `(#:tests? #f)))))
+
+(define-public cl-jonathan
+  (sbcl-package->cl-source-package sbcl-jonathan))
+
+(define-public sbcl-http-body
+  (let ((commit-hash "dd01dc4f5842e3d29728552e5163acce8386eb73"))
+    (package
+     (name "sbcl-http-body")
+     (synopsis "HTTP POST data parser.")
+     (description "HTTP-Body parses HTTP POST data and returns POST parameters. It supports application/x-www-form-urlencoded, application/json, and multipart/form-data.")
+     (home-page "https://github.com/fukamachi/http-body")
+     (license license:bsd-2)
+     (version (string-append "0.1.0-" (string-take commit-hash 7)))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/fukamachi/http-body")
+             (commit commit-hash)))
+       (sha256 (base32 "1jd06snjvxcprhapgfq8sx0y5lrldkvhf206ix6d5a23dd6zcmr0"))))
+     (inputs
+      `(("sbcl-fast-http" ,sbcl-fast-http)
+        ("sbcl-jonathan" ,sbcl-jonathan)
+        ("sbcl-quri" ,sbcl-quri)))
+     (native-inputs
+      `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+        ("sbcl-prove" ,sbcl-prove)))
+     (build-system asdf-build-system/sbcl)
+     (arguments
+      ;; Tests fail with: Component HTTP-BODY-ASD::HTTP-BODY-TEST not
+      ;; found, required by #<SYSTEM "http-body">. Why?
+      `(#:tests? #f)))))
+
+(define-public cl-http-body
+  (sbcl-package->cl-source-package sbcl-http-body))
+
+(define-public sbcl-circular-streams
+  (let ((commit-hash "e770bade1919c5e8533dd2078c93c3d3bbeb38df"))
+    (package
+     (name "sbcl-circular-streams")
+     (synopsis "Circularly readable streams for Common Lisp.")
+     (description
+      "Circular-Streams allows you to read streams circularly by wrapping real streams. Once you reach end-of-file of a stream, it's file position will be reset to 0 and you're able to read it again.")
+     (home-page "https://github.com/fukamachi/circular-streams")
+     (license license:llgpl)
+     (version (string-append "0.1.0-" (string-take commit-hash 7)))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/fukamachi/circular-streams")
+             (commit commit-hash)))
+       (sha256 (base32 "1wpw6d5cciyqcf92f7mvihak52pd5s47kk4qq6f0r2z2as68p5rs"))))
+     (inputs
+      `(("sbcl-fast-io" ,sbcl-fast-io)
+        ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)))
+     (build-system asdf-build-system/sbcl)
+     (arguments
+      ;; The tests depend on cl-test-more which is now prove. Prove
+      ;; tests aren't working for some reason.
+      `(#:tests? #f)))))
+
+(define-public cl-circular-streams
+  (sbcl-package->cl-source-package sbcl-circular-streams))
+
+(define-public sbcl-lack-request
+  (let ((commit-hash "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b"))
+    (package
+     (name "sbcl-lack-request")
+     (synopsis "Lack, the core of Clack")
+     (description
+      "Lack is a Common Lisp library which allows web applications to be constructed of modular components. It was originally a part of Clack, however it's going to be rewritten as an individual project since Clack v2 with performance and simplicity in mind.")
+     (home-page "https://github.com/fukamachi/lack")
+     (license license:llgpl)
+     (version (string-append "0.1.0-" (string-take commit-hash 7)))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/fukamachi/lack.git")
+             (commit commit-hash)))
+       (sha256 (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
+     (inputs
+      `(("sbcl-quri" ,sbcl-quri)
+        ("sbcl-http-body" ,sbcl-http-body)
+        ("sbcl-circular-streams" ,sbcl-circular-streams)))
+     (native-inputs
+      `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+        ("sbcl-prove" ,sbcl-prove)))
+     (build-system asdf-build-system/sbcl)
+     (arguments
+      '(#:asd-file "lack-request.asd"
+        #:asd-system-name "lack-request"
+        #:test-asd-file "t-lack-request.asd"
+        #:tests? #f)))))
+
+(define-public cl-lack-request
+  (sbcl-package->cl-source-package sbcl-lack-request))
+
+(define-public sbcl-lack-response
+  (let ((commit-hash "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b"))
+    (package
+     (name "sbcl-lack-response")
+     (synopsis "Lack, the core of Clack")
+     (description
+      "Lack is a Common Lisp library which allows web applications to be constructed of modular components. It was originally a part of Clack, however it's going to be rewritten as an individual project since Clack v2 with performance and simplicity in mind.")
+     (home-page "https://github.com/fukamachi/lack")
+     (license license:llgpl)
+     (version (string-append "0.1.0-" (string-take commit-hash 7)))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/fukamachi/lack.git")
+             (commit commit-hash)))
+       (sha256 (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
+     (inputs
+      `(("sbcl-quri" ,sbcl-quri)
+        ("sbcl-http-body" ,sbcl-http-body)
+        ("sbcl-circular-streams" ,sbcl-circular-streams)
+        ("sbcl-local-time" ,sbcl-local-time)))
+     (native-inputs
+      `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+        ("sbcl-prove" ,sbcl-prove)))
+     (build-system asdf-build-system/sbcl)
+     (arguments
+      '(#:asd-file "lack-response.asd"
+        #:asd-system-name "lack-response"
+        #:test-asd-file "t-lack-response.asd"
+        #:tests? #f)))))
+
+(define-public cl-lack-response
+  (sbcl-package->cl-source-package sbcl-lack-response))
+
+(define-public sbcl-lack-component
+  (let ((commit-hash "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b"))
+    (package
+     (name "sbcl-lack-component")
+     (synopsis "Lack, the core of Clack")
+     (description
+      "Lack is a Common Lisp library which allows web applications to be constructed of modular components. It was originally a part of Clack, however it's going to be rewritten as an individual project since Clack v2 with performance and simplicity in mind.")
+     (home-page "https://github.com/fukamachi/lack")
+     (license license:llgpl)
+     (version (string-append "0.0.0-" (string-take commit-hash 7)))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/fukamachi/lack.git")
+             (commit commit-hash)))
+       (sha256 (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
+     (build-system asdf-build-system/sbcl)
+     (arguments
+      '(#:asd-file "lack-component.asd"
+        #:asd-system-name "lack-component"
+        #:test-asd-file "t-lack-component.asd"
+        #:tests? #f)))))
+
+(define-public cl-lack-component
+  (sbcl-package->cl-source-package sbcl-lack-component))
+
+(define-public sbcl-lack-util
+  (let ((commit-hash "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b"))
+    (package
+     (name "sbcl-lack-util")
+     (synopsis "Lack, the core of Clack")
+     (description
+      "Lack is a Common Lisp library which allows web applications to be constructed of modular components. It was originally a part of Clack, however it's going to be rewritten as an individual project since Clack v2 with performance and simplicity in mind.")
+     (home-page "https://github.com/fukamachi/lack")
+     (license license:llgpl)
+     (version (string-append "0.1.0-" (string-take commit-hash 7)))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/fukamachi/lack.git")
+             (commit commit-hash)))
+       (sha256 (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
+     (inputs
+      `(("sbcl-ironclad" ,sbcl-ironclad)))
+     (build-system asdf-build-system/sbcl)
+     (arguments
+      '(#:asd-file "lack-util.asd"
+        #:asd-system-name "lack-util"
+        #:test-asd-file "t-lack-util.asd"
+        #:tests? #f)))))
+
+(define-public cl-lack-util
+  (sbcl-package->cl-source-package sbcl-lack-util))
+
+(define-public sbcl-lack-middleware-backtrace
+  (let ((commit-hash "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b"))
+    (package
+     (name "sbcl-lack-middleware-backtrace")
+     (synopsis "Lack, the core of Clack")
+     (description
+      "Lack is a Common Lisp library which allows web applications to be constructed of modular components. It was originally a part of Clack, however it's going to be rewritten as an individual project since Clack v2 with performance and simplicity in mind.")
+     (home-page "https://github.com/fukamachi/lack")
+     (license license:llgpl)
+     (version (string-append "0.1.0-" (string-take commit-hash 7)))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/fukamachi/lack.git")
+             (commit commit-hash)))
+       (sha256 (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
+     (build-system asdf-build-system/sbcl)
+     (arguments
+      '(#:asd-file "lack-middleware-backtrace.asd"
+        #:asd-system-name "lack-middleware-backtrace"
+        #:test-asd-file "t-lack-middleware-backtrace.asd"
+        #:tests? #f)))))
+
+(define-public cl-lack-middleware-backtrace
+  (sbcl-package->cl-source-package sbcl-lack-middleware-backtrace))
+
+(define-public sbcl-lack-middleware-static
+  (let ((commit-hash "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b"))
+    (package
+     (name "sbcl-lack-middleware-static")
+     (synopsis "Lack, the core of Clack")
+     (description
+      "Lack is a Common Lisp library which allows web applications to be constructed of modular components. It was originally a part of Clack, however it's going to be rewritten as an individual project since Clack v2 with performance and simplicity in mind.")
+     (home-page "https://github.com/fukamachi/lack")
+     (license license:llgpl)
+     (version (string-append "0.1.0-" (string-take commit-hash 7)))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/fukamachi/lack.git")
+             (commit commit-hash)))
+       (sha256 (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
+     (inputs
+      `(("sbcl-ironclad" ,sbcl-ironclad)
+        ("sbcl-trivial-mimes" ,sbcl-trivial-mimes)
+        ("sbcl-local-time" ,sbcl-local-time)))
+     (build-system asdf-build-system/sbcl)
+     (arguments
+      '(#:asd-file "lack-middleware-static.asd"
+        #:asd-system-name "lack-middleware-static"
+        #:test-asd-file "t-lack-middleware-static.asd"
+        #:tests? #f)))))
+
+(define-public cl-lack-middleware-static
+  (sbcl-package->cl-source-package sbcl-lack-middleware-static))
+
+(define-public sbcl-lack
+  (let ((commit-hash "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b"))
+    (package
+     (name "sbcl-lack")
+     (synopsis "Lack, the core of Clack")
+     (description
+      "Lack is a Common Lisp library which allows web applications to be constructed of modular components. It was originally a part of Clack, however it's going to be rewritten as an individual project since Clack v2 with performance and simplicity in mind.")
+     (home-page "https://github.com/fukamachi/lack")
+     (license license:llgpl)
+     (version (string-append "0.1.0-" (string-take commit-hash 7)))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/fukamachi/lack.git")
+             (commit commit-hash)))
+       (sha256 (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
+     (inputs
+      `(("sbcl-lack-component" ,sbcl-lack-component)
+        ("sbcl-lack-util" ,sbcl-lack-util)))
+     (build-system asdf-build-system/sbcl)
+     (arguments
+      '(#:test-asd-file "t-lack.asd"
+        #:tests? #f)))))
+
+(define-public cl-lack
+  (sbcl-package->cl-source-package sbcl-lack))
+
+(define-public sbcl-local-time
+  (let ((commit-hash "beac054eef428552b63d4ae7820c32ffef9a3015"))
+    (package
+     (name "sbcl-local-time")
+     (synopsis "Time manipulation library for Common Lisp")
+     (description
+      "The LOCAL-TIME library is a Common Lisp library for the manipulation
+of dates and times.  It is based almost entirely upon Erik Naggum's
+paper \"The Long Painful History of Time\".")
+     (home-page "https://common-lisp.net/project/local-time/")
+     (license license:expat)            ; MIT
+     (version (string-append "1.0.6-" (string-take commit-hash 7)))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/dlowe-net/local-time.git")
+             (commit commit-hash)))
+       (sha256 (base32 "0xhkmgxh41dg2wwlsp0h2l41jp144xn4gpxhh0lna6kh0560w2cc"))))
+     (inputs
+      `(("sbcl-cl-fad" ,sbcl-cl-fad)))
+     (native-inputs
+      `(("stefil" ,sbcl-hu.dwim.stefil)))
+     (build-system asdf-build-system/sbcl)
+     (arguments
+      ;; TODO: Component :STEFIL not found, required by #<SYSTEM
+      ;; "local-time/test">
+      '(#:tests? #f)))))
+
+(define-public cl-local-time
+  (sbcl-package->cl-source-package sbcl-local-time))
+
+(define-public sbcl-ningle
+  (let ((commit-hash "50bd4f09b5a03a7249bd4d78265d6451563b25ad"))
+    (package
+      (name "sbcl-ningle")
+      (synopsis "Super micro framework for Common Lisp")
+      (description "Ningle is a lightweight web application framework for Common Lisp.")
+      (home-page "http://8arrow.org/ningle/")
+      (license license:llgpl)
+      (version (string-append "0.3.0-" (string-take commit-hash 7)))
+      (source
+       (origin
+         (method git-fetch)
+         (uri (git-reference
+               (url "https://github.com/fukamachi/ningle.git")
+               (commit commit-hash)))
+         (sha256 (base32 "1bsl8cnxhacb8p92z9n89vhk1ikmij5zavk0m2zvmj7iqm79jzgw"))))
+      (inputs
+       `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
+         ("sbcl-cl-syntax-annot" ,sbcl-cl-syntax-annot)
+         ("sbcl-myway" ,sbcl-myway)
+         ("sbcl-lack-request" ,sbcl-lack-request)
+         ("sbcl-lack-response" ,sbcl-lack-response)
+         ("sbcl-lack-component" ,sbcl-lack-component)
+         ("sbcl-alexandria" ,sbcl-alexandria)
+         ("sbcl-babel" ,sbcl-babel)
+         ))
+      (native-inputs
+       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+         ("sbcl-prove" ,sbcl-prove)))
+      (build-system asdf-build-system/sbcl)
+      (arguments
+       ;; TODO: pull in clack-test
+       '(#:tests? #f
+         #:phases
+         (modify-phases %standard-phases
+           (delete 'cleanup-files)
+           (delete 'cleanup)
+           (add-before 'cleanup 'combine-fasls
+             (lambda* (#:key outputs #:allow-other-keys)
+               (let* ((out (assoc-ref outputs "out"))
+                      (lib (string-append out "/lib/sbcl"))
+                      (ningle-path (string-append lib "/ningle"))
+                      (fasl-files (find-files out "\\.fasl$")))
+                 ;;(system-fasl (string-append lib "/ningle--system.fasl")))
+                 (display (string-append "KT: " ningle-path))
+                 (mkdir-p ningle-path)
+                 (let ((fasl-path (lambda (name)
+                                    (string-append ningle-path "/" (basename name) "--system.fasl"))))
+                   (for-each (lambda (file)
+                               (rename-file file (fasl-path (basename file ".fasl"))))
+                             fasl-files))
+                 ;; (lisp-eval-program
+                 ;;  `((require :uiop)
+                 ;;    (uiop:combine-fasls ',(map fasl-path '("context" "app" "route" "main")) ,system-fasl)
+                 ;;    ;;(uiop:combine-fasls ',fasl-files ,system-fasl)
+                 ;;    ))
+                 )))
+           ;; TODO: Do we need this?
+           ;; (add-after 'create-asd-file 'fix-package-inferred-system
+           ;;            (lambda* (#:key outputs #:allow-other-keys)
+           ;;              (let* ((out (assoc-ref outputs "out"))
+           ;;                     (new-asd-path (string-append out "/lib/sbcl/ningle.asd")))
+           ;;                (substitute* new-asd-path
+           ;;                             ((" \"ningle-main\"" all)
+           ;;                              " \"ningle/main\"")))))
+
+           ;; (add-after 'unpack 'fix-paths
+           ;;            (lambda* (#:key inputs #:allow-other-keys)
+           ;;              ;; (substitute* "ningle.asd"
+           ;;              ;;              (("#:lack.response))" all)
+           ;;              ;;               "#:lack.response))\n\n(register-system-packages \"ningle-main\" '(#:ningle #:ningle/main))"))
+           ;;              ;; (substitute* "ningle.asd"
+           ;;              ;;              (("ningle/main" all)
+           ;;              ;;               "ningle-main"))
+           ;;              (substitute* "main.lisp"
+           ;;                           (("#:ningle$" all)
+           ;;                            "#:ningle/main"))
+           ;;              )
+           ;;            )
+           )
+         )))))
+
+(define-public cl-ningle
+  (sbcl-package->cl-source-package sbcl-ningle))
+
+(define-public sbcl-trivial-mimes
+  (let ((commit-hash "303f8ac0aa6ca0bc139aa3c34822e623c3723fab"))
+    (package
+     (name "sbcl-trivial-mimes")
+     (synopsis "Tiny Common Lisp library to detect mime types in files.")
+     (description "This is a teensy library that provides some functions to determine the mime-type of a file.")
+     (home-page "http://shinmera.github.io/trivial-mimes/")
+     (license license:artistic2.0)
+     (version (string-append "1.1.0-" (string-take commit-hash 7)))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/Shinmera/trivial-mimes.git")
+             (commit commit-hash)))
+       (sha256 (base32 "17jxgl47r695bvsb7wi3n2ws5rp1zzgvw0zii8cy5ggw4b4ayv6m"))))
+     (inputs
+      `(("sbcl-cl-fad" ,sbcl-cl-fad)))
+     (native-inputs
+      `(("stefil" ,sbcl-hu.dwim.stefil)))
+     (build-system asdf-build-system/sbcl)
+     (arguments
+      '(#:phases
+        (modify-phases %standard-phases
+          (add-after 'unpack 'fix-paths
+                      (lambda* (#:key inputs #:allow-other-keys)
+                        (let ((anchor "#p\"/etc/mime.types\""))
+                          (substitute* "mime-types.lisp"
+                             ((anchor all)
+                              (string-append anchor "\n"
+                                             "(asdf:system-relative-pathname :trivial-mimes \"../../share/common-lisp/sbcl-source/trivial-mimes/mime.types\")"))))))))))))
+
+(define-public cl-trivial-mimes
+  (sbcl-package->cl-source-package sbcl-trivial-mimes))
+
+(define-public sbcl-clack
+  (let ((commit-hash "e3e032843bb1220ab96263c411aa7f2feb4746e0"))
+    (package
+     (name "sbcl-clack")
+     (synopsis
+      "Clack is a web application environment for Common Lisp inspired by Python's WSGI and Ruby's Rack.")
+     (description
+      "Clack is a web application environment for Common Lisp inspired by Python's WSGI and Ruby's Rack.")
+     (home-page "https://github.com/fukamachi/clack")
+     (license license:llgpl)
+     (version (string-append "2.0.0-" (string-take commit-hash 7)))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/fukamachi/clack.git")
+             (commit commit-hash)))
+       (sha256 (base32 "1ymzs6qyrwhlj6cgqsnpyn6g5cbp7a3s1vgxwna20y2q7y4iacy0"))))
+     (inputs
+      `(("sbcl-lack" ,sbcl-lack)
+        ("sbcl-lack-middleware-backtrace" ,sbcl-lack-middleware-backtrace)
+        ("sbcl-bordeaux-threads" ,sbcl-bordeaux-threads)))
+     (build-system asdf-build-system/sbcl))))
+
+(define-public cl-clack
+  (sbcl-package->cl-source-package sbcl-clack))
diff --git a/guix/licenses.scm b/guix/licenses.scm
index d22c3fa36e..5c406503a6 100644
--- a/guix/licenses.scm
+++ b/guix/licenses.scm
@@ -65,7 +65,7 @@
             imlib2
             ipa
             knuth
-            lgpl2.0 lgpl2.0+ lgpl2.1 lgpl2.1+ lgpl3 lgpl3+
+            lgpl2.0 lgpl2.0+ lgpl2.1 lgpl2.1+ lgpl3 lgpl3+ llgpl
             lppl lppl1.0+ lppl1.1+ lppl1.2 lppl1.2+
             lppl1.3 lppl1.3+
             lppl1.3a lppl1.3a+
@@ -417,6 +417,11 @@ at URI, which may be a file:// URI pointing the package's tree."
            "https://www.gnu.org/licenses/lgpl.html"
            "https://www.gnu.org/licenses/license-list#LGPLv3"))
 
+(define llgpl
+  (license "LLGPL"
+           "https://opensource.franz.com/preamble.html"
+           "Lisp Lesser General Public License"))
+
 (define lppl
   (license "LPPL (any version)"
            "https://www.latex-project.org/lppl/lppl-1-0/"
-- 
2.20.1


[-- Attachment #3: Type: text/plain, Size: 15 bytes --]


-- 
Katherine