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

all messages for Guix-related lists mirrored at yhetil.org
 help / color / mirror / code / Atom feed

* [bug#34959] [PATCH] Add Multiple Common Lisp Packages
@ 2019-03-23 20:14 Katherine Cox-Buday
       [not found] ` <handler.34959.B.155337211019624.ack@debbugs.gnu.org>
  0 siblings, 1 reply; 12+ messages in thread
From: Katherine Cox-Buday @ 2019-03-23 20:14 UTC (permalink / raw)
  To: 34959

[-- 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

^ permalink raw reply related	[flat|nested] 12+ messages in thread

* [bug#34959] Acknowledgement ([PATCH] Add Multiple Common Lisp Packages)
       [not found] ` <handler.34959.B.155337211019624.ack@debbugs.gnu.org>
@ 2019-03-23 20:41   ` Katherine Cox-Buday
  2019-03-24 10:01     ` Ricardo Wurmus
  0 siblings, 1 reply; 12+ messages in thread
From: Katherine Cox-Buday @ 2019-03-23 20:41 UTC (permalink / raw)
  To: 34959

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

Of course as soon as I push it up and review it I find all the junk i
left in. Here's a cleaner patch, with apologies.


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

From d40bd8e4b7b2637b088ea3c14825fd4062625e22 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 | 1181 ++++++++++++++++++++++++++++++++++++++++-
 guix/licenses.scm     |    7 +-
 2 files changed, 1185 insertions(+), 3 deletions(-)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index 3d43b7c509..095c6e5c4e 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,1179 @@ 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
+      "Why write programs in Common Lisp but tests like Java? Meet CheckL!")
+     (home-page "https://github.com/rpav/CheckL/")
+     ;; 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$")))
+                 (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))
+                             fasl-files)))))))))
+
+(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

^ permalink raw reply related	[flat|nested] 12+ messages in thread

* [bug#34959] Acknowledgement ([PATCH] Add Multiple Common Lisp Packages)
  2019-03-23 20:41   ` [bug#34959] Acknowledgement ([PATCH] Add Multiple Common Lisp Packages) Katherine Cox-Buday
@ 2019-03-24 10:01     ` Ricardo Wurmus
  2019-03-28 17:38       ` Katherine Cox-Buday
  2019-03-29 23:19       ` Katherine Cox-Buday
  0 siblings, 2 replies; 12+ messages in thread
From: Ricardo Wurmus @ 2019-03-24 10:01 UTC (permalink / raw)
  To: Katherine Cox-Buday; +Cc: 34959

Hi Katherine,

> Of course as soon as I push it up and review it I find all the junk i
> left in. Here's a cleaner patch, with apologies.
>
> From d40bd8e4b7b2637b088ea3c14825fd4062625e22 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

thank you for the patch!

We usually expect one commit per independent change.  Could you please
split up this patch into multiple commits?  You can group package
variants like “sbcl-trivial-backtrace” and “cl-trivial-backtrace”, but
separate packages generally each should have their own commit.

> +(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.")

Please break up long lines like this.  Please run “./pre-inst-env guix
lint sbcl-trivial-backtrace”, which will tell you about this problem.

> +     (home-page "https://common-lisp.net/project/trivial-backtrace/")
> +     (license license:bsd-style)
> +     (version (string-append "0.0.0-" (string-take commit-hash 7)))

Please use “git-version” here.  Please also use a revision string, which
allows us to build version strings that can be sorted, e.g. when the
base version is unchanged and a newer commit is “smaller” than the
previous one.

> +     (source
> +      (origin
> +       (method git-fetch)
> +       (uri (git-reference
> +             (url "https://github.com/gwkkwg/trivial-backtrace.git")
> +             (commit commit-hash)))

Throughout you can use “commit” instead of “commit-hash” — there is no
naming conflict.

> +       (sha256 (base32 "10p41p43skj6cimdg8skjy7372s8v2xpkg8djjy0l8rm45i654k1"))))
> +     (inputs
> +      `(("sbcl-lift" ,sbcl-lift)))
> +     (build-system asdf-build-system/sbcl))))

Generally, I would like to suggest to keep the order of fields
consistent with the order used in other packages:

name, source, build-system, arguments, {native-,propagated-,}inputs,
home-page, synopsis, description, license.

--
Ricardo

^ permalink raw reply	[flat|nested] 12+ messages in thread

* [bug#34959] Acknowledgement ([PATCH] Add Multiple Common Lisp Packages)
  2019-03-24 10:01     ` Ricardo Wurmus
@ 2019-03-28 17:38       ` Katherine Cox-Buday
  2019-03-28 20:43         ` Ricardo Wurmus
  2019-03-29 23:19       ` Katherine Cox-Buday
  1 sibling, 1 reply; 12+ messages in thread
From: Katherine Cox-Buday @ 2019-03-28 17:38 UTC (permalink / raw)
  To: Ricardo Wurmus; +Cc: 34959

Ricardo Wurmus <rekado@elephly.net> writes:

Hey Ricardo, thanks for the review. I expect to continue work on this
tomorrow, but I wanted to check in on a few things before I get going.

> We usually expect one commit per independent change.  Could you please
> split up this patch into multiple commits?  You can group package
> variants like “sbcl-trivial-backtrace” and “cl-trivial-backtrace”, but
> separate packages generally each should have their own commit.

This will be a non-trivial amount of work, and these will have to be
chained against each other since this patch forms a dependency graph.
Given that, can you discuss the benefits of splitting these into
separate commits? Also is it multiple commits, one patch? Or multiple
patches?

>> +(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.")
>
> Please break up long lines like this.  Please run “./pre-inst-env guix
> lint sbcl-trivial-backtrace”, which will tell you about this problem.

I did run linting, but I wasn't sure how to break up description
strings. If I just do line-breaks, will that be OK?

>> +     (home-page "https://common-lisp.net/project/trivial-backtrace/")
>> +     (license license:bsd-style)
>> +     (version (string-append "0.0.0-" (string-take commit-hash 7)))
>
> Please use “git-version” here.  Please also use a revision string, which
> allows us to build version strings that can be sorted, e.g. when the
> base version is unchanged and a newer commit is “smaller” than the
> previous one.
>
>> +     (source
>> +      (origin
>> +       (method git-fetch)
>> +       (uri (git-reference
>> +             (url "https://github.com/gwkkwg/trivial-backtrace.git")
>> +             (commit commit-hash)))
>
> Throughout you can use “commit” instead of “commit-hash” — there is no
> naming conflict.

Yes, I know. I preferred `commit-hash` because that's what it is -- not
an actual commit. Do we standardize this much, down to variable names?

-- 
Katherine

^ permalink raw reply	[flat|nested] 12+ messages in thread

* [bug#34959] Acknowledgement ([PATCH] Add Multiple Common Lisp Packages)
  2019-03-28 17:38       ` Katherine Cox-Buday
@ 2019-03-28 20:43         ` Ricardo Wurmus
  2019-03-29 17:15           ` Katherine Cox-Buday
  0 siblings, 1 reply; 12+ messages in thread
From: Ricardo Wurmus @ 2019-03-28 20:43 UTC (permalink / raw)
  To: Katherine Cox-Buday; +Cc: 34959

Hi Katherine,

>> We usually expect one commit per independent change.  Could you please
>> split up this patch into multiple commits?  You can group package
>> variants like “sbcl-trivial-backtrace” and “cl-trivial-backtrace”, but
>> separate packages generally each should have their own commit.
>
> This will be a non-trivial amount of work, and these will have to be
> chained against each other since this patch forms a dependency graph.
> Given that, can you discuss the benefits of splitting these into
> separate commits? Also is it multiple commits, one patch? Or multiple
> patches?

You can generate one patch per commit with “git format-patch”.  Separate
commits allow us to use the git history to our advantage.  We use git
not only do we track changes but semantic units of change.  We decided
on the unit to be individual packages.

One effect of this is that the summary line of each commit can be exact.
When reading the commit log this keeps surprises to a minimum.

If you are an Emacs user I recommend using the Yasnippet “add” snippet
for quickly generating commit messages for the staged diff.  This makes
it much easier to create the expected commit messages, especially when
there are many commits.  (I use this all the time for R package updates
and additions.)

>>> +(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.")
>>
>> Please break up long lines like this.  Please run “./pre-inst-env guix
>> lint sbcl-trivial-backtrace”, which will tell you about this problem.
>
> I did run linting, but I wasn't sure how to break up description
> strings. If I just do line-breaks, will that be OK?

Yes.  Line breaks are the right tool here.  In Emacs you can do M-q
while point is on the description string to break up the lines
in the expected fashion.

>>> +     (source
>>> +      (origin
>>> +       (method git-fetch)
>>> +       (uri (git-reference
>>> +             (url "https://github.com/gwkkwg/trivial-backtrace.git")
>>> +             (commit commit-hash)))
>>
>> Throughout you can use “commit” instead of “commit-hash” — there is no
>> naming conflict.
>
> Yes, I know. I preferred `commit-hash` because that's what it is -- not
> an actual commit. Do we standardize this much, down to variable names?

That’s fine.  I guessed that you used “commit-hash” to avoid a name
clash, so I clarified that this is not necessary.

Personally, I think it’s best to stick with the established conventions
as it makes working on Guix less surprising.

--
Ricardo

^ permalink raw reply	[flat|nested] 12+ messages in thread

* [bug#34959] Acknowledgement ([PATCH] Add Multiple Common Lisp Packages)
  2019-03-28 20:43         ` Ricardo Wurmus
@ 2019-03-29 17:15           ` Katherine Cox-Buday
  0 siblings, 0 replies; 12+ messages in thread
From: Katherine Cox-Buday @ 2019-03-29 17:15 UTC (permalink / raw)
  To: Ricardo Wurmus; +Cc: 34959

Ricardo Wurmus <rekado@elephly.net> writes:

> Hi Katherine,
>
>>> We usually expect one commit per independent change.  Could you please
>>> split up this patch into multiple commits?  You can group package
>>> variants like “sbcl-trivial-backtrace” and “cl-trivial-backtrace”, but
>>> separate packages generally each should have their own commit.
>>
>> This will be a non-trivial amount of work, and these will have to be
>> chained against each other since this patch forms a dependency graph.
>> Given that, can you discuss the benefits of splitting these into
>> separate commits? Also is it multiple commits, one patch? Or multiple
>> patches?
>
> You can generate one patch per commit with “git format-patch”.  Separate
> commits allow us to use the git history to our advantage.  We use git
> not only do we track changes but semantic units of change.  We decided
> on the unit to be individual packages.
>
> One effect of this is that the summary line of each commit can be exact.
> When reading the commit log this keeps surprises to a minimum.
>
> If you are an Emacs user I recommend using the Yasnippet “add” snippet
> for quickly generating commit messages for the staged diff.  This makes
> it much easier to create the expected commit messages, especially when
> there are many commits.  (I use this all the time for R package updates
> and additions.)

This makes sense. Thank you for the explanation.

>>>> +(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.")
>>>
>>> Please break up long lines like this.  Please run “./pre-inst-env guix
>>> lint sbcl-trivial-backtrace”, which will tell you about this problem.
>>
>> I did run linting, but I wasn't sure how to break up description
>> strings. If I just do line-breaks, will that be OK?
>
> Yes.  Line breaks are the right tool here.  In Emacs you can do M-q
> while point is on the description string to break up the lines
> in the expected fashion.

Will do; thank you.

>>>> +     (source
>>>> +      (origin
>>>> +       (method git-fetch)
>>>> +       (uri (git-reference
>>>> +             (url "https://github.com/gwkkwg/trivial-backtrace.git")
>>>> +             (commit commit-hash)))
>>>
>>> Throughout you can use “commit” instead of “commit-hash” — there is no
>>> naming conflict.
>>
>> Yes, I know. I preferred `commit-hash` because that's what it is -- not
>> an actual commit. Do we standardize this much, down to variable names?
>
> That’s fine.  I guessed that you used “commit-hash” to avoid a name
> clash, so I clarified that this is not necessary.
>
> Personally, I think it’s best to stick with the established conventions
> as it makes working on Guix less surprising.

OK, I'll use the standard.

Thanks for taking the time to explain. It is very much appreciated.

-- 
Katherine

^ permalink raw reply	[flat|nested] 12+ messages in thread

* [bug#34959] Acknowledgement ([PATCH] Add Multiple Common Lisp Packages)
  2019-03-24 10:01     ` Ricardo Wurmus
  2019-03-28 17:38       ` Katherine Cox-Buday
@ 2019-03-29 23:19       ` Katherine Cox-Buday
  2019-04-07  6:13         ` bug#34959: " 宋文武
  1 sibling, 1 reply; 12+ messages in thread
From: Katherine Cox-Buday @ 2019-03-29 23:19 UTC (permalink / raw)
  To: 34959

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

Phew! I hope I did this right because that was a lot of work to get
those in shape! ;p

I've at least learned more about Guix packaging :)


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: 0001-licenses-Add-Lisp-Lesser-General-Public-License.patch --]
[-- Type: text/x-patch, Size: 1239 bytes --]

From 711db064defa099b5051a2d9c73171a989025482 Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 12:21:35 -0500
Subject: [PATCH 01/42] licenses: Add Lisp Lesser General Public License

---
 guix/licenses.scm | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/guix/licenses.scm b/guix/licenses.scm
index 676e71acdb..952c3bfd1a 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: 0002-gnu-cl-ansi-text-Update-License-to-LLGPL.patch --]
[-- Type: text/x-patch, Size: 1316 bytes --]

From 2dc51db0e95342fbc93b2dbb77ddd8979c847214 Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 12:29:13 -0500
Subject: [PATCH 02/42] gnu: cl-ansi-text: Update License to LLGPL

---
 gnu/packages/lisp.scm | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index 87dcf36372..4c6683abb7 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.
 ;;;
@@ -2554,8 +2555,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))
-- 
2.20.1


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #4: 0003-gnu-Add-cl-ssl.patch --]
[-- Type: text/x-patch, Size: 2624 bytes --]

From de5f834aed0c92824828a30cbeed4e9aed0d2883 Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 12:33:12 -0500
Subject: [PATCH 03/42] gnu: Add cl+ssl

---
 gnu/packages/lisp.scm | 43 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index 4c6683abb7..b9f1382f9c 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -66,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)
@@ -3840,3 +3841,45 @@ client and server.")
 
 (define-public ecl-trivial-clipboard
   (sbcl-package->ecl-package sbcl-trivial-clipboard))
+
+(define-public sbcl-cl+ssl
+  (let ((commit "b81c1135cf5700e870ce2573d5035d249e491788")
+        (revision "1"))
+    (package
+      (name "sbcl-cl+ssl")
+      (version (git-version "0.0.0" revision commit))
+      (source
+       (origin
+         (method git-fetch)
+         (uri (git-reference
+               (url "https://github.com/cl-plus-ssl/cl-plus-ssl.git")
+               (commit commit)))
+         (sha256 (base32 "1845i1pafmqb6cdlr53yaqy67kjrhkvbx6c37ca15cw70vhdr3z9"))))
+      (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))))))))
+      (propagated-inputs `(("openssl" ,openssl)))
+      (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)))
+      (home-page "http://common-lisp.net/project/cl-plus-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.")
+      (license license:expat))))
+
+(define-public cl-cl+ssl
+  (sbcl-package->cl-source-package sbcl-cl+ssl))
-- 
2.20.1


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #5: 0004-gnu-Add-trivial-backtrace.patch --]
[-- Type: text/x-patch, Size: 2024 bytes --]

From affeacbec8cecf03275d02505761def012b646a4 Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 12:46:02 -0500
Subject: [PATCH 04/42] gnu: Add trivial-backtrace

---
 gnu/packages/lisp.scm | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index b9f1382f9c..74d4d424b3 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -3842,6 +3842,37 @@ client and server.")
 (define-public ecl-trivial-clipboard
   (sbcl-package->ecl-package sbcl-trivial-clipboard))
 
+(define-public sbcl-trivial-backtrace
+  (let ((commit "ca81c011b86424a381a7563cea3b924f24e6fbeb")
+        (revision "1"))
+    (package
+     (name "sbcl-trivial-backtrace")
+     (version (git-version "0.0.0" revision commit))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/gwkkwg/trivial-backtrace.git")
+             (commit commit)))
+       (sha256
+        (base32 "10p41p43skj6cimdg8skjy7372s8v2xpkg8djjy0l8rm45i654k1"))))
+     (build-system asdf-build-system/sbcl)
+     (inputs
+      `(("sbcl-lift" ,sbcl-lift)))
+     (home-page "https://common-lisp.net/project/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.")
+     (license license:bsd-style))))
+
+(define-public cl-trivial-backtrace
+  (sbcl-package->cl-source-package sbcl-trivial-backtrace))
+
 (define-public sbcl-cl+ssl
   (let ((commit "b81c1135cf5700e870ce2573d5035d249e491788")
         (revision "1"))
-- 
2.20.1


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #6: 0005-gnu-Add-rfc2388.patch --]
[-- Type: text/x-patch, Size: 1639 bytes --]

From 48e1855f760776c8c1c3acf0577c21146b28fda3 Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 12:50:17 -0500
Subject: [PATCH 05/42] gnu: Add rfc2388

---
 gnu/packages/lisp.scm | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index 74d4d424b3..b56efc7b93 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -3873,6 +3873,31 @@ portably.")
 (define-public cl-trivial-backtrace
   (sbcl-package->cl-source-package sbcl-trivial-backtrace))
 
+(define-public sbcl-rfc2388
+  (let ((commit "591bcf7e77f2c222c43953a80f8c297751dc0c4e")
+        (revision "1"))
+    (package
+     (name "sbcl-rfc2388")
+     (version (git-version "0.0.0" revision commit))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/jdz/rfc2388.git")
+             (commit commit)))
+       (sha256 (base32 "0phh5n3clhl9ji8jaxrajidn22d3f0aq87mlbfkkxlnx2pnw694k"))))
+     (build-system asdf-build-system/sbcl)
+     (home-page "https://github.com/jdz/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\".")
+     (license license:bsd-2))))
+
+(define-public cl-rfc2388
+  (sbcl-package->cl-source-package sbcl-rfc2388))
+
 (define-public sbcl-cl+ssl
   (let ((commit "b81c1135cf5700e870ce2573d5035d249e491788")
         (revision "1"))
-- 
2.20.1


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #7: 0006-gnu-Add-md5.patch --]
[-- Type: text/x-patch, Size: 1532 bytes --]

From fa0a98c34ac0eac45cac69e9357b6fa6763537fd Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 12:50:43 -0500
Subject: [PATCH 06/42] gnu: Add md5

---
 gnu/packages/lisp.scm | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index b56efc7b93..7617cf249c 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -3898,6 +3898,25 @@ process form data posted with HTTP POST method using enctype
 (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 "b81c1135cf5700e870ce2573d5035d249e491788")
         (revision "1"))
-- 
2.20.1


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #8: 0007-gnu-Add-kmrcl.patch --]
[-- Type: text/x-patch, Size: 1818 bytes --]

From ba590f51c35d68e828602c5e0a3c07146d2318fd Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 12:51:29 -0500
Subject: [PATCH 07/42] gnu: Add kmrcl

---
 gnu/packages/lisp.scm | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index 7617cf249c..ac605db446 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -3958,3 +3958,37 @@ Schmidt. Development into CL+SSL was done by David Lichteblau.")
 
 (define-public cl-cl+ssl
   (sbcl-package->cl-source-package sbcl-cl+ssl))
+
+(define-public sbcl-kmrcl
+  (let ((version "1.109.0")
+        (commit "5260068b2eb735af6796740c2db4955afac21636")
+        (revision "1"))
+    (package
+      (name "sbcl-kmrcl")
+      (version (git-version version revision commit))
+      (source
+       (origin
+         (method git-fetch)
+         (uri (git-reference
+               (url "http://git.kpe.io/kmrcl.git/")
+               (commit commit)))
+         (sha256 (base32 "1va7xjgzfv674bpsli674i7zj3f7wg5kxic41kz18r6hh4n52dfv"))))
+      (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))
+      (inputs
+       `(("sbcl-rt" ,sbcl-rt)))
+      (home-page "http://files.kpe.io/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.")
+      (license license:llgpl))))
+
+(define-public cl-kmrcl
+  (sbcl-package->cl-source-package sbcl-kmrcl))
+
-- 
2.20.1


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #9: 0008-gnu-Add-cl-base64.patch --]
[-- Type: text/x-patch, Size: 1948 bytes --]

From 024d2bd956771e9f861ae1aa8be2eb69628cc68e Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 12:52:23 -0500
Subject: [PATCH 08/42] gnu: Add cl-base64

---
 gnu/packages/lisp.scm | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index ac605db446..cabcbba2a8 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -3992,3 +3992,38 @@ Rosenberg's CL packages.")
 (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")
+      (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"))))
+      (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))
+      (inputs
+       `(("sbcl-ptester" ,sbcl-ptester)
+         ("sbcl-kmrcl" ,sbcl-kmrcl)))
+      (home-page "http://files.kpe.io/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.")
+      (license license:bsd-3))))
+
+(define-public cl-cl-base64
+  (sbcl-package->cl-source-package sbcl-cl-base64))
+
-- 
2.20.1


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #10: 0009-gnu-Add-chunga.patch --]
[-- Type: text/x-patch, Size: 1500 bytes --]

From 403a0d5a8db5edb6cf6143f3f14227f7e5b43260 Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 12:52:51 -0500
Subject: [PATCH 09/42] gnu: Add chunga

---
 gnu/packages/lisp.scm | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index cabcbba2a8..ed0b1014f4 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -4027,3 +4027,28 @@ modified encoding table that uses only URI-compatible characters.")
 (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")
+      (version version)
+      (source
+       (origin
+         (method url-fetch)
+         (uri (string-append
+               "https://github.com/edicl/chunga/archive/v" version ".tar.gz"))
+         (sha256
+          (base32 "0ra17kyc9l7qbaw003ly111r1cbn4zixbfq1ydr9cxw10v30q1n7"))))
+      (build-system asdf-build-system/sbcl)
+      (inputs
+       `(("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)))
+      (home-page "https://edicl.github.io/chunga/")
+      (synopsis "Portable chunked streams for Common Lisp")
+      (description
+       "Chunga implements streams capable of chunked encoding on demand as
+defined in RFC 2616.")
+      (license license:bsd-2))))
+
+(define-public cl-chunga
+  (sbcl-package->cl-source-package sbcl-chunga))
+
-- 
2.20.1


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #11: 0010-gnu-Add-cl-who.patch --]
[-- Type: text/x-patch, Size: 1800 bytes --]

From 7544b0c2025fab714739227310c150c7b34097bb Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 14:40:35 -0500
Subject: [PATCH 10/42] gnu: Add cl-who

---
 gnu/packages/lisp.scm | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index ed0b1014f4..0435873b9b 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -4052,3 +4052,35 @@ defined in RFC 2616.")
 (define-public cl-chunga
   (sbcl-package->cl-source-package sbcl-chunga))
 
+(define-public sbcl-cl-who
+  (let ((version "1.1.4")
+        (commit "2c08caa4bafba720409af9171feeba3f32e86d32")
+        (revision "1"))
+    (package
+      (name "sbcl-cl-who")
+      (version (git-version version revision commit))
+      (source
+       (origin
+         (method git-fetch)
+         (uri (git-reference
+               (url "https://github.com/edicl/cl-who.git")
+               (commit commit)))
+         (file-name (git-file-name name version))
+         (sha256
+          (base32
+           "0yjb6sr3yazm288m318kqvj9xk8rm9n1lpimgf65ymqv0i5agxsb"))))
+      (build-system asdf-build-system/sbcl)
+      (native-inputs
+       `(("sbcl-flexi-streams" ,sbcl-flexi-streams)))
+      (home-page "https://edicl.github.io/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.")
+      (license license:bsd-2))))
+
+(define-public cl-cl-who
+  (sbcl-package->cl-source-package sbcl-cl-who))
+
-- 
2.20.1


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #12: 0011-gnu-Add-chipz.patch --]
[-- Type: text/x-patch, Size: 1933 bytes --]

From 29a0ba2338cf84fd973b58bfc8d1aa364a454cc7 Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 14:44:43 -0500
Subject: [PATCH 11/42] gnu: Add chipz

---
 gnu/packages/lisp.scm | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index 0435873b9b..1ef9585fcf 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -4084,3 +4084,38 @@ as good or bad as the next one.")
 (define-public cl-cl-who
   (sbcl-package->cl-source-package sbcl-cl-who))
 
+(define-public sbcl-chipz
+  (let ((version "0.8")
+        (commit "75dfbc660a5a28161c57f115adf74c8a926bfc4d")
+        (revision "1"))
+    (package
+      (name "sbcl-chipz")
+      (version (git-version version revision commit))
+      (source
+       (origin
+         (method git-fetch)
+         (uri (git-reference
+               (url "https://github.com/froydnj/chipz.git")
+               (commit commit)))
+         (file-name (git-file-name name version))
+         (sha256
+          (base32
+           "0plx4rs39zbs4gjk77h4a2q11zpy75fh9v8hnxrvsf8fnakajhwg"))))
+      (build-system asdf-build-system/sbcl)
+      (native-inputs
+       `(("sbcl-flexi-streams" ,sbcl-flexi-streams)))
+      (home-page "http://method-combination.net/lisp/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.")
+      ;; The author describes it as "MIT-like"
+      (license license:expat))))
+
+(define-public cl-chipz
+  (sbcl-package->cl-source-package sbcl-chipz))
+
-- 
2.20.1


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #13: 0012-gnu-Add-drakma.patch --]
[-- Type: text/x-patch, Size: 2134 bytes --]

From eb103cd7b0d748c7bc8038116fc6107a71d6da11 Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 14:50:42 -0500
Subject: [PATCH 12/42] gnu: Add drakma

---
 gnu/packages/lisp.scm | 40 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index 1ef9585fcf..815f3acf56 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -4119,3 +4119,43 @@ the format used by the popular compression tool bzip2.")
 (define-public cl-chipz
   (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
+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))))
+
+(define-public cl-drakma
+  (sbcl-package->cl-source-package sbcl-drakma))
+
-- 
2.20.1


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #14: 0013-gnu-Add-hunchentoot.patch --]
[-- Type: text/x-patch, Size: 2190 bytes --]

From 758aa13eb621d391ecce17021a5ce2bf121031e8 Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 14:54:47 -0500
Subject: [PATCH 13/42] gnu: Add hunchentoot

---
 gnu/packages/lisp.scm | 40 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index 815f3acf56..809c52fdfc 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -4159,3 +4159,43 @@ sockets, SSL, continuable uploads, file uploads, cookies, and more.")
 (define-public cl-drakma
   (sbcl-package->cl-source-package sbcl-drakma))
 
+(define-public sbcl-hunchentoot
+  (let ((version "1.2.38"))
+    (package
+      (name "sbcl-hunchentoot")
+      (version version)
+      (source
+       (origin
+         (method url-fetch)
+         (uri (string-append
+               "https://github.com/edicl/hunchentoot/archive/v"
+               version ".tar.gz"))
+         (sha256
+          (base32 "17z8rpd6b5w93jwrdwfwxjha617xnjqw8aq1hw2z76zp1fn8yrmh"))))
+      (build-system asdf-build-system/sbcl)
+      (native-inputs
+       `(("sbcl-cl-who" ,sbcl-cl-who)
+         ("sbcl-drakma" ,sbcl-drakma)))
+      (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)))
+      (home-page "https://edicl.github.io/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.")
+      (license license:bsd-2))))
+
+(define-public cl-hunchentoot
+  (sbcl-package->cl-source-package sbcl-hunchentoot))
+
-- 
2.20.1


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #15: 0014-gnu-Add-trivial-types.patch --]
[-- Type: text/x-patch, Size: 1459 bytes --]

From 52c5e995dbdb6c97e2be5118caee0583299979fa Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 15:06:03 -0500
Subject: [PATCH 14/42] gnu: Add trivial-types

---
 gnu/packages/lisp.scm | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index 809c52fdfc..b9b148cff4 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -4199,3 +4199,26 @@ connections (keep-alive), and SSL.")
 (define-public cl-hunchentoot
   (sbcl-package->cl-source-package sbcl-hunchentoot))
 
+(define-public sbcl-trivial-types
+  (package
+    (name "sbcl-trivial-types")
+    (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)
+    (home-page "https://github.com/m2ym/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.")
+    (license license:llgpl)))
+
+(define-public cl-trivial-types
+  (sbcl-package->cl-source-package sbcl-trivial-types))
+
-- 
2.20.1


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #16: 0015-gnu-Add-cl-syntax.patch --]
[-- Type: text/x-patch, Size: 1629 bytes --]

From 550f6a1e9fbd4e10411ceed6edb1df83e534f125 Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 15:12:18 -0500
Subject: [PATCH 15/42] gnu: Add cl-syntax

---
 gnu/packages/lisp.scm | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index b9b148cff4..59a42877b0 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -4222,3 +4222,30 @@ PROPER-LIST, ASSOCIATION-LIST, PROPERTY-LIST and TUPLE.")
 (define-public cl-trivial-types
   (sbcl-package->cl-source-package sbcl-trivial-types))
 
+(define-public sbcl-cl-syntax
+  (package
+    (name "sbcl-cl-syntax")
+    (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"))))
+    (build-system asdf-build-system/sbcl)
+    (arguments
+     '(#:asd-file "cl-syntax.asd"
+       #:asd-system-name "cl-syntax"))
+    (inputs `(("sbcl-trivial-types" ,sbcl-trivial-types)
+              ("sbcl-named-readtables" ,sbcl-named-readtables)))
+    (home-page "https://github.com/m2ym/cl-syntax")
+    (synopsis "Reader Syntax Coventions for Common Lisp and SLIME")
+    (description
+     "CL-SYNTAX provides Reader Syntax Coventions for Common Lisp and SLIME.")
+    (license license:llgpl)))
+
+(define-public cl-cl-syntax
+  (sbcl-package->cl-source-package sbcl-cl-syntax))
+
-- 
2.20.1


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #17: 0016-gnu-Add-cl-annot.patch --]
[-- Type: text/x-patch, Size: 1561 bytes --]

From fbc9ed4b9ed5a2225a7dd181808e1aef716f709d Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 15:26:41 -0500
Subject: [PATCH 16/42] gnu: Add cl-annot

---
 gnu/packages/lisp.scm | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index 59a42877b0..1495038b5f 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -4249,3 +4249,29 @@ PROPER-LIST, ASSOCIATION-LIST, PROPERTY-LIST and TUPLE.")
 (define-public cl-cl-syntax
   (sbcl-package->cl-source-package sbcl-cl-syntax))
 
+(define-public sbcl-cl-annot
+  (let ((commit "c99e69c15d935eabc671b483349a406e0da9518d")
+        (revision "1"))
+    (package
+      (name "sbcl-cl-annot")
+      (version (git-version "0.0.0" revision commit))
+      (source
+       (origin
+         (method git-fetch)
+         (uri (git-reference
+               (url "https://github.com/m2ym/cl-annot.git")
+               (commit commit)))
+         (sha256
+          (base32 "1wq1gs9jjd5m6iwrv06c2d7i5dvqsfjcljgbspfbc93cg5xahk4n"))))
+      (build-system asdf-build-system/sbcl)
+      (inputs
+       `(("sbcl-alexandria" ,sbcl-alexandria)))
+      (home-page "https://github.com/m2ym/cl-annot")
+      (synopsis "Python-like Annotation Syntax for Common Lisp.")
+      (description
+       "cl-annot is an general annotation library for Common Lisp.")
+      (license license:llgpl))))
+
+(define-public cl-cl-annot
+  (sbcl-package->cl-source-package sbcl-cl-annot))
+
-- 
2.20.1


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #18: 0017-gnu-Add-cl-syntax-annot.patch --]
[-- Type: text/x-patch, Size: 1639 bytes --]

From 386d50492990b94c7226b5cb3650466aca538fb2 Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 15:28:38 -0500
Subject: [PATCH 17/42] gnu: Add cl-syntax-annot

---
 gnu/packages/lisp.scm | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index 1495038b5f..325bcadad9 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -4275,3 +4275,32 @@ PROPER-LIST, ASSOCIATION-LIST, PROPERTY-LIST and TUPLE.")
 (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")
+    (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"))))
+    (build-system asdf-build-system/sbcl)
+    (arguments
+     '(#:asd-file "cl-syntax-annot.asd"
+       #:asd-system-name "cl-syntax-annot"))
+    (inputs
+     `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
+       ("sbcl-cl-annot" ,sbcl-cl-annot)))
+    (home-page "https://github.com/m2ym/cl-syntax")
+    (synopsis "Reader Syntax Coventions for Common Lisp and SLIME")
+    (description
+     "CL-SYNTAX provides Reader Syntax Coventions for Common Lisp and
+SLIME.")
+    (license license:llgpl)))
+
+(define-public cl-cl-syntax-annot
+  (sbcl-package->cl-source-package sbcl-cl-syntax-annot))
+
-- 
2.20.1


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #19: 0018-gnu-Add-myway.patch --]
[-- Type: text/x-patch, Size: 1822 bytes --]

From 178e99674d67f54f99f65d9ad554052bc7c523b3 Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 15:31:24 -0500
Subject: [PATCH 18/42] gnu: Add myway

---
 gnu/packages/lisp.scm | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index 325bcadad9..0191adfbcd 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -4304,3 +4304,37 @@ SLIME.")
 (define-public cl-cl-syntax-annot
   (sbcl-package->cl-source-package sbcl-cl-syntax-annot))
 
+(define-public sbcl-myway
+  (let ((commit "286230082a11f879c18b93f17ca571c5f676bfb7")
+        (revision "1"))
+    (package
+     (name "sbcl-myway")
+     (version (git-version "0.1.0" revision commit))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/fukamachi/myway.git")
+             (commit commit)))
+       (sha256
+        (base32 "0briia9bk3lbr0frnx39d1qg6i38dm4j6z9w3yga3d40k6df4a90"))))
+     (build-system asdf-build-system/sbcl)
+     (arguments
+      ;; Tests fail with: Component MYWAY-ASD::MYWAY-TEST not found, required
+      ;; by #<SYSTEM "myway">. Why?
+      '(#:tests? #f))
+     (native-inputs
+      `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+        ("sbcl-prove" ,sbcl-prove)))
+     (inputs
+      `(("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
+        ("sbcl-quri" ,sbcl-quri)
+        ("sbcl-map-set" ,sbcl-map-set)))
+     (home-page "https://github.com/fukamachi/myway")
+     (synopsis "Sinatra-compatible URL routing library for Common Lisp")
+     (description "My Way is a Sinatra-compatible URL routing library.")
+     (license license:llgpl))))
+
+(define-public cl-myway
+  (sbcl-package->cl-source-package sbcl-myway))
+
-- 
2.20.1


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #20: 0019-gnu-Add-cl-utilities.patch --]
[-- Type: text/x-patch, Size: 2426 bytes --]

From 136bff5cf85055f855a162c0aeaca5969f62e50c Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 15:35:00 -0500
Subject: [PATCH 19/42] gnu: Add cl-utilities

---
 gnu/packages/lisp.scm | 40 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index 0191adfbcd..d0cc781256 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -4338,3 +4338,43 @@ SLIME.")
 (define-public cl-myway
   (sbcl-package->cl-source-package sbcl-myway))
 
+(define-public sbcl-cl-utilities
+  (let ((commit "dce2d2f6387091ea90357a130fa6d13a6776884b")
+        (revision "1"))
+    (package
+      (name "sbcl-cl-utilities")
+      (version (git-version "0.0.0" revision commit))
+      (source
+       (origin
+         (method url-fetch)
+         (uri
+          (string-append
+           "https://gitlab.common-lisp.net/cl-utilities/cl-utilities/-/archive/"
+           commit "/cl-utilities-" commit ".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)")))))))
+      (home-page "http://common-lisp.net/project/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.")
+      (license license:public-domain))))
+
+(define-public cl-cl-utilities
+  (sbcl-package->cl-source-package sbcl-cl-utilities))
+
-- 
2.20.1


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #21: 0020-gnu-Add-map-set.patch --]
[-- Type: text/x-patch, Size: 1601 bytes --]

From 3961073351645803795ebfccac75b82926bfaca7 Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 15:36:45 -0500
Subject: [PATCH 20/42] gnu: Add map-set

---
 gnu/packages/lisp.scm | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index d0cc781256..bcf0d9b3e1 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -4378,3 +4378,30 @@ everywhere some dumb user might make a mistake.")
 (define-public cl-cl-utilities
   (sbcl-package->cl-source-package sbcl-cl-utilities))
 
+(define-public sbcl-map-set
+  (let ((commit "7b4b545b68b8")
+        (revision "1"))
+    (package
+      (name "sbcl-map-set")
+      (version (git-version "0.0.0" revision commit))
+      (source
+       (origin
+         (method url-fetch)
+         (uri (string-append
+               "https://bitbucket.org/tarballs_are_good/map-set/get/"
+               commit ".tar.gz"))
+         (sha256
+          (base32 "1sx5j5qdsy5fklspfammwb16kjrhkggdavm922a9q86jm5l0b239"))))
+      (build-system asdf-build-system/sbcl)
+      (home-page "https://bitbucket.org/tarballs_are_good/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.")
+      (license license:bsd-3))))
+
+(define-public cl-map-set
+  (sbcl-package->cl-source-package sbcl-map-set))
+
-- 
2.20.1


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #22: 0021-gnu-Add-quri.patch --]
[-- Type: text/x-patch, Size: 2011 bytes --]

From 53afd2e4b455f9acb20f955e34627775a144ebd5 Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 15:49:31 -0500
Subject: [PATCH 21/42] gnu: Add quri

---
 gnu/packages/lisp.scm | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index bcf0d9b3e1..cd5a0e6303 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -4405,3 +4405,38 @@ addition, removal, and random selection.")
 (define-public cl-map-set
   (sbcl-package->cl-source-package sbcl-map-set))
 
+(define-public sbcl-quri
+  (let ((commit "76b75103f21ead092c9f715512fa82441ef61185")
+        (revision "1"))
+    (package
+      (name "sbcl-quri")
+      (version (git-version "0.1.0" revision commit))
+      (source
+       (origin
+         (method git-fetch)
+         (uri (git-reference
+               (url "https://github.com/fukamachi/quri.git")
+               (commit commit)))
+         (sha256
+          (base32 "1ccbxsgzdibmzq33mmbmmz9vwl6l03xh6nbpsh1hkdvdcl7q0a60"))))
+      (build-system asdf-build-system/sbcl)
+      (arguments
+       ;; Tests fail with: Component QURI-ASD::QURI-TEST not found,
+       ;; required by #<SYSTEM "quri">. Why?
+       '(#:tests? #f))
+      (native-inputs `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+                       ("sbcl-prove" ,sbcl-prove)))
+      (inputs `(("sbcl-babel" ,sbcl-babel)
+                ("sbcl-split-sequence" ,sbcl-split-sequence)
+                ("sbcl-cl-utilities" ,sbcl-cl-utilities)
+                ("sbcl-alexandria" ,sbcl-alexandria)))
+      (home-page "https://github.com/fukamachi/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.")
+      (license license:bsd-3))))
+
+(define-public cl-quri
+  (sbcl-package->cl-source-package sbcl-quri))
+
-- 
2.20.1


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #23: 0022-gnu-Add-smart-buffer.patch --]
[-- Type: text/x-patch, Size: 1936 bytes --]

From e050b45cbcf656a900980c5fce49622d8f0f499e Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 15:51:40 -0500
Subject: [PATCH 22/42] gnu: Add smart-buffer

---
 gnu/packages/lisp.scm | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index cd5a0e6303..be0a82d34a 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -4440,3 +4440,38 @@ Lisp. It is intended to be a replacement of PURI.")
 (define-public cl-quri
   (sbcl-package->cl-source-package sbcl-quri))
 
+(define-public sbcl-smart-buffer
+  (let ((commit "09b9a9a0b3abaa37abe9a730f5aac2643dca4e62")
+        (revision "1"))
+    (package
+      (name "sbcl-smart-buffer")
+      (version (git-version "0.0.1" revision commit))
+      (source
+       (origin
+         (method git-fetch)
+         (uri (git-reference
+               (url "https://github.com/fukamachi/smart-buffer")
+               (commit commit)))
+         (sha256
+          (base32 "0qz1zzxx0wm5ff7gpgsq550a59p0qj594zfmm2rglj97dahj54l7"))))
+      (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))
+      (native-inputs
+       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+         ("sbcl-prove" ,sbcl-prove)))
+      (inputs
+       `(("sbcl-xsubseq" ,sbcl-xsubseq)
+         ("sbcl-flexi-streams" ,sbcl-flexi-streams)))
+      (home-page "https://github.com/fukamachi/smart-buffer")
+      (synopsis "Smart octets buffer.")
+      (description
+       "Smart-buffer provides an output buffer which changes the destination
+depending on content size.")
+      (license license:bsd-3))))
+
+(define-public cl-smart-buffer
+  (sbcl-package->cl-source-package sbcl-smart-buffer))
+
-- 
2.20.1


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #24: 0023-gnu-Add-xsubseq.patch --]
[-- Type: text/x-patch, Size: 1745 bytes --]

From 1759719cc568c131ea5f18601f28096250ab8b2f Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 15:53:10 -0500
Subject: [PATCH 23/42] gnu: Add xsubseq

---
 gnu/packages/lisp.scm | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index be0a82d34a..f0222ac669 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -4475,3 +4475,35 @@ depending on content size.")
 (define-public cl-smart-buffer
   (sbcl-package->cl-source-package sbcl-smart-buffer))
 
+(define-public sbcl-xsubseq
+  (let ((commit "5ce430b3da5cda3a73b9cf5cee4df2843034422b")
+        (revision "1"))
+    (package
+     (name "sbcl-xsubseq")
+     (version (git-version "0.0.1" revision commit))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/fukamachi/xsubseq")
+             (commit commit)))
+       (sha256
+        (base32 "1xz79q0p2mclf3sqjiwf6izdpb6xrsr350bv4mlmdlm6rg5r99px"))))
+     (build-system asdf-build-system/sbcl)
+     (arguments
+      ;; Tests fail with: Component XSUBSEQ-ASD::XSUBSEQ-TEST not found,
+      ;; required by #<SYSTEM "xsubseq">. Why?
+      `(#:tests? #f))
+     (native-inputs
+      `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+        ("sbcl-prove" ,sbcl-prove)))
+     (home-page "https://github.com/fukamachi/xsubseq")
+     (synopsis "Efficient way to use \"subseq\"s in Common Lisp")
+     (description
+      "XSubseq provides functions to be able to handle \"subseq\"s more
+effieiently.")
+     (license license:bsd-2))))
+
+(define-public cl-xsubseq
+  (sbcl-package->cl-source-package sbcl-xsubseq))
+
-- 
2.20.1


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #25: 0024-gnu-Add-fast-http.patch --]
[-- Type: text/x-patch, Size: 2071 bytes --]

From 7a46b502b878ea7ba23d110855e5ed107446a073 Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 15:55:08 -0500
Subject: [PATCH 24/42] gnu: Add fast-http

---
 gnu/packages/lisp.scm | 39 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index f0222ac669..339e4953cf 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -4507,3 +4507,42 @@ effieiently.")
 (define-public cl-xsubseq
   (sbcl-package->cl-source-package sbcl-xsubseq))
 
+(define-public sbcl-fast-http
+  (let ((commit "f9e7597191bae380503e20724fd493a24d024935")
+        (revision "1"))
+    (package
+      (name "sbcl-fast-http")
+      (version (git-version "0.2.0" revision commit))
+      (source
+       (origin
+         (method git-fetch)
+         (uri (git-reference
+               (url "https://github.com/fukamachi/fast-http")
+               (commit commit)))
+         (sha256
+          (base32 "0qdmwv2zm0sizxdb8nnclgwl0nfjcbjaimbakavikijw7lr9b4jp"))))
+      (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))
+      (native-inputs
+       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+         ("sbcl-prove" ,sbcl-prove)))
+      (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)))
+      (home-page "https://github.com/fukamachi/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.")
+      ;; Author specified the MIT license
+      (license license:expat))))
+
+(define-public cl-fast-http
+  (sbcl-package->cl-source-package sbcl-fast-http))
+
-- 
2.20.1


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #26: 0025-gnu-Add-static-vectors.patch --]
[-- Type: text/x-patch, Size: 1641 bytes --]

From 4126b3f99e689497b4b0982a6a610c1c088bc49f Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 15:56:28 -0500
Subject: [PATCH 25/42] gnu: Add static-vectors

---
 gnu/packages/lisp.scm | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index 339e4953cf..9db9d3ef9b 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -4546,3 +4546,32 @@ Lisp.")
 (define-public cl-fast-http
   (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
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/sionescu/static-vectors.git")
+             (commit commit)))
+       (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 "Allocate SIMPLE-ARRAYs in static memory")
+     ;; Author specified an MIT license
+     (license license:expat))))
+
+(define-public cl-static-vectors
+  (sbcl-package->cl-source-package sbcl-static-vectors))
+
-- 
2.20.1


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #27: 0026-gnu-Add-marshal.patch --]
[-- Type: text/x-patch, Size: 1672 bytes --]

From e352914802103b0f7047ffc04fc25c26e3e6fa89 Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 15:58:09 -0500
Subject: [PATCH 26/42] gnu: Add marshal

---
 gnu/packages/lisp.scm | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index 9db9d3ef9b..7c8dfa4aad 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -4575,3 +4575,32 @@ Lisp.")
 (define-public cl-static-vectors
   (sbcl-package->cl-source-package sbcl-static-vectors))
 
+(define-public sbcl-marshal
+  (let ((commit "eff1b15f2b0af2f26f71ad6a4dd5c4beab9299ec")
+        (revision "1"))
+    (package
+     (name "sbcl-marshal")
+     (version (git-version "1.3.0" revision commit))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/wlbr/cl-marshal.git")
+             (commit commit)))
+       (sha256
+        (base32 "08qs6fhk38xpkkjkpcj92mxx0lgy4ygrbbzrmnivdx281syr0gwh"))))
+     (build-system asdf-build-system/sbcl)
+     (home-page "https://github.com/wlbr/cl-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.")
+     ;; Author specified an MIT license
+     (license license:expat))))
+
+(define-public cl-marshal
+  (sbcl-package->cl-source-package sbcl-marshal))
+
-- 
2.20.1


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #28: 0027-gnu-Add-checkl.patch --]
[-- Type: text/x-patch, Size: 2113 bytes --]

From da226e0a87660ee7f4bca7825cd4839b434d345c Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 15:59:51 -0500
Subject: [PATCH 27/42] gnu: Add checkl

---
 gnu/packages/lisp.scm | 37 +++++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index 7c8dfa4aad..9bf8edd3de 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -4604,3 +4604,40 @@ minimal changes required to make your CLOS objects serializable.")
 (define-public cl-marshal
   (sbcl-package->cl-source-package sbcl-marshal))
 
+(define-public sbcl-checkl
+  (let ((commit "80328800d047fef9b6e32dfe6bdc98396aee3cc9")
+        (revision "1"))
+    (package
+      (name "sbcl-checkl")
+      (version (git-version "0.0.0" revision commit))
+      (source
+       (origin
+         (method git-fetch)
+         (uri (git-reference
+               (url "https://github.com/rpav/CheckL.git")
+               (commit commit)))
+         (sha256
+          (base32 "0bpisihx1gay44xmyr1dmhlwh00j0zzi04rp9fy35i95l2r4xdlx"))))
+      (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))
+      (native-inputs
+       `(("sbcl-fiveam" ,sbcl-fiveam)))
+      (inputs
+       `(("sbcl-marshal" ,sbcl-marshal)))
+      (home-page "https://github.com/rpav/CheckL/")
+      (synopsis
+       "Why write programs in Common Lisp but tests like Java? Meet CheckL!")
+      (description
+       "Why write programs in Common Lisp but tests like Java? Meet CheckL!")
+      ;; 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))))
+
+(define-public cl-checkl
+  (sbcl-package->cl-source-package sbcl-checkl))
+
-- 
2.20.1


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #29: 0028-gnu-Add-fast-io.patch --]
[-- Type: text/x-patch, Size: 2114 bytes --]

From e6561256717a706bdd075794851f7d7d3bbcda3a Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 16:01:51 -0500
Subject: [PATCH 28/42] gnu: Add fast-io

---
 gnu/packages/lisp.scm | 38 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index 9bf8edd3de..b87a755379 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -4641,3 +4641,41 @@ minimal changes required to make your CLOS objects serializable.")
 (define-public cl-checkl
   (sbcl-package->cl-source-package sbcl-checkl))
 
+(define-public sbcl-fast-io
+  (let ((commit "dc3a71db7e9b756a88781ae9c342fe9d4bbab51c")
+        (revision "1"))
+    (package
+     (name "sbcl-fast-io")
+     (version (git-version "1.0.0" revision commit))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/rpav/fast-io.git")
+             (commit commit)))
+       (sha256
+        (base32 "1jsp6xvi26ln6fdy5j5zi05xvan8jsqdhisv552dy6xg6ws8i1yq"))))
+     (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))
+     (native-inputs
+      `(("sbcl-fiveam" ,sbcl-fiveam)
+        ("sbcl-checkl" ,sbcl-checkl)))
+     (inputs
+      `(("sbcl-alexandria" ,sbcl-alexandria)
+        ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)
+        ("sbcl-static-vectors" ,sbcl-static-vectors)))
+     (home-page "https://github.com/rpav/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).")
+     ;; Author specifies this as NewBSD which is an alias
+     (license license:bsd-3))))
+
+(define-public cl-fast-io
+  (sbcl-package->cl-source-package sbcl-fast-io))
+
-- 
2.20.1


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #30: 0029-gnu-Add-jonathan.patch --]
[-- Type: text/x-patch, Size: 2068 bytes --]

From 74eee85652d267c2e1c4408a4a0d5b95334dbe8d Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 16:04:43 -0500
Subject: [PATCH 29/42] gnu: Add jonathan

---
 gnu/packages/lisp.scm | 38 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index b87a755379..5661c9226a 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -4679,3 +4679,41 @@ streams (though primarily the former, while wrapping the latter).")
 (define-public cl-fast-io
   (sbcl-package->cl-source-package sbcl-fast-io))
 
+(define-public sbcl-jonathan
+  (let ((commit "1f448b4f7ac8265e56e1c02b32ce383e65316300")
+        (revision "1"))
+    (package
+     (name "sbcl-jonathan")
+     (version (git-version "0.1.0" revision commit))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/Rudolph-Miller/jonathan.git")
+             (commit commit)))
+       (sha256
+        (base32 "14x4iwz3mbag5jzzzr4sb6ai0m9r4q4kyypbq32jmsk2dx1hi807"))))
+     (build-system asdf-build-system/sbcl)
+     (arguments
+      ;; Tests fail with: Component JONATHAN-ASD::JONATHAN-TEST not found,
+      ;; required by #<SYSTEM "jonathan">. Why?
+      `(#:tests? #f))
+     (native-inputs
+      `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+        ("sbcl-prove" ,sbcl-prove)))
+     (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)))
+     (home-page "http://rudolph-miller.github.io/jonathan/overview.html")
+     (synopsis "JSON encoder and decoder.")
+     (description
+      "It's faster than jsown - high performance Common Lisp json parser.")
+     ;; Author specifies the MIT license
+     (license license:expat))))
+
+(define-public cl-jonathan
+  (sbcl-package->cl-source-package sbcl-jonathan))
+
-- 
2.20.1


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #31: 0030-gnu-Add-http-body.patch --]
[-- Type: text/x-patch, Size: 1986 bytes --]

From d2d297b8ceaef4bdd2877feb2e8b3aeffa23d849 Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 16:06:16 -0500
Subject: [PATCH 30/42] gnu: Add http-body

---
 gnu/packages/lisp.scm | 37 +++++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index 5661c9226a..1296795246 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -4717,3 +4717,40 @@ streams (though primarily the former, while wrapping the latter).")
 (define-public cl-jonathan
   (sbcl-package->cl-source-package sbcl-jonathan))
 
+(define-public sbcl-http-body
+  (let ((commit "dd01dc4f5842e3d29728552e5163acce8386eb73")
+        (revision "1"))
+    (package
+     (name "sbcl-http-body")
+     (version (git-version "0.1.0" revision commit))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/fukamachi/http-body")
+             (commit commit)))
+       (sha256
+        (base32 "1jd06snjvxcprhapgfq8sx0y5lrldkvhf206ix6d5a23dd6zcmr0"))))
+     (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))
+     (native-inputs
+      `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+        ("sbcl-prove" ,sbcl-prove)))
+     (inputs
+      `(("sbcl-fast-http" ,sbcl-fast-http)
+        ("sbcl-jonathan" ,sbcl-jonathan)
+        ("sbcl-quri" ,sbcl-quri)))
+     (home-page "https://github.com/fukamachi/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.")
+     (license license:bsd-2))))
+
+(define-public cl-http-body
+  (sbcl-package->cl-source-package sbcl-http-body))
+
-- 
2.20.1


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #32: 0031-gnu-Add-circular-streams.patch --]
[-- Type: text/x-patch, Size: 1922 bytes --]

From 48df1d15efc1917b0a62624ca89daef0b677b36e Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 16:08:00 -0500
Subject: [PATCH 31/42] gnu: Add circular-streams

---
 gnu/packages/lisp.scm | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index 1296795246..8178a6e227 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -4754,3 +4754,36 @@ multipart/form-data.")
 (define-public cl-http-body
   (sbcl-package->cl-source-package sbcl-http-body))
 
+(define-public sbcl-circular-streams
+  (let ((commit "e770bade1919c5e8533dd2078c93c3d3bbeb38df")
+        (revision "1"))
+    (package
+     (name "sbcl-circular-streams")
+     (version (git-version "0.1.0" revision commit))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/fukamachi/circular-streams")
+             (commit commit)))
+       (sha256
+        (base32 "1wpw6d5cciyqcf92f7mvihak52pd5s47kk4qq6f0r2z2as68p5rs"))))
+     (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))
+     (inputs
+      `(("sbcl-fast-io" ,sbcl-fast-io)
+        ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)))
+     (home-page "https://github.com/fukamachi/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.")
+     (license license:llgpl))))
+
+(define-public cl-circular-streams
+  (sbcl-package->cl-source-package sbcl-circular-streams))
+
-- 
2.20.1


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #33: 0032-gnu-Add-lack-request.patch --]
[-- Type: text/x-patch, Size: 2110 bytes --]

From db0ba55573f93166515e62351bae19dbb5f69310 Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 16:20:14 -0500
Subject: [PATCH 32/42] gnu: Add lack-request

---
 gnu/packages/lisp.scm | 39 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index 8178a6e227..ea42c2c736 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -4787,3 +4787,42 @@ reset to 0 and you're able to read it again.")
 (define-public cl-circular-streams
   (sbcl-package->cl-source-package sbcl-circular-streams))
 
+(define-public sbcl-lack-request
+  (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
+        (revision "1"))
+    (package
+     (name "sbcl-lack-request")
+     (version (git-version "0.1.0" revision commit))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/fukamachi/lack.git")
+             (commit commit)))
+       (sha256
+        (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
+     (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))
+     (native-inputs
+      `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+        ("sbcl-prove" ,sbcl-prove)))
+     (inputs
+      `(("sbcl-quri" ,sbcl-quri)
+        ("sbcl-http-body" ,sbcl-http-body)
+        ("sbcl-circular-streams" ,sbcl-circular-streams)))
+     (home-page "https://github.com/fukamachi/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.")
+     (license license:llgpl))))
+
+(define-public cl-lack-request
+  (sbcl-package->cl-source-package sbcl-lack-request))
+
-- 
2.20.1


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #34: 0033-gnu-Add-lack-response.patch --]
[-- Type: text/x-patch, Size: 2148 bytes --]

From 446307fd98e39f2d40b85204d37d66f567a5aa08 Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 16:22:46 -0500
Subject: [PATCH 33/42] gnu: Add lack-response

---
 gnu/packages/lisp.scm | 40 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index ea42c2c736..6a2b47bca0 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -4826,3 +4826,43 @@ performance and simplicity in mind.")
 (define-public cl-lack-request
   (sbcl-package->cl-source-package sbcl-lack-request))
 
+(define-public sbcl-lack-response
+  (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
+        (revision "1"))
+    (package
+     (name "sbcl-lack-response")
+     (version (git-version "0.1.0" revision commit))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/fukamachi/lack.git")
+             (commit commit)))
+       (sha256
+        (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
+     (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))
+     (native-inputs
+      `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+        ("sbcl-prove" ,sbcl-prove)))
+     (inputs
+      `(("sbcl-quri" ,sbcl-quri)
+        ("sbcl-http-body" ,sbcl-http-body)
+        ("sbcl-circular-streams" ,sbcl-circular-streams)
+        ("sbcl-local-time" ,sbcl-local-time)))
+     (home-page "https://github.com/fukamachi/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.")
+     (license license:llgpl))))
+
+(define-public cl-lack-response
+  (sbcl-package->cl-source-package sbcl-lack-response))
+
-- 
2.20.1


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #35: 0034-gnu-Add-lack-component.patch --]
[-- Type: text/x-patch, Size: 1847 bytes --]

From 59c1b7d563d92016fcfb5a41c0e8037f0433295d Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 16:23:43 -0500
Subject: [PATCH 34/42] gnu: Add lack-component

---
 gnu/packages/lisp.scm | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index 6a2b47bca0..dfe5c0e3b8 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -4866,3 +4866,35 @@ performance and simplicity in mind.")
 (define-public cl-lack-response
   (sbcl-package->cl-source-package sbcl-lack-response))
 
+(define-public sbcl-lack-component
+  (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
+        (revision "1"))
+    (package
+     (name "sbcl-lack-component")
+     (version (git-version "0.0.0" revision commit))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/fukamachi/lack.git")
+             (commit commit)))
+       (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))
+     (home-page "https://github.com/fukamachi/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.")
+     (license license:llgpl))))
+
+(define-public cl-lack-component
+  (sbcl-package->cl-source-package sbcl-lack-component))
+
-- 
2.20.1


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #36: 0035-gnu-Add-lack-util.patch --]
[-- Type: text/x-patch, Size: 1869 bytes --]

From daebe431d302ec00110b8c53c52ddb5acb5d5a73 Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 16:24:37 -0500
Subject: [PATCH 35/42] gnu: Add lack-util

---
 gnu/packages/lisp.scm | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index dfe5c0e3b8..a8be6f646f 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -4898,3 +4898,37 @@ performance and simplicity in mind.")
 (define-public cl-lack-component
   (sbcl-package->cl-source-package sbcl-lack-component))
 
+(define-public sbcl-lack-util
+  (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
+        (revision "1"))
+    (package
+     (name "sbcl-lack-util")
+     (version (git-version "0.1.0" revision commit))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/fukamachi/lack.git")
+             (commit commit)))
+       (sha256
+        (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
+     (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))
+     (inputs
+      `(("sbcl-ironclad" ,sbcl-ironclad)))
+     (home-page "https://github.com/fukamachi/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.")
+     (license license:llgpl))))
+
+(define-public cl-lack-util
+  (sbcl-package->cl-source-package sbcl-lack-util))
+
-- 
2.20.1


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #37: 0036-gnu-Add-lack-middleware-backtrace.patch --]
[-- Type: text/x-patch, Size: 1927 bytes --]

From d08752ea7aca8ad1239e9a383b9da477b5546913 Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 16:25:24 -0500
Subject: [PATCH 36/42] gnu: Add lack-middleware-backtrace

---
 gnu/packages/lisp.scm | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index a8be6f646f..b9d4ea63df 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -4932,3 +4932,35 @@ performance and simplicity in mind.")
 (define-public cl-lack-util
   (sbcl-package->cl-source-package sbcl-lack-util))
 
+(define-public sbcl-lack-middleware-backtrace
+  (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
+        (revision "1"))
+    (package
+     (name "sbcl-lack-middleware-backtrace")
+     (version (git-version "0.1.0" revision commit))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/fukamachi/lack.git")
+             (commit commit)))
+       (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))
+     (home-page "https://github.com/fukamachi/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.")
+     (license license:llgpl))))
+
+(define-public cl-lack-middleware-backtrace
+  (sbcl-package->cl-source-package sbcl-lack-middleware-backtrace))
+
-- 
2.20.1


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #38: 0037-gnu-Add-lack-middleware-static.patch --]
[-- Type: text/x-patch, Size: 2095 bytes --]

From b5f52a100df69f465e0263e5e34ed8f29773ea39 Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 16:27:01 -0500
Subject: [PATCH 37/42] gnu: Add lack-middleware-static

---
 gnu/packages/lisp.scm | 36 ++++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index b9d4ea63df..343836ed9a 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -4964,3 +4964,39 @@ performance and simplicity in mind.")
 (define-public cl-lack-middleware-backtrace
   (sbcl-package->cl-source-package sbcl-lack-middleware-backtrace))
 
+(define-public sbcl-lack-middleware-static
+  (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
+        (revision "1"))
+    (package
+     (name "sbcl-lack-middleware-static")
+     (version (git-version "0.1.0" revision commit))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/fukamachi/lack.git")
+             (commit commit)))
+       (sha256
+        (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
+     (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))
+     (inputs
+      `(("sbcl-ironclad" ,sbcl-ironclad)
+        ("sbcl-trivial-mimes" ,sbcl-trivial-mimes)
+        ("sbcl-local-time" ,sbcl-local-time)))
+     (home-page "https://github.com/fukamachi/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.")
+     (license license:llgpl))))
+
+(define-public cl-lack-middleware-static
+  (sbcl-package->cl-source-package sbcl-lack-middleware-static))
+
-- 
2.20.1


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #39: 0038-gnu-Add-lack.patch --]
[-- Type: text/x-patch, Size: 1835 bytes --]

From 279e20b0f509ebe3471875532b48152e41404a8c Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 16:28:04 -0500
Subject: [PATCH 38/42] gnu: Add lack

---
 gnu/packages/lisp.scm | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index 343836ed9a..2eb6730c39 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -5000,3 +5000,36 @@ performance and simplicity in mind.")
 (define-public cl-lack-middleware-static
   (sbcl-package->cl-source-package sbcl-lack-middleware-static))
 
+(define-public sbcl-lack
+  (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
+        (revision "1"))
+    (package
+     (name "sbcl-lack")
+     (version (git-version "0.1.0" revision commit))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/fukamachi/lack.git")
+             (commit commit)))
+       (sha256
+        (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
+     (build-system asdf-build-system/sbcl)
+     (arguments
+      '(#:test-asd-file "t-lack.asd"
+        #:tests? #f))
+     (inputs
+      `(("sbcl-lack-component" ,sbcl-lack-component)
+        ("sbcl-lack-util" ,sbcl-lack-util)))
+     (home-page "https://github.com/fukamachi/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.")
+     (license license:llgpl))))
+
+(define-public cl-lack
+  (sbcl-package->cl-source-package sbcl-lack))
+
-- 
2.20.1


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #40: 0039-gnu-Add-local-time.patch --]
[-- Type: text/x-patch, Size: 1867 bytes --]

From cecd64fcc2bf686a3271ec3d53e4395bc4e08711 Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 16:29:42 -0500
Subject: [PATCH 39/42] gnu: Add local-time

---
 gnu/packages/lisp.scm | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index 2eb6730c39..a9227b92f9 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -5033,3 +5033,38 @@ performance and simplicity in mind.")
 (define-public cl-lack
   (sbcl-package->cl-source-package sbcl-lack))
 
+(define-public sbcl-local-time
+  (let ((commit "beac054eef428552b63d4ae7820c32ffef9a3015")
+        (revision "1"))
+    (package
+     (name "sbcl-local-time")
+     (version (git-version "1.0.6" revision commit))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/dlowe-net/local-time.git")
+             (commit commit)))
+       (sha256
+        (base32 "0xhkmgxh41dg2wwlsp0h2l41jp144xn4gpxhh0lna6kh0560w2cc"))))
+     (build-system asdf-build-system/sbcl)
+     (arguments
+      ;; TODO: Component :STEFIL not found, required by #<SYSTEM
+      ;; "local-time/test">
+      '(#:tests? #f))
+     (native-inputs
+      `(("stefil" ,sbcl-hu.dwim.stefil)))
+     (inputs
+      `(("sbcl-cl-fad" ,sbcl-cl-fad)))
+     (home-page "https://common-lisp.net/project/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\".")
+     ;; MIT
+     (license license:expat))))
+
+(define-public cl-local-time
+  (sbcl-package->cl-source-package sbcl-local-time))
+
-- 
2.20.1


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #41: 0040-gnu-Add-ningle.patch --]
[-- Type: text/x-patch, Size: 3205 bytes --]

From 5071b0d9bec98bdf0c86c85833bae910df025c01 Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 16:31:37 -0500
Subject: [PATCH 40/42] gnu: Add ningle

---
 gnu/packages/lisp.scm | 61 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 61 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index a9227b92f9..764a30e97a 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -5068,3 +5068,64 @@ paper \"The Long Painful History of Time\".")
 (define-public cl-local-time
   (sbcl-package->cl-source-package sbcl-local-time))
 
+(define-public sbcl-ningle
+  (let ((commit "50bd4f09b5a03a7249bd4d78265d6451563b25ad")
+        (revision "1"))
+    (package
+      (name "sbcl-ningle")
+      (version (git-version "0.3.0" revision commit))
+      (source
+       (origin
+         (method git-fetch)
+         (uri (git-reference
+               (url "https://github.com/fukamachi/ningle.git")
+               (commit commit)))
+         (sha256
+          (base32 "1bsl8cnxhacb8p92z9n89vhk1ikmij5zavk0m2zvmj7iqm79jzgw"))))
+      (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$")))
+                 (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))
+                 fasl-files))))))
+      (native-inputs
+       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+         ("sbcl-prove" ,sbcl-prove)))
+      (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)))
+      (home-page "http://8arrow.org/ningle/")
+      (synopsis "Super micro framework for Common Lisp")
+      (description
+       "Ningle is a lightweight web application framework for Common Lisp.")
+      (license license:llgpl))))
+
+(define-public cl-ningle
+  (sbcl-package->cl-source-package sbcl-ningle))
+
-- 
2.20.1


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #42: 0041-gnu-Add-trivial-mimes.patch --]
[-- Type: text/x-patch, Size: 2255 bytes --]

From 09e1250cdae31cf2dfc8fc97cbee578edc82276e Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 16:33:32 -0500
Subject: [PATCH 41/42] gnu: Add trivial-mimes

---
 gnu/packages/lisp.scm | 41 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index 764a30e97a..07ec2efa12 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -5129,3 +5129,44 @@ paper \"The Long Painful History of Time\".")
 (define-public cl-ningle
   (sbcl-package->cl-source-package sbcl-ningle))
 
+(define-public sbcl-trivial-mimes
+  (let ((commit "303f8ac0aa6ca0bc139aa3c34822e623c3723fab")
+        (revision "1"))
+    (package
+      (name "sbcl-trivial-mimes")
+      (version (git-version "1.1.0" revision commit))
+      (source
+       (origin
+         (method git-fetch)
+         (uri (git-reference
+               (url "https://github.com/Shinmera/trivial-mimes.git")
+               (commit commit)))
+         (sha256
+          (base32 "17jxgl47r695bvsb7wi3n2ws5rp1zzgvw0zii8cy5ggw4b4ayv6m"))))
+      (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\")")))))))))
+      (native-inputs
+       `(("stefil" ,sbcl-hu.dwim.stefil)))
+      (inputs
+       `(("sbcl-cl-fad" ,sbcl-cl-fad)))
+      (home-page "http://shinmera.github.io/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.")
+      (license license:artistic2.0))))
+
+(define-public cl-trivial-mimes
+  (sbcl-package->cl-source-package sbcl-trivial-mimes))
+
-- 
2.20.1


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #43: 0042-gnu-Add-clack.patch --]
[-- Type: text/x-patch, Size: 1722 bytes --]

From 1983505f62c0df61ac8f780fd8d3394c953a4612 Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <cox.katherine.e@gmail.com>
Date: Fri, 29 Mar 2019 16:34:36 -0500
Subject: [PATCH 42/42] gnu: Add clack

---
 gnu/packages/lisp.scm | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index 07ec2efa12..a4acd50712 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -5170,3 +5170,33 @@ mime-type of a file.")
 (define-public cl-trivial-mimes
   (sbcl-package->cl-source-package sbcl-trivial-mimes))
 
+(define-public sbcl-clack
+  (let ((commit "e3e032843bb1220ab96263c411aa7f2feb4746e0")
+        (revision "1"))
+    (package
+     (name "sbcl-clack")
+     (version (git-version "2.0.0" revision commit))
+     (source
+      (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/fukamachi/clack.git")
+             (commit commit)))
+       (sha256
+        (base32 "1ymzs6qyrwhlj6cgqsnpyn6g5cbp7a3s1vgxwna20y2q7y4iacy0"))))
+     (build-system asdf-build-system/sbcl)
+     (inputs
+      `(("sbcl-lack" ,sbcl-lack)
+        ("sbcl-lack-middleware-backtrace" ,sbcl-lack-middleware-backtrace)
+        ("sbcl-bordeaux-threads" ,sbcl-bordeaux-threads)))
+     (home-page "https://github.com/fukamachi/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.")
+     (license license:llgpl))))
+
+(define-public cl-clack
+  (sbcl-package->cl-source-package sbcl-clack))
-- 
2.20.1


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


-- 
Katherine

^ permalink raw reply related	[flat|nested] 12+ messages in thread

* bug#34959: Acknowledgement ([PATCH] Add Multiple Common Lisp Packages)
  2019-03-29 23:19       ` Katherine Cox-Buday
@ 2019-04-07  6:13         ` 宋文武
  2019-04-10 14:46           ` [bug#34959] " Katherine Cox-Buday
  0 siblings, 1 reply; 12+ messages in thread
From: 宋文武 @ 2019-04-07  6:13 UTC (permalink / raw)
  To: Katherine Cox-Buday; +Cc: 34959-done

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

> Phew! I hope I did this right because that was a lot of work to get
> those in shape! ;p

With some minor issues (lack commit messages, and some patches are out
of order etc.) fixed, I push them all, thank you!!

>
> I've at least learned more about Guix packaging :)

Welcome :-)

^ permalink raw reply	[flat|nested] 12+ messages in thread

* [bug#34959] Acknowledgement ([PATCH] Add Multiple Common Lisp Packages)
  2019-04-07  6:13         ` bug#34959: " 宋文武
@ 2019-04-10 14:46           ` Katherine Cox-Buday
  2019-04-10 17:00             ` Ricardo Wurmus
  0 siblings, 1 reply; 12+ messages in thread
From: Katherine Cox-Buday @ 2019-04-10 14:46 UTC (permalink / raw)
  To: 宋文武; +Cc: 34959-done

iyzsong@member.fsf.org (宋文武) writes:

> Katherine Cox-Buday <cox.katherine.e@gmail.com> writes:
>
>> Phew! I hope I did this right because that was a lot of work to get
>> those in shape! ;p
>
> With some minor issues (lack commit messages, and some patches are out
> of order etc.) fixed, I push them all, thank you!!
>
>>
>> I've at least learned more about Guix packaging :)
>
> Welcome :-)

Thanks very much for fixing these things up and landing! I continue to
have great experiences with devs in the Guix community, and it
encourages me to keep contributing :)

Do all commits require message bodies?

-- 
Katherine

^ permalink raw reply	[flat|nested] 12+ messages in thread

* [bug#34959] Acknowledgement ([PATCH] Add Multiple Common Lisp Packages)
  2019-04-10 14:46           ` [bug#34959] " Katherine Cox-Buday
@ 2019-04-10 17:00             ` Ricardo Wurmus
  2019-04-10 17:57               ` Katherine Cox-Buday
  0 siblings, 1 reply; 12+ messages in thread
From: Ricardo Wurmus @ 2019-04-10 17:00 UTC (permalink / raw)
  To: Katherine Cox-Buday; +Cc: 宋文武, 34959-done

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

> Do all commits require message bodies?

Yes, for better or worse we adhere to the GNU conventions in commit
messages.  Since the format is predictable and can be, in part, derived
from the changes we offer Emacs snippets that can be used to generate
the commit messages more quickly.

If you’re using Emacs and Magit you only need to type “add” or “update”
and hit TAB to have the commit message generated for you.

(If you’re not using Emacs we would welcome snippets for other editors
to make it writing commit messages easier.) 

--
Ricardo

^ permalink raw reply	[flat|nested] 12+ messages in thread

* [bug#34959] Acknowledgement ([PATCH] Add Multiple Common Lisp Packages)
  2019-04-10 17:00             ` Ricardo Wurmus
@ 2019-04-10 17:57               ` Katherine Cox-Buday
  2019-04-10 18:19                 ` Ricardo Wurmus
  0 siblings, 1 reply; 12+ messages in thread
From: Katherine Cox-Buday @ 2019-04-10 17:57 UTC (permalink / raw)
  To: Ricardo Wurmus; +Cc: 宋文武, 34959-done

Ricardo Wurmus <rekado@elephly.net> writes:

> Katherine Cox-Buday <cox.katherine.e@gmail.com> writes:
>
>> Do all commits require message bodies?
>
> Yes, for better or worse we adhere to the GNU conventions in commit
> messages.  Since the format is predictable and can be, in part, derived
> from the changes we offer Emacs snippets that can be used to generate
> the commit messages more quickly.
>
> If you’re using Emacs and Magit you only need to type “add” or “update”
> and hit TAB to have the commit message generated for you.
>
> (If you’re not using Emacs we would welcome snippets for other editors
> to make it writing commit messages easier.) 
>
> --
> Ricardo

I am indeed using emacs and magit, so I'll start doing this.

As an aside, I don't know how much of this is obvious to other folks
(i.e. maybe folks who contribute to GNU projects more often), but I feel
like I've been discovering things like this which aren't in the Guix
manual. Did I just miss this stuff (very possible!), or are we missing
some instruction and perhaps links to GNU standards?

-- 
Katherine

^ permalink raw reply	[flat|nested] 12+ messages in thread

* [bug#34959] Acknowledgement ([PATCH] Add Multiple Common Lisp Packages)
  2019-04-10 17:57               ` Katherine Cox-Buday
@ 2019-04-10 18:19                 ` Ricardo Wurmus
  0 siblings, 0 replies; 12+ messages in thread
From: Ricardo Wurmus @ 2019-04-10 18:19 UTC (permalink / raw)
  To: Katherine Cox-Buday; +Cc: 宋文武, 34959-done

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

> As an aside, I don't know how much of this is obvious to other folks
> (i.e. maybe folks who contribute to GNU projects more often), but I feel
> like I've been discovering things like this which aren't in the Guix
> manual. Did I just miss this stuff (very possible!), or are we missing
> some instruction and perhaps links to GNU standards?

The “Contributing” section in the manual does link to the GNU standards
(if you’re reading this in an Info reader like Emacs you may want to
install the “gnu-standards” package to be able to follow the link
locally).

It also mentions the snippets and how to use them.

The Contributing section in the manual is pretty big, so it’s easy to
miss something.

--
Ricardo

^ permalink raw reply	[flat|nested] 12+ messages in thread

end of thread, other threads:[~2019-04-10 18:21 UTC | newest]

Thread overview: 12+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2019-03-23 20:14 [bug#34959] [PATCH] Add Multiple Common Lisp Packages Katherine Cox-Buday
     [not found] ` <handler.34959.B.155337211019624.ack@debbugs.gnu.org>
2019-03-23 20:41   ` [bug#34959] Acknowledgement ([PATCH] Add Multiple Common Lisp Packages) Katherine Cox-Buday
2019-03-24 10:01     ` Ricardo Wurmus
2019-03-28 17:38       ` Katherine Cox-Buday
2019-03-28 20:43         ` Ricardo Wurmus
2019-03-29 17:15           ` Katherine Cox-Buday
2019-03-29 23:19       ` Katherine Cox-Buday
2019-04-07  6:13         ` bug#34959: " 宋文武
2019-04-10 14:46           ` [bug#34959] " Katherine Cox-Buday
2019-04-10 17:00             ` Ricardo Wurmus
2019-04-10 17:57               ` Katherine Cox-Buday
2019-04-10 18:19                 ` Ricardo Wurmus

Code repositories for project(s) associated with this external index

	https://git.savannah.gnu.org/cgit/guix.git

This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.