>From 81b0547c40c20ef040e7bc0f2d0623b39bd38098 Mon Sep 17 00:00:00 2001
From: Andy Patterson <address@hidden>
Date: Thu, 10 May 2018 01:07:22 -0400
Subject: [PATCH] gnu: Add some lisp packages.

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

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index 1f8e6ab42..17e709641 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -1433,3 +1433,730 @@ compressor.  It works on data produced by @code{parse-js} to generate a
      `(("sbcl" ,sbcl)
        ("sbcl-cl-uglify-js" ,sbcl-cl-uglify-js)))
     (synopsis "JavaScript compressor")))
+
+(define-public sbcl-closer-mop
+  (package
+    (name "sbcl-closer-mop")
+    (version "1.0.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://github.com/pcostanza/closer-mop"
+                           "/archive/v" version ".tar.gz"))
+       (sha256
+        (base32 "1pyc8lk2yxbjhycm57377vhxy0xrh2pmg0w89m7fifan6haiisbl"))
+       (file-name (string-append "closer-mop-" version ".tar.gz"))))
+    (build-system asdf-build-system/sbcl)
+    (home-page "https://github.com/pcostanza/closer-mop/")
+    (synopsis "Meta Object Protocol (MOP) compatibility layer")
+    (description "Closer to MOP is a compatibility layer that rectifies many
+of the absent or incorrect CLOS MOP features across a broad range of Common
+Lisp implementations.")
+    (license license:x11)))
+
+(define-public sbcl-trivial-types
+  (let ((commit "ee869f2b7504d8aa9a74403641a5b42b16f47d88")
+        (revision "1"))
+    (package
+      (name "sbcl-trivial-types")
+      (version (string-append "0.1-" revision "." (string-take commit 7)))
+      (source
+       (origin
+         (method git-fetch)
+         (uri (git-reference
+               (url "https://github.com/m2ym/trivial-types.git")
+               (commit commit)))
+         (sha256
+          (base32 "1s4cp9bdlbn8447q7w7f1wkgwrbvfzp20mgs307l5pxvdslin341"))
+         (file-name (string-append "trivial-types-" version "-checkout"))))
+      (build-system asdf-build-system/sbcl)
+      (home-page "https://github.com/m2ym/trivial-types")
+      (synopsis "Trivial type definitions")
+      (description "TRIVIAL-TYPES provides missing but important type
+definitions such as PROPER-LIST, ASSOCIATION-LIST, PROPERTY-LIST and TUPLE.
+By using these types, you can keep type declarations more accurate. For
+example, you may write a class definition like:
+
address@hidden
+(defclass person ()
+  ((name :type string))
+  ((age :type fixnum))
+  ((friends :type list)))
address@hidden example
+
+However, it is not obvious for anyone except you that FRIENDS slot has
+only a list of person. If you want declare FRIENDS slot more
+accurately, PROPER-LIST is the best for that:
+
address@hidden
+(defclass person ()
+  ((name :type string))
+  ((age :type fixnum))
+  ((friends :type (proper-list person))))
address@hidden example
+
+In addition, TRIVIAL-TYPES also provides standard designators defined
+in ANSI standard such as PACKAGE-DESIGNATOR. They are useful when you
+write a function that takes a package-oid argument like:
+
address@hidden
+(defun list-external-symbols (package)
+  (declare (package-designator package))
+  (loop for symbol being the external-symbol of package
+        collect symbol))
address@hidden example
+")
+      (license license:lgpl2.0+))))
+
+(define-public sbcl-named-readtables
+  (let ((commit "4dfb89fa1af6b305b6492b8af042f5190c11e9fc")
+        (revision "1"))
+    (package
+      (name "sbcl-named-readtables")
+      (version (string-append "0.9-" revision "." (string-take commit 7)))
+      (source
+       (origin
+         (method git-fetch)
+         (uri (git-reference
+
+               (url "https://github.com/melisgl/named-readtables.git")
+               (commit commit)))
+         (sha256
+          (base32 "083kgh5462iqbb4px6kq8s7sggvpvkm36hx4qi9rnaw53b6ilqkk"))
+         (file-name (string-append "named-readtables-" version "-checkout"))))
+      (build-system asdf-build-system/sbcl)
+      (home-page "https://github.com/melisgl/named-readtables/")
+      (synopsis "Library that creates a namespace for named readtables")
+      (description "Named readtables is a library that creates a namespace for
+named readtables, which is akin to package namespacing in Common Lisp.")
+      (license license:bsd-3))))
+
+(define-public sbcl-cl-interpol
+  (package
+    (name "sbcl-cl-interpol")
+    (version "0.2.6")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://github.com/edicl/cl-interpol"
+                           "/archive/v" version ".tar.gz"))
+       (sha256
+        (base32 "1cdl0dn55nsrr9w5ykzfgwh3f76n4k7g9cd1i6d90nqsdcnnwc3x"))
+       (file-name (string-append "cl-interpol-" version ".tar.gz"))))
+    (build-system asdf-build-system/sbcl)
+    (inputs `(("cl-unicode" ,sbcl-cl-unicode)))
+    (native-inputs `(("flexi-streams" ,sbcl-flexi-streams)))
+    (home-page "http://weitz.de/cl-interpol/")
+    (synopsis "String interpolation library for Common Lisp")
+    (description "CL-INTERPOL is a library for Common Lisp which modifies the
+reader so that you can have interpolation within strings similar to Perl or
+Unix Shell scripts.  It also provides various ways to insert arbitrary
+characters into literal strings even if your editor/IDE doesn't support
+them.")
+    (license license:bsd-2)))
+
+(define-public sbcl-split-sequence
+  (package
+    (name "sbcl-split-sequence")
+    (version "1.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://github.com/sharplispers/split-sequence"
+                           "/archive/v" version ".tar.gz"))
+       (sha256
+        (base32 "12qgmnas2vd1wgyddf4fv2j5xsaj5mb2r0ylh043bwr6986gdbqa"))
+       (file-name (string-append "split-sequence-" version ".tar.gz"))))
+    (build-system asdf-build-system/sbcl)
+    (native-inputs `(("fiveam" ,sbcl-fiveam)))
+    (home-page "http://cliki.net/split-sequence")
+    (synopsis "Common Lisp utility to split sequences")
+    (description "A Common Lisp library whose purpose is to split a sequence
+into a list of subsequences delimited by objects satisfying a test.")
+    (license license:public-domain)))
+
+(define-public sbcl-rt
+  (let ((revision "1")
+        (commit "a6a7503a0b47953bc7579c90f02a6dba1f6e4c5a"))
+    (package
+      (name "sbcl-rt")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source
+       (origin
+         (method git-fetch)
+         (uri
+          (git-reference
+           (url "http://git.kpe.io/rt.git")
+           (commit commit)))
+         (sha256
+          (base32 "13si2rrxaagbr0bkvg6sqicxxpyshabx6ad6byc9n2ik5ysna69b"))
+         (file-name (string-append "rt-" version "-checkout"))))
+      (build-system asdf-build-system/sbcl)
+      (home-page "http://www.cliki.net/RT")
+      (synopsis "Regression testing framework")
+      (description "@code{rt} is short for \"regression testing\", an older
+test tramework from the CMU AI Repository.")
+      (license (list
+                license:lgpl3 ; for rt.asd
+                license:expat))))) ; for rt.lisp
+
+(define-public sbcl-hu.dwim.asdf
+  (let ((revision "1")
+        (commit "170b0e4fdde3df0bc537327e7600575daac9e141"))
+    (package
+      (name "sbcl-hu.dwim.asdf")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source
+       (origin
+         (method git-fetch)
+         (uri
+          (git-reference
+           (url "https://github.com/nixeagle/hu.dwim.asdf")
+           (commit commit)))
+         (sha256
+          (base32 "10ax7p8y6vjqxzcq125p62kf68zi455a65ysgk0kl1f2v839c33v"))
+         (file-name (string-append "hu.dwim.asdf-" version "-checkout"))))
+      (build-system asdf-build-system/sbcl)
+      (home-page "http://hub.darcs.net/hu.dwim/hu.dwim.asdf")
+      (synopsis "Extensions to ASDF")
+      (description "Various ASDF extensions such as attached test and
+documentation system, explicit development support, etc.")
+      (license license:public-domain))))
+
+(define-public sbcl-hu.dwim.stefil
+  (let ((revision "1")
+        (commit "ab6d1aa8995878a1b66d745dfd0ba021090bbcf9"))
+    (package
+      (name "sbcl-hu.dwim.stefil")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source
+       (origin
+         (method git-fetch)
+         (uri
+          (git-reference
+           (url "https://gitlab.common-lisp.net/xcvb/hu.dwim.stefil.git")
+           (commit commit)))
+         (sha256
+          (base32 "1d8yccw65zj3zh46cbi3x6nmn1dwdb76s9d0av035077mvyirqqp"))
+         (file-name (string-append "hu.dwim.stefil-" version "-checkout"))))
+      (build-system asdf-build-system/sbcl)
+      (native-inputs
+       `(("asdf:cl-hu.dwim.asdf" ,sbcl-hu.dwim.asdf)))
+      (inputs
+       `(("sbcl-alexandria" ,sbcl-alexandria)))
+      (home-page "http://hub.darcs.net/hu.dwim/hu.dwim.stefil")
+      (synopsis "Simple test framework")
+      (description "Stefil is a simple test framework for Common Lisp,
+with a focus on interactive development.")
+      (license license:public-domain))))
+
+(define-public sbcl-repl-utilities
+  (let ((commit "e0de9c92e774f77cab1a4cd92e2ac922ac3a807e")
+        (revision "1"))
+    (package
+      (name "sbcl-repl-utilities")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source
+       (origin
+         (method git-fetch)
+         (uri (git-reference
+               (url "https://github.com/m-n/repl-utilities.git")
+               (commit commit)))
+         (sha256
+          (base32 "1r5icmw3ha5y77kvzqni3a9bcd66d9pz5mjsbw04xg3jk0d15cgz"))
+         (file-name (string-append "repl-utilities" version "-checkout"))))
+      (build-system asdf-build-system/sbcl)
+      (home-page "https://github.com/m-n/repl-utilities/")
+      (synopsis "Library to simplify life at the REPL")
+      (description "REPL-Utilities provides a set of features which makes the
+use of the Read-Eval-Print-Loop (REPL) easier for common tasks.")
+      (license license:bsd-3))))
+
+(define-public sbcl-babel
+  (package
+    (name "sbcl-babel")
+    (version "0.5.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://github.com/cl-babel/babel/archive/v"
+             version ".tar.gz"))
+       (sha256
+        (base32 "189kgbmslh36xx0d2i1g6a7mcvjryvjzkdlnhilqy5xs7hkyqirq"))
+       (file-name (string-append name "-" version ".tar.gz"))))
+    (build-system asdf-build-system/sbcl)
+    (native-inputs
+     `(("tests:cl-hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
+    (inputs
+     `(("sbcl-alexandria" ,sbcl-alexandria)
+       ("sbcl-trivial-features" ,sbcl-trivial-features-bootstrap)))
+    (home-page "https://common-lisp.net/project/babel/")
+    (synopsis "Charset encoding and decoding library")
+    (description "Babel is a charset encoding and decoding library, not unlike
+GNU libiconv, but completely written in Common Lisp.")
+    (license license:x11)))
+
+(define-public sbcl-cffi-bootstrap
+  (package
+    (name "sbcl-cffi-bootstrap")
+    (version "0.18.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://github.com/cffi/cffi/archive/v"
+                           version ".tar.gz"))
+       (sha256
+        (base32 "0ac40z3sg5szhm99l3bjpm0v1yz2vlhc6scqx1qzvlfcawc66m9q"))
+       (file-name (string-append name "-" version ".tar.gz"))))
+    (build-system asdf-build-system/sbcl)
+    (inputs
+     `(("libffi" ,libffi)
+       ("alexandria" ,sbcl-alexandria)
+       ("babel" ,sbcl-babel)
+       ("trivial-features" ,sbcl-trivial-features-bootstrap)))
+    (native-inputs
+     `(("pkg-config" ,pkg-config)))
+    (arguments
+     '(#:phases
+       (modify-phases %standard-phases
+         (add-after 'unpack 'fix-paths
+           (lambda* (#:key inputs #:allow-other-keys)
+             (substitute* "libffi/libffi.lisp"
+               (("libffi.so.6" all) (string-append
+                                     (assoc-ref inputs "libffi")
+                                     "/lib/" all)))
+             (substitute* "toolchain/c-toolchain.lisp"
+               (("\"cc\"") (format #f "~S" (which "gcc")))))))
+       #:asd-system-name "cffi"
+       #:tests? #f))
+    (home-page "http://common-lisp.net/project/cffi")
+    (synopsis "Common Foreign Function Interface for Common Lisp")
+    (description "The Common Foreign Function Interface (CFFI)
+purports to be a portable foreign function interface for Common Lisp.
+The CFFI library is composed of a Lisp-implementation-specific backend
+in the CFFI-SYS package, and a portable frontend in the CFFI
+package.")
+    (license license:x11)))
+
+(define-public sbcl-cffi-toolchain
+  (package
+    (inherit sbcl-cffi-bootstrap)
+    (name "sbcl-cffi-toolchain")
+    (inputs
+     `(("libffi" ,libffi)
+       ("sbcl-cffi" ,sbcl-cffi-bootstrap)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cffi-bootstrap)
+       ((#:asd-system-name _) #f)
+       ((#:tests? _) #t)))))
+
+(define-public sbcl-cffi-libffi
+  (package
+    (inherit sbcl-cffi-toolchain)
+    (name "sbcl-cffi-libffi")
+    (inputs
+     `(("cffi" ,sbcl-cffi-bootstrap)
+       ("cffi-grovel" ,sbcl-cffi-grovel)
+       ("trivial-features" ,sbcl-trivial-features-bootstrap)
+       ("libffi" ,libffi)))))
+
+(define-public sbcl-cffi-grovel
+  (package
+    (inherit sbcl-cffi-toolchain)
+    (name "sbcl-cffi-grovel")
+    (inputs
+     `(("libffi" ,libffi)
+       ("cffi" ,sbcl-cffi-bootstrap)
+       ("cffi-toolchain" ,sbcl-cffi-toolchain)
+       ("alexandria" ,sbcl-alexandria)))
+    (arguments
+     (substitute-keyword-arguments (package-arguments sbcl-cffi-toolchain)
+       ((#:phases phases)
+        `(modify-phases ,phases
+           (add-after 'build 'install-headers
+             (lambda* (#:key outputs #:allow-other-keys)
+               (install-file "grovel/common.h"
+                             (string-append
+                              (assoc-ref outputs "out")
+                              "/include/grovel"))))))))))
+
+(define-public sbcl-cffi
+  (package
+    (inherit sbcl-cffi-toolchain)
+    (name "sbcl-cffi")
+    (inputs (package-inputs sbcl-cffi-bootstrap))
+    (native-inputs
+     `(("cffi-grovel" ,sbcl-cffi-grovel)
+       ("cffi-libffi" ,sbcl-cffi-libffi)
+       ("rt" ,sbcl-rt)
+       ("bordeaux-threads" ,sbcl-bordeaux-threads)
+       ,@(package-native-inputs sbcl-cffi-bootstrap)))))
+
+(define-public sbcl-trivial-features-bootstrap
+  (package
+    (name "sbcl-trivial-features")
+    (version "0.8")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://github.com/trivial-features/trivial-features/archive/v"
+             version ".tar.gz"))
+       (sha256
+        (base32 "0db1awn6jyhcfhyfvpjvfziprmq85cigf19mwbvaprhblydsag3c"))
+       (file-name (string-append "trivial-features-" version ".tar.gz"))))
+    (build-system asdf-build-system/sbcl)
+    (arguments '(#:tests? #f))
+    (home-page "http://cliki.net/trivial-features")
+    (synopsis "Ensures consistency of @code{*FEATURES*} in Common Lisp")
+    (description "Trivial-features ensures that @code{*FEATURES*} is
+consistent across multiple Common Lisp implementations.")
+    (license license:x11)))
+
+(define-public sbcl-osicat
+  (package
+    (name "sbcl-osicat")
+    (version "0.7.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://github.com/osicat/osicat/archive/v"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "10g8gvmnpl94c3iqf6nav663brk1qnc9wyz46q3vk4i77pbl63r6"))
+       (file-name (string-append "osicat-" version ".tar.gz"))))
+    (build-system asdf-build-system/sbcl)
+    (inputs
+     `(("cffi" ,sbcl-cffi)
+       ("alexandria" ,sbcl-alexandria)
+       ("trivial-features" ,sbcl-trivial-features-bootstrap)))
+    (native-inputs
+     `(("cffi-grovel" ,sbcl-cffi-grovel)
+       ("rt" ,sbcl-rt)))
+    (arguments
+     '(#:phases
+       (modify-phases %standard-phases
+         ;; We don't want the libraries in lib/<lisp>/posix re-parented.
+         (delete 'cleanup))))
+    (home-page "https://common-lisp.net/project/osicat/")
+    (synopsis "Lightweight operating system interface for Common Lisp")
+    (description "Osicat is a lightweight operating system interface for
+Common Lisp on POSIX-like systems, including Windows.")
+    (license license:x11)))
+
+(define-public sbcl-iterate
+  (let ((hash "e65a5020b5392fbb6be1cd4d3190d4e3fbe00f52")
+        (revision "1"))
+    (package
+      (name "sbcl-iterate")
+      (version (string-append "0.0.0-" revision "." (string-take hash 7)))
+      (source
+       (origin
+         (method darcs-fetch)
+         (uri
+          (darcs-reference
+           (url "https://www.common-lisp.net/project/iterate/darcs/iterate/")
+           (hash hash)))
+         (sha256
+          (base32 "1y7smkpa7haxmq17yrph8ax8lgc549pgc9sbzwz1bynqqycfj8id"))
+         (file-name (string-append "iterate-" version "-checkout"))))
+      (build-system asdf-build-system/sbcl)
+      (native-inputs
+       `(("rt" ,sbcl-rt)))
+      (home-page "https://common-lisp.net/project/iterate/")
+      (synopsis "Iteration facility for Common Lisp")
+      (description "Iterate is an iteration construct for Common Lisp. It is
+similar to the CL:LOOP macro, with these distinguishing marks:
+
address@hidden
address@hidden It is extensible.
address@hidden It helps editors like Emacs indent iterate forms by having a more
+lisp-like syntax.
address@hidden It isn't part of the ANSI standard for Common Lisp.
address@hidden enumerate
+")
+      (license license:isc))))
+
+(define-public sbcl-anaphora
+  (package
+    (name "sbcl-anaphora")
+    (version "0.9.6")
+    (source
+     (origin
+       (method url-fetch)
+       (uri "https://github.com/tokenrove/anaphora/archive/0.9.6.tar.gz")
+       (file-name (string-append "anaphora-" version ".tar.gz"))
+       (sha256
+        (base32 "0bp8vg0y4ljla3i9322lyddmys4gzzhqq97zz4bjn46qrk5dvywl"))))
+    (build-system asdf-build-system/sbcl)
+    (native-inputs
+     `(("rt" ,sbcl-rt)))
+    (home-page "https://common-lisp.net/project/anaphora/")
+    (synopsis "Anaphoric macro package for Common Lisp")
+    (description "Anaphora is the anaphoric macro collection from Hell: it
+includes many new fiends in addition to old friends like AIF and AWHEN.")
+    (license license:public-domain)))
+
+(define-public sbcl-lift
+  (let ((commit "7d49a66c62759535624037826891152223d4206c")
+        (revision "1"))
+    (package
+      (name "sbcl-lift")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source
+       (origin
+         (method git-fetch)
+         (uri
+          (git-reference
+           (url "https://github.com/gwkkwg/lift.git")
+           (commit commit)))
+         (file-name (string-append "lift-" version "-checkout"))
+         (sha256
+          (base32 "127v5avpz1i4m0lkaxqrq8hrl69rdazqaxf6s8awf0nd7wj2g4dp"))))
+      (build-system asdf-build-system/sbcl)
+      (arguments
+       ;; The tests require a debugger, but we run with the debugger disabled.
+       '(#:tests? #f
+         #:phases
+         (modify-phases %standard-phases
+           ;; Do this to ensure the 'reset-gzip-timestamps phase works.
+           (add-after 'unpack 'make-gzips-writeable
+             (lambda _
+               (for-each (lambda (file)
+                           (chmod file #o755))
+                         (find-files "." "\\.gz$")))))))
+      ;; XXX: https://www.common-lisp.net/project/lift is gone for some reason.
+      (home-page "https://www.common-lisp.net/project/lift/user-guide.html")
+      (synopsis "Common Lisp test framework")
+      (description "LIFT is the LIsp Framework for Testing.  It is an SUnit
+variant.")
+      (license license:x11-style))))
+
+(define-public sbcl-let-plus
+  (let ((commit "77efafd94aba3943d4289fcc88377fe9240448a8")
+        (revision "1"))
+    (package
+      (name "sbcl-let-plus")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source
+       (origin
+         (method git-fetch)
+         (uri
+          (git-reference
+           (url "https://github.com/tpapp/let-plus.git")
+           (commit commit)))
+         (file-name (string-append "let-plus-" version "-checkout"))
+         (sha256
+          (base32 "07vgp2a4szdb07bph7iv2r067x4csl68nw3hjgdfxpmz08nr1jnv"))))
+      (build-system asdf-build-system/sbcl)
+      (inputs
+       `(("anaphora" ,sbcl-anaphora)
+         ("alexandria" ,sbcl-alexandria)))
+      (native-inputs
+       `(("lift" ,sbcl-lift)))
+      (home-page "https://github.com/tpapp/let-plus")
+      (synopsis "Destructuring extension of let*")
+      (description "Library which implements the let+ macro, which is a
+dectructuring extension of let*.  It features:
+
address@hidden
address@hidden placeholder macros allow editor hints and syntax highlighting
address@hidden &ign for ignored values (in forms where that makes sense)
address@hidden very easy to extend
address@hidden enumerate
+")
+      (license license:boost1.0))))
+
+(define-public sbcl-cl-colors
+  (let ((commit "1867afb1fe75dcc8b72f139a4bb5290b70bc1cad")
+        (revision "1"))
+    (package
+      (name "sbcl-cl-colors")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source
+       (origin
+         (method git-fetch)
+         (uri
+          (git-reference
+           (url "https://github.com/tpapp/cl-colors.git")
+           (commit commit)))
+         (file-name (string-append "cl-colours-" version "-checkout"))
+         (sha256
+          (base32 "139j94vwa5ygzzk4w4aij6z75wh4ymlkpqj28h7vxp6ixchx668s"))))
+      (build-system asdf-build-system/sbcl)
+      (inputs
+       `(("alexandria" ,sbcl-alexandria)
+         ("let-plus" ,sbcl-let-plus)))
+      (home-page "http://www.cliki.net/cl-colors")
+      (synopsis "Simple color library for Common Lisp")
+      (description "CL-colors is a very simple color library for Common Lisp.
+It provides:
+
address@hidden
address@hidden Types for representing colors in HSV and RGB spaces.
address@hidden Simple conversion functions between the above types.
address@hidden Some predefined colors (currently X11 color names).
address@hidden enumerate
+")
+      (license license:boost1.0))))
+
+(define-public sbcl-cl-ansi-text
+  (let ((commit "53badf7878f27f22f2d4a2a43e6df458e43acbe9")
+        (revision "1"))
+    (package
+      (name "sbcl-cl-ansi-text")
+      (version (git-version "0.0.0" revision commit))
+      (source
+       (origin
+         (method git-fetch)
+         (uri
+          (git-reference
+           (url "https://github.com/pnathan/cl-ansi-text.git")
+           (commit commit)))
+         (file-name (git-file-name "cl-ansi-text" version))
+         (sha256
+          (base32 "11i27n0dbz5lmygiw65zzr8lx0rac6b6yysqranphn31wls6ja3v"))))
+      (build-system asdf-build-system/sbcl)
+      (inputs
+       `(("alexandria" ,sbcl-alexandria)
+         ("cl-colors" ,sbcl-cl-colors)))
+      (home-page "https://github.com/pnathan/cl-ansi-text")
+      (synopsis "ANSI terminal color implementation for Common Lisp")
+      (description "CL-ansi-text provides utilities which enable printing to
+an ANSI terminal with colored text.  It provides the macro with-color 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.")
+      (license license:lgpl2.0+))))
+
+(define-public sbcl-prove-asdf
+  (let ((commit "e217d243a5e363e44951c096072ff8e57824db93")
+        (revision "1"))
+    (package
+      (name "sbcl-prove-asdf")
+      (version (git-version "1.0.0" revision commit))
+      (source
+       (origin
+         (method git-fetch)
+         (uri
+          (git-reference
+           (url "https://github.com/fukamachi/prove.git")
+           (commit commit)))
+         (file-name (git-file-name "prove" version))
+         (sha256
+          (base32 "0xbr6prv096fjha1fnfwv5vh5w7r6rhw3fbb2sxw92nmvnj33cbk"))))
+      (build-system asdf-build-system/sbcl)
+      (home-page "https://github.com/fukamachi/prove")
+      (synopsis "Unit testing framework for Common Lisp")
+      (description "Prove is yet another unit testing framework for Common
+Lisp.
+It features:
+
address@hidden
address@hidden Various simple functions for testing and informative error messages
address@hidden ASDF integration
address@hidden Extensible test reporters
address@hidden Colorizes the report if it's available
address@hidden Reports test durations
address@hidden enumerate
+")
+      (license license:x11))))
+
+(define-public sbcl-prove
+  (package
+    (inherit sbcl-prove-asdf)
+    (name "sbcl-prove")
+    (inputs
+     `(("alexandria" ,sbcl-alexandria)
+       ("cl-ansi-text" ,sbcl-cl-ansi-text)
+       ("cl-colors" ,sbcl-cl-colors)
+       ("cl-ppcre" ,sbcl-cl-ppcre)))
+    (native-inputs
+     `(("prove-asdf" ,sbcl-prove-asdf)
+       ("split-sequence" ,sbcl-split-sequence)))))
+
+(define-public sbcl-cl-test-more
+  (package
+    (inherit sbcl-prove)
+    (name "sbcl-cl-test-more")
+    (inputs
+     `(("prove" ,sbcl-prove)))
+    (arguments
+     '(#:phases
+       (modify-phases %standard-phases
+         ;; There are no output files so we need to handle this differently.
+         (add-before 'create-asd-file 'ensure-libdir-exists
+           (lambda* (#:key outputs #:allow-other-keys)
+             (mkdir-p (string-append
+                       (assoc-ref outputs "out") "/lib/" (%lisp-type)))))
+         ;; There are no components in this alias system.
+         (add-after 'create-asd-file 'remove-component-from-asd-file
+           (lambda* (#:key outputs #:allow-other-keys)
+             (define asd-file
+               (string-append
+                (assoc-ref outputs "out")
+                "/lib/" (%lisp-type) "/cl-test-more.asd"))
+             (substitute* asd-file
+               ((":components") "")
+               (("\\(\\(:compiled.*") ")")))))))))
+
+(define-public sbcl-cl21
+  (let ((commit "c36644f3b6ea4975174c8ce72de43a4524dd0696")
+        (revision "1"))
+    (package
+      (name "sbcl-cl21")
+      (version (git-version "0.0.0" revision commit))
+      (source
+       (origin
+         (method git-fetch)
+         (uri (git-reference
+               (url "https://github.com/cl21/cl21.git")
+               (commit commit)))
+         (sha256
+          (base32 "0pa0dx33br6ckhqlq7z7x562y1naidd5qns23pcbjnq1isfc5k8l"))
+         (file-name (string-append "cl21-" version "-checkout"))))
+      (build-system asdf-build-system/sbcl)
+      (inputs
+       `(("cl-ppcre" ,sbcl-cl-ppcre)
+         ("trivial-gray-streams" ,sbcl-trivial-gray-streams)
+         ("trivial-types" ,sbcl-trivial-types)
+         ("named-readtables" ,sbcl-named-readtables)
+         ("cl-interpol" ,sbcl-cl-interpol)
+         ("split-sequence" ,sbcl-split-sequence)
+         ("alexandria" ,sbcl-alexandria)
+         ("repl-utilities" ,sbcl-repl-utilities)
+         ("osicat" ,sbcl-osicat)
+         ("iterate" ,sbcl-iterate)
+         ("closer-mop" ,sbcl-closer-mop)))
+      (native-inputs
+       `(("cl-test-more" ,sbcl-cl-test-more)))
+      (arguments
+       '(#:phases
+         (modify-phases %standard-phases
+           (add-before 'check 'add-load-path
+             (lambda* (#:key outputs #:allow-other-keys)
+               (define path
+                 (string-append
+                  (assoc-ref outputs "out") %source-install-prefix "//"))
+               ;; XXX: After successfully running the tests, asdf complains
+               ;; that it cannot find the test system. Odd. Hack around it for
+               ;; now.
+               (prepend-to-source-registry path)
+               #t)))))
+      (home-page "http://cl21.org/")
+      (synopsis "Common Lisp in the 21st century")
+      (description "CL21 is an experimental project redesigning Common Lisp,
+which features:
+
address@hidden
address@hidden More object oriented.
address@hidden Add more functional programming facilities.
address@hidden Organize symbols into several packages.
address@hidden Include MOP.
address@hidden Syntax for regular expression.
address@hidden Written in pure Common Lisp.
address@hidden enumerate
+")
+      (license license:unlicense))))
-- 
2.17.0