aboutsummaryrefslogtreecommitdiff
path: root/gnu/packages/lisp.scm
diff options
context:
space:
mode:
authorRicardo Wurmus <rekado@elephly.net>2019-11-28 21:09:24 +0100
committerRicardo Wurmus <rekado@elephly.net>2019-11-28 21:09:24 +0100
commit076527c354795e6e1b23a7fd827ac1ce846b06f2 (patch)
treeef37fc4958212a370fd46b61e8a3868457cda487 /gnu/packages/lisp.scm
parentabf43a67d5929bf279edce3e790ef1348dda32a5 (diff)
downloadguix-076527c354795e6e1b23a7fd827ac1ce846b06f2.tar
guix-076527c354795e6e1b23a7fd827ac1ce846b06f2.tar.gz
Revert "gnu: Move lisp libraries to lisp-xyz, uglify-js to javascript and stumpwm to wm."
This reverts commit abf43a67d5929bf279edce3e790ef1348dda32a5 as it broke "guix pull".
Diffstat (limited to 'gnu/packages/lisp.scm')
-rw-r--r--gnu/packages/lisp.scm7323
1 files changed, 7317 insertions, 6 deletions
diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index dc44a9d133..9a83a1598a 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -31,17 +31,13 @@
;;; You should have received a copy of the GNU General Public License
;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>.
-;;; This file only contains Common Lisp compilers and tooling.
-;;; Common Lisp libraries go to lisp-xyz.scm.
-;;; Common Lisp applications should go to the most appropriate file,
-;;; e.g. StumpWM is in wm.scm.
-
(define-module (gnu packages lisp)
#:use-module (gnu packages)
#:use-module ((guix licenses) #:prefix license:)
#:use-module (guix packages)
#:use-module (guix download)
#:use-module (guix git-download)
+ #:use-module (guix hg-download)
#:use-module (guix utils)
#:use-module (guix build-system gnu)
#:use-module (guix build-system ant)
@@ -51,6 +47,7 @@
#:use-module (gnu packages base)
#:use-module (gnu packages bdw-gc)
#:use-module (gnu packages bison)
+ #:use-module (gnu packages c)
#:use-module (gnu packages compression)
#:use-module (gnu packages ed)
#:use-module (gnu packages flex)
@@ -68,13 +65,23 @@
#:use-module (gnu packages libsigsegv)
#:use-module (gnu packages linux)
#:use-module (gnu packages perl)
+ #:use-module (gnu packages pkg-config)
+ #:use-module (gnu packages python)
+ #:use-module (gnu packages python-xyz)
#:use-module (gnu packages readline)
#:use-module (gnu packages sdl)
+ #: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 (ice-9 match))
+ #:use-module (gnu packages databases)
+ #:use-module (gnu packages gtk)
+ #:use-module (gnu packages webkit)
+ #:use-module (gnu packages xdisorg)
+ #:use-module (ice-9 match)
+ #:use-module (srfi srfi-19))
(define (asdf-substitutions lisp)
;; Prepend XDG_DATA_DIRS/LISP-bundle-systems to ASDF's
@@ -692,6 +699,928 @@ libraries for Machine Learning, Neural Nets and statistical estimation.")
(home-page "http://lush.sourceforge.net/")
(license license:lgpl2.1+)))
+(define-public sbcl-alexandria
+ (let ((revision "1")
+ (commit "3b849bc0116ea70f215ee6b2fbf354e862aaa9dd"))
+ (package
+ (name "sbcl-alexandria")
+ (version (git-version "1.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://gitlab.common-lisp.net/alexandria/alexandria.git")
+ (commit commit)))
+ (sha256
+ (base32
+ "04amwvx2vl691f0plcfbqqwxgib9zimih7jrn5zl7mbwvrxy022b"))
+ (file-name (git-file-name name version))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("rt" ,sbcl-rt)))
+ (synopsis "Collection of portable utilities for Common Lisp")
+ (description
+ "Alexandria is a collection of portable utilities. It does not contain
+conceptual extensions to Common Lisp. It is conservative in scope, and
+portable between implementations.")
+ (home-page "https://common-lisp.net/project/alexandria/")
+ (license license:public-domain))))
+
+(define-public cl-alexandria
+ (sbcl-package->cl-source-package sbcl-alexandria))
+
+(define-public ecl-alexandria
+ (sbcl-package->ecl-package sbcl-alexandria))
+
+(define-public sbcl-net.didierverna.asdf-flv
+ (package
+ (name "sbcl-net.didierverna.asdf-flv")
+ (version "2.1")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/didierverna/asdf-flv")
+ (commit (string-append "version-" version))))
+ (file-name (git-file-name "asdf-flv" version))
+ (sha256
+ (base32 "1fi2y4baxan103jbg4idjddzihy03kwnj2mzbwrknw4d4x7xlgwj"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Common Lisp ASDF extension to provide support for file-local variables")
+ (description "ASDF-FLV provides support for file-local variables through
+ASDF. A file-local variable behaves like @code{*PACKAGE*} and
+@code{*READTABLE*} with respect to @code{LOAD} and @code{COMPILE-FILE}: a new
+dynamic binding is created before processing the file, so that any
+modification to the variable becomes essentially file-local.
+
+In order to make one or several variables file-local, use the macros
+@code{SET-FILE-LOCAL-VARIABLE(S)}.")
+ (home-page "https://www.lrde.epita.fr/~didier/software/lisp/misc.php#asdf-flv")
+ (license (license:non-copyleft
+ "https://www.gnu.org/prep/maintain/html_node/License-Notices-for-Other-Files.html"
+ "GNU All-Permissive License"))))
+
+(define-public cl-net.didierverna.asdf-flv
+ (sbcl-package->cl-source-package sbcl-net.didierverna.asdf-flv))
+
+(define-public ecl-net.didierverna.asdf-flv
+ (sbcl-package->ecl-package sbcl-net.didierverna.asdf-flv))
+
+(define-public sbcl-fiveam
+ (package
+ (name "sbcl-fiveam")
+ (version "1.4.1")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sionescu/fiveam.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "fiveam" version))
+ (sha256
+ (base32 "1q3d38pwafnwnw42clq0f8g5xw7pbzr287jl9jsqmb1vb0n1vrli"))))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("net.didierverna.asdf-flv" ,sbcl-net.didierverna.asdf-flv)
+ ("trivial-backtrace" ,sbcl-trivial-backtrace)))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Common Lisp testing framework")
+ (description "FiveAM is a simple (as far as writing and running tests
+goes) regression testing framework. It has been designed with Common Lisp's
+interactive development model in mind.")
+ (home-page "https://common-lisp.net/project/fiveam/")
+ (license license:bsd-3)))
+
+(define-public cl-fiveam
+ (sbcl-package->cl-source-package sbcl-fiveam))
+
+(define-public ecl-fiveam
+ (sbcl-package->ecl-package sbcl-fiveam))
+
+(define-public sbcl-bordeaux-threads
+ (let ((commit "5dce49fbc829f4d136a734f5ef4f5d599660984f")
+ (revision "1"))
+ (package
+ (name "sbcl-bordeaux-threads")
+ (version (git-version "0.8.6" revision commit))
+ (source (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sionescu/bordeaux-threads.git")
+ (commit commit)))
+ (sha256
+ (base32 "1gkh9rz7zw57n3110ikcf4835950wr4hgp8l79id5ai6nd86x7wv"))
+ (file-name
+ (git-file-name "bordeaux-threads" version))))
+ (inputs `(("alexandria" ,sbcl-alexandria)))
+ (native-inputs `(("fiveam" ,sbcl-fiveam)))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Portable shared-state concurrency library for Common Lisp")
+ (description "BORDEAUX-THREADS is a proposed standard for a minimal
+MP/Threading interface. It is similar to the CLIM-SYS threading and lock
+support.")
+ (home-page "https://common-lisp.net/project/bordeaux-threads/")
+ (license license:x11))))
+
+(define-public cl-bordeaux-threads
+ (sbcl-package->cl-source-package sbcl-bordeaux-threads))
+
+(define-public ecl-bordeaux-threads
+ (sbcl-package->ecl-package sbcl-bordeaux-threads))
+
+(define-public sbcl-trivial-gray-streams
+ (let ((revision "1")
+ (commit "0483ade330508b4b2edeabdb47d16ec9437ee1cb"))
+ (package
+ (name "sbcl-trivial-gray-streams")
+ (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri
+ (git-reference
+ (url "https://github.com/trivial-gray-streams/trivial-gray-streams.git")
+ (commit commit)))
+ (sha256
+ (base32 "0m3rpf2x0zmdk3nf1qfa01j6a55vj7gkwhyw78qslcgbjlgh8p4d"))
+ (file-name
+ (string-append "trivial-gray-streams-" version "-checkout"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Compatibility layer for Gray streams implementations")
+ (description "Gray streams is an interface proposed for inclusion with
+ANSI CL by David N. Gray. The proposal did not make it into ANSI CL, but most
+popular CL implementations implement it. This package provides an extremely
+thin compatibility layer for gray streams.")
+ (home-page "http://www.cliki.net/trivial-gray-streams")
+ (license license:x11))))
+
+(define-public cl-trivial-gray-streams
+ (sbcl-package->cl-source-package sbcl-trivial-gray-streams))
+
+(define-public ecl-trivial-gray-streams
+ (sbcl-package->ecl-package sbcl-trivial-gray-streams))
+
+(define-public sbcl-fiasco
+ (let ((commit "d62f7558b21addc89f87e306f65d7f760632655f")
+ (revision "1"))
+ (package
+ (name "sbcl-fiasco")
+ (version (git-version "0.0.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/joaotavora/fiasco.git")
+ (commit commit)))
+ (file-name (git-file-name "fiasco" version))
+ (sha256
+ (base32
+ "1zwxs3d6iswayavcmb49z2892xhym7n556d8dnmvalc32pm9bkjh"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
+ (synopsis "Simple and powerful test framework for Common Lisp")
+ (description "A Common Lisp test framework that treasures your failures,
+logical continuation of Stefil. It focuses on interactive debugging.")
+ (home-page "https://github.com/joaotavora/fiasco")
+ ;; LICENCE specifies this is public-domain unless the legislation
+ ;; doesn't allow or recognize it. In that case it falls back to a
+ ;; permissive licence.
+ (license (list license:public-domain
+ (license:x11-style "file://LICENCE"))))))
+
+(define-public cl-fiasco
+ (sbcl-package->cl-source-package sbcl-fiasco))
+
+(define-public ecl-fiasco
+ (sbcl-package->ecl-package sbcl-fiasco))
+
+(define-public sbcl-flexi-streams
+ (package
+ (name "sbcl-flexi-streams")
+ (version "1.0.16")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/edicl/flexi-streams.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "flexi-streams" version))
+ (sha256
+ (base32 "0gvykjlmja060zqq6nn6aqxlshh6r6ijahmmgf20q0d839rwpgxc"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'make-git-checkout-writable
+ (lambda _
+ (for-each make-file-writable (find-files "."))
+ #t)))))
+ (inputs `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
+ (synopsis "Implementation of virtual bivalent streams for Common Lisp")
+ (description "Flexi-streams is an implementation of \"virtual\" bivalent
+streams that can be layered atop real binary or bivalent streams and that can
+be used to read and write character data in various single- or multi-octet
+encodings which can be changed on the fly. It also supplies in-memory binary
+streams which are similar to string streams.")
+ (home-page "http://weitz.de/flexi-streams/")
+ (license license:bsd-3)))
+
+(define-public cl-flexi-streams
+ (sbcl-package->cl-source-package sbcl-flexi-streams))
+
+(define-public ecl-flexi-streams
+ (sbcl-package->ecl-package sbcl-flexi-streams))
+
+(define-public sbcl-cl-ppcre
+ (package
+ (name "sbcl-cl-ppcre")
+ (version "2.0.11")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/edicl/cl-ppcre.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-ppcre" version))
+ (sha256
+ (base32 "0q3iany07vgqm144lw6pj0af2d3vsikpbkwcxr30fci3kzsq4f49"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs `(("flexi-streams" ,sbcl-flexi-streams)))
+ (synopsis "Portable regular expression library for Common Lisp")
+ (description "CL-PPCRE is a portable regular expression library for Common
+Lisp, which is compatible with perl. It is pretty fast, thread-safe, and
+compatible with ANSI-compliant Common Lisp implementations.")
+ (home-page "http://weitz.de/cl-ppcre/")
+ (license license:bsd-2)))
+
+(define-public cl-ppcre
+ (sbcl-package->cl-source-package sbcl-cl-ppcre))
+
+(define-public ecl-cl-ppcre
+ (sbcl-package->ecl-package sbcl-cl-ppcre))
+
+(define sbcl-cl-unicode-base
+ (let ((revision "1")
+ (commit "9fcd06fba1ddc9e66aed2f2d6c32dc9b764f03ea"))
+ (package
+ (name "sbcl-cl-unicode-base")
+ (version (string-append "0.1.5-" revision "." (string-take commit 7)))
+ (source (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/edicl/cl-unicode.git")
+ (commit commit)))
+ (file-name (string-append "cl-unicode-" version "-checkout"))
+ (sha256
+ (base32
+ "1jicprb5b3bv57dy1kg03572gxkcaqdjhak00426s76g0plmx5ki"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-file "cl-unicode.asd"
+ #:asd-system-name "cl-unicode/base"))
+ (inputs
+ `(("cl-ppcre" ,sbcl-cl-ppcre)))
+ (home-page "http://weitz.de/cl-unicode/")
+ (synopsis "Portable Unicode library for Common Lisp")
+ (description "CL-UNICODE is a portable Unicode library Common Lisp, which
+is compatible with perl. It is pretty fast, thread-safe, and compatible with
+ANSI-compliant Common Lisp implementations.")
+ (license license:bsd-2))))
+
+(define-public sbcl-cl-unicode
+ (package
+ (inherit sbcl-cl-unicode-base)
+ (name "sbcl-cl-unicode")
+ (inputs
+ `(("cl-unicode/base" ,sbcl-cl-unicode-base)
+ ,@(package-inputs sbcl-cl-unicode-base)))
+ (native-inputs
+ `(("flexi-streams" ,sbcl-flexi-streams)))
+ (arguments '())))
+
+(define-public ecl-cl-unicode
+ (sbcl-package->ecl-package sbcl-cl-unicode))
+
+(define-public cl-unicode
+ (sbcl-package->cl-source-package sbcl-cl-unicode))
+
+(define-public sbcl-clx
+ (package
+ (name "sbcl-clx")
+ (version "0.7.5")
+ (source
+ (origin
+ (method git-fetch)
+ (uri
+ (git-reference
+ (url "https://github.com/sharplispers/clx.git")
+ (commit version)))
+ (sha256
+ (base32
+ "1vi67z9hpj5rr4xcmfbfwzmlcc0ah7hzhrmfid6lqdkva238v2wf"))
+ (file-name (string-append "clx-" version))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("fiasco" ,sbcl-fiasco)))
+ (home-page "http://www.cliki.net/portable-clx")
+ (synopsis "X11 client library for Common Lisp")
+ (description "CLX is an X11 client library for Common Lisp. The code was
+originally taken from a CMUCL distribution, was modified somewhat in order to
+make it compile and run under SBCL, then a selection of patches were added
+from other CLXes around the net.")
+ (license license:x11)))
+
+(define-public cl-clx
+ (sbcl-package->cl-source-package sbcl-clx))
+
+(define-public ecl-clx
+ (sbcl-package->ecl-package sbcl-clx))
+
+(define-public sbcl-cl-ppcre-unicode
+ (package (inherit sbcl-cl-ppcre)
+ (name "sbcl-cl-ppcre-unicode")
+ (arguments
+ `(#:tests? #f ; tests fail with "Component :CL-PPCRE-TEST not found"
+ #:asd-file "cl-ppcre-unicode.asd"))
+ (inputs
+ `(("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
+ ("sbcl-cl-unicode" ,sbcl-cl-unicode)))))
+
+(define-public stumpwm
+ (package
+ (name "stumpwm")
+ (version "18.11")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/stumpwm/stumpwm.git")
+ (commit version)))
+ (file-name (git-file-name "stumpwm" version))
+ (sha256
+ (base32 "003g1fmh7446ws49866kzny4lrk1wf034dq5fa4m9mq1nzc7cwv7"))
+ (patches
+ ;; This patch is included in the post-18.11 git master tree
+ ;; and can be removed when we move to the next release.
+ (search-patches "stumpwm-fix-broken-read-one-line.patch"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs `(("fiasco" ,sbcl-fiasco)
+ ("texinfo" ,texinfo)))
+ (inputs `(("cl-ppcre" ,sbcl-cl-ppcre)
+ ("clx" ,sbcl-clx)
+ ("alexandria" ,sbcl-alexandria)))
+ (outputs '("out" "lib"))
+ (arguments
+ '(#:asd-system-name "stumpwm"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'create-symlinks 'build-program
+ (lambda* (#:key outputs #:allow-other-keys)
+ (build-program
+ (string-append (assoc-ref outputs "out") "/bin/stumpwm")
+ outputs
+ #:entry-program '((stumpwm:stumpwm) 0))))
+ (add-after 'build-program 'create-desktop-file
+ (lambda* (#:key outputs #:allow-other-keys)
+ (let* ((out (assoc-ref outputs "out"))
+ (xsessions (string-append out "/share/xsessions")))
+ (mkdir-p xsessions)
+ (call-with-output-file
+ (string-append xsessions "/stumpwm.desktop")
+ (lambda (file)
+ (format file
+ "[Desktop Entry]~@
+ Name=stumpwm~@
+ Comment=The Stump Window Manager~@
+ Exec=~a/bin/stumpwm~@
+ TryExec=~@*~a/bin/stumpwm~@
+ Icon=~@
+ Type=Application~%"
+ out)))
+ #t)))
+ (add-after 'install 'install-manual
+ (lambda* (#:key outputs #:allow-other-keys)
+ ;; The proper way to the manual is bootstrapping a full autotools
+ ;; build system and running ‘./configure && make stumpwm.info’ to
+ ;; do some macro substitution. We can get away with much less.
+ (let* ((out (assoc-ref outputs "out"))
+ (info (string-append out "/share/info")))
+ (invoke "makeinfo" "stumpwm.texi.in")
+ (install-file "stumpwm.info" info)
+ #t))))))
+ (synopsis "Window manager written in Common Lisp")
+ (description "Stumpwm is a window manager written entirely in Common Lisp.
+It attempts to be highly customizable while relying entirely on the keyboard
+for input. These design decisions reflect the growing popularity of
+productive, customizable lisp based systems.")
+ (home-page "https://github.com/stumpwm/stumpwm")
+ (license license:gpl2+)
+ (properties `((cl-source-variant . ,(delay cl-stumpwm))))))
+
+(define-public sbcl-stumpwm
+ (deprecated-package "sbcl-stumpwm" stumpwm))
+
+(define-public cl-stumpwm
+ (package
+ (inherit (sbcl-package->cl-source-package stumpwm))
+ (name "cl-stumpwm")))
+
+;; The slynk that users expect to install includes all of slynk's contrib
+;; modules. Therefore, we build the base module and all contribs first; then
+;; we expose the union of these as `sbcl-slynk'. The following variable
+;; describes the base module.
+(define sbcl-slynk-boot0
+ (let ((revision "2")
+ (commit "cbf84c36c4eca8b032e3fd16177a7bc02df3ec4c"))
+ (package
+ (name "sbcl-slynk-boot0")
+ (version (string-append "1.0.0-beta-" revision "." (string-take commit 7)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri
+ (git-reference
+ (url "https://github.com/joaotavora/sly.git")
+ (commit commit)))
+ (sha256
+ (base32 "13dyhsravn591p7g6is01mp2ynzjnnj7pwgi57r6xqmd4611y9vh"))
+ (file-name (string-append "slynk-" version "-checkout"))
+ (modules '((guix build utils)
+ (ice-9 ftw)))
+ (snippet
+ '(begin
+ ;; Move the contribs into the main source directory for easier
+ ;; access
+ (substitute* "slynk/slynk.asd"
+ (("\\.\\./contrib")
+ "contrib")
+ (("\\(defsystem :slynk/util")
+ "(defsystem :slynk/util :depends-on (:slynk)")
+ ((":depends-on \\(:slynk :slynk/util\\)")
+ ":depends-on (:slynk :slynk-util)"))
+ (substitute* "contrib/slynk-trace-dialog.lisp"
+ (("\\(slynk::reset-inspector\\)") ; Causes problems on load
+ "nil"))
+ (substitute* "contrib/slynk-profiler.lisp"
+ (("slynk:to-line")
+ "slynk-pprint-to-line"))
+ (substitute* "contrib/slynk-fancy-inspector.lisp"
+ (("slynk/util") "slynk-util")
+ ((":compile-toplevel :load-toplevel") ""))
+ (rename-file "contrib" "slynk/contrib")
+ ;; Move slynk's contents into the base directory for easier
+ ;; access
+ (for-each (lambda (file)
+ (unless (string-prefix? "." file)
+ (rename-file (string-append "slynk/" file)
+ (string-append "./" (basename file)))))
+ (scandir "slynk"))
+ #t))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:tests? #f ; No test suite
+ #:asd-system-name "slynk"))
+ (synopsis "Common Lisp IDE for Emacs")
+ (description "SLY is a fork of SLIME, an IDE backend for Common Lisp.
+It also features a completely redesigned REPL based on Emacs's own
+full-featured comint.el, live code annotations, and a consistent interactive
+button interface. Everything can be copied to the REPL. One can create
+multiple inspectors with independent history.")
+ (home-page "https://github.com/joaotavora/sly")
+ (license license:public-domain)
+ (properties `((cl-source-variant . ,(delay cl-slynk)))))))
+
+(define-public cl-slynk
+ (package
+ (inherit (sbcl-package->cl-source-package sbcl-slynk-boot0))
+ (name "cl-slynk")))
+
+(define ecl-slynk-boot0
+ (sbcl-package->ecl-package sbcl-slynk-boot0))
+
+(define sbcl-slynk-arglists
+ (package
+ (inherit sbcl-slynk-boot0)
+ (name "sbcl-slynk-arglists")
+ (inputs `(("slynk" ,sbcl-slynk-boot0)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-slynk-boot0)
+ ((#:asd-file _ "") "slynk.asd")
+ ((#:asd-system-name _ #f) "slynk/arglists")))))
+
+(define ecl-slynk-arglists
+ (sbcl-package->ecl-package sbcl-slynk-arglists))
+
+(define sbcl-slynk-util
+ (package
+ (inherit sbcl-slynk-boot0)
+ (name "sbcl-slynk-util")
+ (inputs `(("slynk" ,sbcl-slynk-boot0)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-slynk-boot0)
+ ((#:asd-file _ "") "slynk.asd")
+ ((#:asd-system-name _ #f) "slynk/util")))))
+
+(define ecl-slynk-util
+ (sbcl-package->ecl-package sbcl-slynk-util))
+
+(define sbcl-slynk-fancy-inspector
+ (package
+ (inherit sbcl-slynk-arglists)
+ (name "sbcl-slynk-fancy-inspector")
+ (inputs `(("slynk-util" ,sbcl-slynk-util)
+ ,@(package-inputs sbcl-slynk-arglists)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
+ ((#:asd-system-name _ #f) "slynk/fancy-inspector")))))
+
+(define ecl-slynk-fancy-inspector
+ (sbcl-package->ecl-package sbcl-slynk-fancy-inspector))
+
+(define sbcl-slynk-package-fu
+ (package
+ (inherit sbcl-slynk-arglists)
+ (name "sbcl-slynk-package-fu")
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
+ ((#:asd-system-name _ #f) "slynk/package-fu")))))
+
+(define ecl-slynk-package-fu
+ (sbcl-package->ecl-package sbcl-slynk-package-fu))
+
+(define sbcl-slynk-mrepl
+ (package
+ (inherit sbcl-slynk-fancy-inspector)
+ (name "sbcl-slynk-mrepl")
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
+ ((#:asd-system-name _ #f) "slynk/mrepl")))))
+
+(define ecl-slynk-mrepl
+ (sbcl-package->ecl-package sbcl-slynk-mrepl))
+
+(define sbcl-slynk-trace-dialog
+ (package
+ (inherit sbcl-slynk-arglists)
+ (name "sbcl-slynk-trace-dialog")
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
+ ((#:asd-system-name _ #f) "slynk/trace-dialog")))))
+
+(define ecl-slynk-trace-dialog
+ (sbcl-package->ecl-package sbcl-slynk-trace-dialog))
+
+(define sbcl-slynk-profiler
+ (package
+ (inherit sbcl-slynk-arglists)
+ (name "sbcl-slynk-profiler")
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
+ ((#:asd-system-name _ #f) "slynk/profiler")))))
+
+(define ecl-slynk-profiler
+ (sbcl-package->ecl-package sbcl-slynk-profiler))
+
+(define sbcl-slynk-stickers
+ (package
+ (inherit sbcl-slynk-arglists)
+ (name "sbcl-slynk-stickers")
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
+ ((#:asd-system-name _ #f) "slynk/stickers")))))
+
+(define ecl-slynk-stickers
+ (sbcl-package->ecl-package sbcl-slynk-stickers))
+
+(define sbcl-slynk-indentation
+ (package
+ (inherit sbcl-slynk-arglists)
+ (name "sbcl-slynk-indentation")
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
+ ((#:asd-system-name _ #f) "slynk/indentation")))))
+
+(define ecl-slynk-indentation
+ (sbcl-package->ecl-package sbcl-slynk-indentation))
+
+(define sbcl-slynk-retro
+ (package
+ (inherit sbcl-slynk-arglists)
+ (name "sbcl-slynk-retro")
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
+ ((#:asd-system-name _ #f) "slynk/retro")))))
+
+(define ecl-slynk-retro
+ (sbcl-package->ecl-package sbcl-slynk-retro))
+
+(define slynk-systems
+ '("slynk"
+ "slynk-util"
+ "slynk-arglists"
+ "slynk-fancy-inspector"
+ "slynk-package-fu"
+ "slynk-mrepl"
+ "slynk-profiler"
+ "slynk-trace-dialog"
+ "slynk-stickers"
+ "slynk-indentation"
+ "slynk-retro"))
+
+(define-public sbcl-slynk
+ (package
+ (inherit sbcl-slynk-boot0)
+ (name "sbcl-slynk")
+ (inputs
+ `(("slynk" ,sbcl-slynk-boot0)
+ ("slynk-util" ,sbcl-slynk-util)
+ ("slynk-arglists" ,sbcl-slynk-arglists)
+ ("slynk-fancy-inspector" ,sbcl-slynk-fancy-inspector)
+ ("slynk-package-fu" ,sbcl-slynk-package-fu)
+ ("slynk-mrepl" ,sbcl-slynk-mrepl)
+ ("slynk-profiler" ,sbcl-slynk-profiler)
+ ("slynk-trace-dialog" ,sbcl-slynk-trace-dialog)
+ ("slynk-stickers" ,sbcl-slynk-stickers)
+ ("slynk-indentation" ,sbcl-slynk-indentation)
+ ("slynk-retro" ,sbcl-slynk-retro)))
+ (native-inputs `(("sbcl" ,sbcl)))
+ (build-system trivial-build-system)
+ (source #f)
+ (outputs '("out" "image"))
+ (arguments
+ `(#:modules ((guix build union)
+ (guix build utils)
+ (guix build lisp-utils))
+ #:builder
+ (begin
+ (use-modules (ice-9 match)
+ (srfi srfi-1)
+ (guix build union)
+ (guix build lisp-utils))
+
+ (union-build
+ (assoc-ref %outputs "out")
+ (filter-map
+ (match-lambda
+ ((name . path)
+ (if (string-prefix? "slynk" name) path #f)))
+ %build-inputs))
+
+ (prepend-to-source-registry
+ (string-append (assoc-ref %outputs "out") "//"))
+
+ (parameterize ((%lisp-type "sbcl")
+ (%lisp (string-append (assoc-ref %build-inputs "sbcl")
+ "/bin/sbcl")))
+ (build-image (string-append
+ (assoc-ref %outputs "image")
+ "/bin/slynk")
+ %outputs
+ #:dependencies ',slynk-systems))
+ #t)))))
+
+(define-public ecl-slynk
+ (package
+ (inherit sbcl-slynk)
+ (name "ecl-slynk")
+ (inputs
+ (map (match-lambda
+ ((name pkg . _)
+ (list name (sbcl-package->ecl-package pkg))))
+ (package-inputs sbcl-slynk)))
+ (native-inputs '())
+ (outputs '("out"))
+ (arguments
+ '(#:modules ((guix build union))
+ #:builder
+ (begin
+ (use-modules (ice-9 match)
+ (guix build union))
+ (match %build-inputs
+ (((names . paths) ...)
+ (union-build (assoc-ref %outputs "out")
+ paths)
+ #t)))))))
+
+(define-public stumpwm+slynk
+ (package
+ (inherit stumpwm)
+ (name "stumpwm-with-slynk")
+ (outputs '("out"))
+ (inputs
+ `(("stumpwm" ,stumpwm "lib")
+ ("slynk" ,sbcl-slynk)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments stumpwm)
+ ((#:phases phases)
+ `(modify-phases ,phases
+ (replace 'build-program
+ (lambda* (#:key inputs outputs #:allow-other-keys)
+ (let* ((out (assoc-ref outputs "out"))
+ (program (string-append out "/bin/stumpwm")))
+ (build-program program outputs
+ #:entry-program '((stumpwm:stumpwm) 0)
+ #:dependencies '("stumpwm"
+ ,@slynk-systems)
+ #:dependency-prefixes
+ (map (lambda (input) (assoc-ref inputs input))
+ '("stumpwm" "slynk")))
+ ;; Remove unneeded file.
+ (delete-file (string-append out "/bin/stumpwm-exec.fasl"))
+ #t)))
+ (delete 'copy-source)
+ (delete 'build)
+ (delete 'check)
+ (delete 'create-asd-file)
+ (delete 'cleanup)
+ (delete 'create-symlinks)))))))
+
+(define-public sbcl-stumpwm+slynk
+ (deprecated-package "sbcl-stumpwm-with-slynk" stumpwm+slynk))
+
+(define-public sbcl-parse-js
+ (let ((commit "fbadc6029bec7039602abfc06c73bb52970998f6")
+ (revision "1"))
+ (package
+ (name "sbcl-parse-js")
+ (version (string-append "0.0.0-" revision "." (string-take commit 9)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "http://marijn.haverbeke.nl/git/parse-js")
+ (commit commit)))
+ (file-name (string-append name "-" commit "-checkout"))
+ (sha256
+ (base32
+ "1wddrnr5kiya5s3gp4cdq6crbfy9fqcz7fr44p81502sj3bvdv39"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "http://marijnhaverbeke.nl/parse-js/")
+ (synopsis "Parse JavaScript")
+ (description "Parse-js is a Common Lisp package for parsing
+JavaScript (ECMAScript 3). It has basic support for ECMAScript 5.")
+ (license license:zlib))))
+
+(define-public cl-parse-js
+ (sbcl-package->cl-source-package sbcl-parse-js))
+
+(define-public sbcl-parse-number
+ (package
+ (name "sbcl-parse-number")
+ (version "1.7")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sharplispers/parse-number/")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0sk06ib1bhqv9y39vwnnw44vmbc4b0kvqm37xxmkxd4dwchq82d7"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "http://www.cliki.net/PARSE-NUMBER")
+ (synopsis "Parse numbers")
+ (description "@code{parse-number} is a library of functions for parsing
+strings into one of the standard Common Lisp number types without using the
+reader. @code{parse-number} accepts an arbitrary string and attempts to parse
+the string into one of the standard Common Lisp number types, if possible, or
+else @code{parse-number} signals an error of type @code{invalid-number}.")
+ (license license:bsd-3)))
+
+(define-public cl-parse-number
+ (sbcl-package->cl-source-package sbcl-parse-number))
+
+(define-public sbcl-iterate
+ (package
+ (name "sbcl-iterate")
+ ;; The latest official release (1.4.3) fails to build so we have to take
+ ;; the current darcs tarball from quicklisp.
+ (version "20160825")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "http://beta.quicklisp.org/archive/iterate/"
+ "2016-08-25/iterate-"
+ version "-darcs.tgz"))
+ (sha256
+ (base32
+ "0kvz16gnxnkdz0fy1x8y5yr28nfm7i2qpvix7mgwccdpjmsb4pgm"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("rt" ,sbcl-rt)))
+ (home-page "https://common-lisp.net/project/iterate/")
+ (synopsis "Iteration construct for Common Lisp")
+ (description "@code{iterate} is an iteration construct for Common Lisp.
+It is similar to the @code{CL:LOOP} macro, with these distinguishing marks:
+
+@itemize
+@item it is extensible,
+@item it helps editors like Emacs indent iterate forms by having a more
+ lisp-like syntax, and
+@item it isn't part of the ANSI standard for Common Lisp.
+@end itemize\n")
+ (license license:expat)))
+
+(define-public cl-iterate
+ (sbcl-package->cl-source-package sbcl-iterate))
+
+(define-public ecl-iterate
+ (sbcl-package->ecl-package sbcl-iterate))
+
+(define-public sbcl-cl-uglify-js
+ ;; There have been many bug fixes since the 2010 release.
+ (let ((commit "429c5e1d844e2f96b44db8fccc92d6e8e28afdd5")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-uglify-js")
+ (version (string-append "0.1-" revision "." (string-take commit 9)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/mishoo/cl-uglify-js.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0k39y3c93jgxpr7gwz7w0d8yknn1fdnxrjhd03057lvk5w8js27a"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("sbcl-parse-js" ,sbcl-parse-js)
+ ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
+ ("sbcl-cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)
+ ("sbcl-parse-number" ,sbcl-parse-number)
+ ("sbcl-iterate" ,sbcl-iterate)))
+ (home-page "https://github.com/mishoo/cl-uglify-js")
+ (synopsis "JavaScript compressor library for Common Lisp")
+ (description "This is a Common Lisp version of UglifyJS, a JavaScript
+compressor. It works on data produced by @code{parse-js} to generate a
+@dfn{minified} version of the code. Currently it can:
+
+@itemize
+@item reduce variable names (usually to single letters)
+@item join consecutive @code{var} statements
+@item resolve simple binary expressions
+@item group most consecutive statements using the @code{sequence} operator (comma)
+@item remove unnecessary blocks
+@item convert @code{IF} expressions in various ways that result in smaller code
+@item remove some unreachable code
+@end itemize\n")
+ (license license:zlib))))
+
+(define-public cl-uglify-js
+ (sbcl-package->cl-source-package sbcl-cl-uglify-js))
+
+(define-public uglify-js
+ (package
+ (inherit sbcl-cl-uglify-js)
+ (name "uglify-js")
+ (build-system trivial-build-system)
+ (arguments
+ `(#:modules ((guix build utils))
+ #:builder
+ (let* ((bin (string-append (assoc-ref %outputs "out") "/bin/"))
+ (script (string-append bin "uglify-js")))
+ (use-modules (guix build utils))
+ (mkdir-p bin)
+ (with-output-to-file script
+ (lambda _
+ (format #t "#!~a/bin/sbcl --script
+ (require :asdf)
+ (push (truename \"~a/lib/sbcl\") asdf:*central-registry*)"
+ (assoc-ref %build-inputs "sbcl")
+ (assoc-ref %build-inputs "sbcl-cl-uglify-js"))
+ ;; FIXME: cannot use progn here because otherwise it fails to
+ ;; find cl-uglify-js.
+ (for-each
+ write
+ '(;; Quiet, please!
+ (let ((*standard-output* (make-broadcast-stream))
+ (*error-output* (make-broadcast-stream)))
+ (asdf:load-system :cl-uglify-js))
+ (let ((file (cadr *posix-argv*)))
+ (if file
+ (format t "~a"
+ (cl-uglify-js:ast-gen-code
+ (cl-uglify-js:ast-mangle
+ (cl-uglify-js:ast-squeeze
+ (with-open-file (in file)
+ (parse-js:parse-js in))))
+ :beautify nil))
+ (progn
+ (format *error-output*
+ "Please provide a JavaScript file.~%")
+ (sb-ext:exit :code 1))))))))
+ (chmod script #o755)
+ #t)))
+ (inputs
+ `(("sbcl" ,sbcl)
+ ("sbcl-cl-uglify-js" ,sbcl-cl-uglify-js)))
+ (synopsis "JavaScript compressor")))
+
(define-public confusion-mdl
(let* ((commit "12a055581fc262225272df43287dae48281900f5"))
(package
@@ -736,6 +1665,3765 @@ enough to play the original mainframe Zork all the way through.")
(home-page "http://www.russotto.net/git/mrussotto/confusion/src/master/src/README")
(license license:gpl3+))))
+(define-public sbcl-cl-strings
+ (let ((revision "1")
+ (commit "c5c5cbafbf3e6181d03c354d66e41a4f063f00ae"))
+ (package
+ (name "sbcl-cl-strings")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/diogoalexandrefranco/cl-strings")
+ (commit commit)))
+ (sha256
+ (base32
+ "00754mfaqallj480lwd346nkfb6ra8pa8xcxcylf4baqn604zlmv"))
+ (file-name (string-append "cl-strings-" version "-checkout"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Portable, dependency-free set of utilities to manipulate strings in Common Lisp")
+ (description
+ "@command{cl-strings} is a small, portable, dependency-free set of
+utilities that make it even easier to manipulate text in Common Lisp. It has
+100% test coverage and works at least on sbcl, ecl, ccl, abcl and clisp.")
+ (home-page "https://github.com/diogoalexandrefranco/cl-strings")
+ (license license:expat))))
+
+(define-public cl-strings
+ (sbcl-package->cl-source-package sbcl-cl-strings))
+
+(define-public ecl-cl-strings
+ (sbcl-package->ecl-package sbcl-cl-strings))
+
+(define-public sbcl-trivial-features
+ (package
+ (name "sbcl-trivial-features")
+ (version "0.8")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/trivial-features/trivial-features.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "trivial-features" version))
+ (sha256
+ (base32 "0ccv7dqyrk55xga78i5vzlic7mdwp28in3g1a8fqhlk6626scsq9"))))
+ (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:expat)))
+
+(define-public cl-trivial-features
+ (sbcl-package->cl-source-package sbcl-trivial-features))
+
+(define-public ecl-trivial-features
+ (sbcl-package->ecl-package sbcl-trivial-features))
+
+(define-public sbcl-hu.dwim.asdf
+ (package
+ (name "sbcl-hu.dwim.asdf")
+ (version "20190521")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "http://beta.quicklisp.org/archive/hu.dwim.asdf/"
+ "2019-05-21/hu.dwim.asdf-" version "-darcs.tgz"))
+ (sha256
+ (base32
+ "0rsbv71vyszy8w35yjwb5h6zcmknjq223hkzir79y72qdsc6sabn"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://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 cl-hu.dwim.asdf
+ (sbcl-package->cl-source-package sbcl-hu.dwim.asdf))
+
+(define-public ecl-hu.dwim.asdf
+ (sbcl-package->ecl-package sbcl-hu.dwim.asdf))
+
+(define-public sbcl-hu.dwim.stefil
+ (let ((commit "ab6d1aa8995878a1b66d745dfd0ba021090bbcf9"))
+ (package
+ (name "sbcl-hu.dwim.stefil")
+ (version (git-version "0.0.0" "1" commit))
+ (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 (git-file-name "hu.dwim.stefil" version))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("asdf:cl-hu.dwim.asdf" ,sbcl-hu.dwim.asdf)))
+ (inputs
+ `(("sbcl-alexandria" ,sbcl-alexandria)))
+ (home-page "https://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 cl-hu.dwim.stefil
+ (sbcl-package->cl-source-package sbcl-hu.dwim.stefil))
+
+(define-public ecl-hu.dwim.stefil
+ (sbcl-package->ecl-package sbcl-hu.dwim.stefil))
+
+(define-public sbcl-babel
+ (package
+ (name "sbcl-babel")
+ (version "0.5.0")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/cl-babel/babel.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "babel" version))
+ (sha256
+ (base32 "139a8rn2gnhj082n8jg01gc8fyr63hkj57hgrnmb3d1r327yc77f"))))
+ (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)))
+ (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:expat)))
+
+(define-public cl-babel
+ (sbcl-package->cl-source-package sbcl-babel))
+
+(define-public ecl-babel
+ (sbcl-package->ecl-package sbcl-babel))
+
+(define-public sbcl-cl-yacc
+ (package
+ (name "sbcl-cl-yacc")
+ (version "0.3")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/jech/cl-yacc")
+ (commit (string-append "cl-yacc-" version))))
+ (sha256
+ (base32
+ "16946pzf8vvadnyfayvj8rbh4zjzw90h0azz2qk1mxrvhh5wklib"))
+ (file-name (string-append "cl-yacc-" version "-checkout"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:asd-file "yacc.asd"
+ #:asd-system-name "yacc"))
+ (synopsis "LALR(1) parser generator for Common Lisp, similar in spirit to Yacc")
+ (description
+ "CL-Yacc is a LALR(1) parser generator for Common Lisp, similar in spirit
+to AT&T Yacc, Berkeley Yacc, GNU Bison, Zebu, lalr.cl or lalr.scm.
+
+CL-Yacc uses the algorithm due to Aho and Ullman, which is the one also used
+by AT&T Yacc, Berkeley Yacc and Zebu. It does not use the faster algorithm due
+to DeRemer and Pennello, which is used by Bison and lalr.scm (not lalr.cl).")
+ (home-page "https://www.irif.fr/~jch//software/cl-yacc/")
+ (license license:expat)))
+
+(define-public cl-yacc
+ (sbcl-package->cl-source-package sbcl-cl-yacc))
+
+(define-public ecl-cl-yacc
+ (sbcl-package->ecl-package sbcl-cl-yacc))
+
+(define-public sbcl-jpl-util
+ (let ((commit "0311ed374e19a49d43318064d729fe3abd9a3b62"))
+ (package
+ (name "sbcl-jpl-util")
+ (version "20151005")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ ;; Quicklisp uses this fork.
+ (url "https://github.com/hawkir/cl-jpl-util")
+ (commit commit)))
+ (file-name
+ (git-file-name "jpl-util" version))
+ (sha256
+ (base32
+ "0nc0rk9n8grkg3045xsw34whmcmddn2sfrxki4268g7kpgz0d2yz"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Collection of Common Lisp utility functions and macros")
+ (description
+ "@command{cl-jpl-util} is a collection of Common Lisp utility functions
+and macros, primarily for software projects written in CL by the author.")
+ (home-page "https://www.thoughtcrime.us/software/cl-jpl-util/")
+ (license license:isc))))
+
+(define-public cl-jpl-util
+ (sbcl-package->cl-source-package sbcl-jpl-util))
+
+(define-public ecl-jpl-util
+ (sbcl-package->ecl-package sbcl-jpl-util))
+
+(define-public sbcl-jpl-queues
+ (package
+ (name "sbcl-jpl-queues")
+ (version "0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://www.thoughtcrime.us/software/jpl-queues/jpl-queues-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1wvvv7j117h9a42qaj1g4fh4mji28xqs7s60rn6d11gk9jl76h96"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("jpl-util" ,sbcl-jpl-util)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)))
+ (arguments
+ ;; Tests seem to be broken.
+ `(#:tests? #f))
+ (synopsis "Common Lisp library implementing a few different kinds of queues")
+ (description
+ "A Common Lisp library implementing a few different kinds of queues:
+
+@itemize
+@item Bounded and unbounded FIFO queues.
+@item Lossy bounded FIFO queues that drop elements when full.
+@item Unbounded random-order queues that use less memory than unbounded FIFO queues.
+@end itemize
+
+Additionally, a synchronization wrapper is provided to make any queue
+conforming to the @command{jpl-queues} API thread-safe for lightweight
+multithreading applications. (See Calispel for a more sophisticated CL
+multithreaded message-passing library with timeouts and alternation among
+several blockable channels.)")
+ (home-page "https://www.thoughtcrime.us/software/jpl-queues/")
+ (license license:isc)))
+
+(define-public cl-jpl-queues
+ (sbcl-package->cl-source-package sbcl-jpl-queues))
+
+(define-public ecl-jpl-queues
+ (sbcl-package->ecl-package sbcl-jpl-queues))
+
+(define-public sbcl-eos
+ (let ((commit "b0faca83781ead9a588661e37bd47f90362ccd94"))
+ (package
+ (name "sbcl-eos")
+ (version (git-version "0.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/adlai/Eos")
+ (commit commit)))
+ (sha256
+ (base32
+ "1bq8cfg087iyxmxi1mwgx5cfgy3b8ydrf81xljcis8qbgb2vszph"))
+ (file-name (git-file-name "eos" version))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Unit Testing for Common Lisp")
+ (description
+ "Eos was a unit testing library for Common Lisp.
+It began as a fork of FiveAM; however, FiveAM development has continued, while
+that of Eos has not. Thus, Eos is now deprecated in favor of FiveAM.")
+ (home-page "https://github.com/adlai/Eos")
+ (license license:expat))))
+
+(define-public cl-eos
+ (sbcl-package->cl-source-package sbcl-eos))
+
+(define-public ecl-eos
+ (sbcl-package->ecl-package sbcl-eos))
+
+(define-public sbcl-esrap
+ (let ((commit "133be8b05c2aae48696fe5b739eea2fa573fa48d"))
+ (package
+ (name "sbcl-esrap")
+ (version (git-version "0.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/nikodemus/esrap")
+ (commit commit)))
+ (sha256
+ (base32
+ "02d5clihsdryhf7pix8c5di2571fdsffh75d40fkzhws90r5mksl"))
+ (file-name (git-file-name "esrap" version))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("eos" ,sbcl-eos))) ;For testing only.
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)))
+ (synopsis "Common Lisp packrat parser")
+ (description
+ "A packrat parser for Common Lisp.
+In addition to regular Packrat / Parsing Grammar / TDPL features ESRAP supports:
+
+@itemize
+@item dynamic redefinition of nonterminals
+@item inline grammars
+@item semantic predicates
+@item introspective facilities (describing grammars, tracing, setting breaks)
+@end itemize\n")
+ (home-page "https://nikodemus.github.io/esrap/")
+ (license license:expat))))
+
+(define-public cl-esrap
+ (sbcl-package->cl-source-package sbcl-esrap))
+
+(define-public ecl-esrap
+ (sbcl-package->ecl-package sbcl-esrap))
+
+(define-public sbcl-split-sequence
+ (package
+ (name "sbcl-split-sequence")
+ (version "1.4.1")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sharplispers/split-sequence")
+ (commit (string-append "v" version))))
+ (sha256
+ (base32
+ "0c3zp6b7fmmp93sfhq112ind4zkld49ycw68z409xpnz3gc0wpf0"))
+ (file-name (git-file-name "split-sequence" version))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ ;; TODO: Tests seem to be broken.
+ ;; https://github.com/sharplispers/split-sequence/issues/8
+ `(#:tests? #f))
+ (synopsis "Member of the Common Lisp Utilities family of programs")
+ (description
+ "Splits sequence into a list of subsequences delimited by objects
+satisfying the test.")
+ (home-page "https://cliki.net/split-sequence")
+ (license license:expat)))
+
+(define-public cl-split-sequence
+ (sbcl-package->cl-source-package sbcl-split-sequence))
+
+(define-public ecl-split-sequence
+ (sbcl-package->ecl-package sbcl-split-sequence))
+
+(define-public sbcl-html-encode
+ (package
+ (name "sbcl-html-encode")
+ (version "1.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://beta.quicklisp.org/archive/html-encode/2010-10-06/html-encode-"
+ version ".tgz"))
+ (sha256
+ (base32
+ "06mf8wn95yf5swhmzk4vp0xr4ylfl33dgfknkabbkd8n6jns8gcf"))
+ (file-name (string-append "colorize" version "-checkout"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Common Lisp library for encoding text in various web-savvy encodings")
+ (description
+ "A library for encoding text in various web-savvy encodings.")
+ (home-page "http://quickdocs.org/html-encode/")
+ (license license:expat)))
+
+(define-public cl-html-encode
+ (sbcl-package->cl-source-package sbcl-html-encode))
+
+(define-public ecl-html-encode
+ (sbcl-package->ecl-package sbcl-html-encode))
+
+(define-public sbcl-colorize
+ (let ((commit "ea676b584e0899cec82f21a9e6871172fe3c0eb5"))
+ (package
+ (name "sbcl-colorize")
+ (version (git-version "0.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/kingcons/colorize")
+ (commit commit)))
+ (sha256
+ (base32
+ "1pdg4kiaczmr3ivffhirp7m3lbr1q27rn7dhaay0vwghmi31zcw9"))
+ (file-name (git-file-name "colorize" version))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("split-sequence" ,sbcl-split-sequence)
+ ("html-encode" ,sbcl-html-encode)))
+ (synopsis "Common Lisp for syntax highlighting")
+ (description
+ "@command{colorize} is a Lisp library for syntax highlighting
+supporting the following languages: Common Lisp, Emacs Lisp, Scheme, Clojure,
+C, C++, Java, Python, Erlang, Haskell, Objective-C, Diff, Webkit.")
+ (home-page "https://github.com/kingcons/colorize")
+ ;; TODO: Missing license?
+ (license license:expat))))
+
+(define-public cl-colorize
+ (sbcl-package->cl-source-package sbcl-colorize))
+
+(define-public ecl-colorize
+ (sbcl-package->ecl-package sbcl-colorize))
+
+(define-public sbcl-3bmd
+ (let ((commit "192ea13435b605a96ef607df51317056914cabbd"))
+ (package
+ (name "sbcl-3bmd")
+ (version (git-version "0.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/3b/3bmd")
+ (commit commit)))
+ (sha256
+ (base32
+ "1rgv3gi7wf963ikmmpk132wgn0icddf226gq3bmcnk1fr3v9gf2f"))
+ (file-name (git-file-name "3bmd" version))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ ;; FIXME: We need to specify the name because the build-system thinks
+ ;; "3" is a version marker.
+ `(#:asd-system-name "3bmd"))
+ (inputs
+ `(("esrap" ,sbcl-esrap)
+ ("split-sequence" ,sbcl-split-sequence)))
+ (synopsis "Markdown processor in Command Lisp using esrap parser")
+ (description
+ "Common Lisp Markdown -> HTML converter, using @command{esrap} for
+parsing, and grammar based on @command{peg-markdown}.")
+ (home-page "https://github.com/3b/3bmd")
+ (license license:expat))))
+
+(define-public cl-3bmd
+ (sbcl-package->cl-source-package sbcl-3bmd))
+
+(define-public ecl-3bmd
+ (sbcl-package->ecl-package sbcl-3bmd))
+
+(define-public sbcl-3bmd-ext-code-blocks
+ (let ((commit "192ea13435b605a96ef607df51317056914cabbd"))
+ (package
+ (inherit sbcl-3bmd)
+ (name "sbcl-3bmd-ext-code-blocks")
+ (arguments
+ `(#:asd-system-name "3bmd-ext-code-blocks"
+ #:asd-file "3bmd-ext-code-blocks.asd"))
+ (inputs
+ `(("3bmd" ,sbcl-3bmd)
+ ("colorize" ,sbcl-colorize)))
+ (synopsis "3bmd extension which adds support for GitHub-style fenced
+code blocks")
+ (description
+ "3bmd extension which adds support for GitHub-style fenced code blocks,
+with @command{colorize} support."))))
+
+(define-public cl-3bmd-ext-code-blocks
+ (sbcl-package->cl-source-package sbcl-3bmd-ext-code-blocks))
+
+(define-public ecl-3bmd-ext-code-blocks
+ (sbcl-package->ecl-package sbcl-3bmd-ext-code-blocks))
+
+(define-public sbcl-cl-fad
+ (package
+ (name "sbcl-cl-fad")
+ (version "0.7.5")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/edicl/cl-fad/")
+ (commit (string-append "v" version))))
+ (sha256
+ (base32
+ "1l1qmk9z57q84bz5r04sxsksggsnd7dgkxlybzh9imz6ma7sm52m"))
+ (file-name (string-append "cl-fad" version "-checkout"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
+ (synopsis "Portable pathname library for Common Lisp")
+ (description
+ "CL-FAD (for \"Files and Directories\") is a thin layer atop Common
+Lisp's standard pathname functions. It is intended to provide some
+unification between current CL implementations on Windows, OS X, Linux, and
+Unix. Most of the code was written by Peter Seibel for his book Practical
+Common Lisp.")
+ (home-page "https://edicl.github.io/cl-fad/")
+ (license license:bsd-2)))
+
+(define-public cl-fad
+ (sbcl-package->cl-source-package sbcl-cl-fad))
+
+(define-public ecl-cl-fad
+ (sbcl-package->ecl-package sbcl-cl-fad))
+
+(define-public sbcl-rt
+ (package
+ (name "sbcl-rt")
+ (version "1990.12.19")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "http://beta.quicklisp.org/archive/rt/2010-10-06/rt-"
+ "20101006-git" ".tgz"))
+ (sha256
+ (base32
+ "1jncar0xwkqk8yrc2dln389ivvgzs7ijdhhs3zpfyi5d21f0qa1v"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "MIT Regression Tester")
+ (description
+ "RT provides a framework for writing regression test suites.")
+ (home-page "https://github.com/sharplispers/nibbles")
+ (license license:unlicense)))
+
+(define-public cl-rt
+ (sbcl-package->cl-source-package sbcl-rt))
+
+(define-public ecl-rt
+ (sbcl-package->ecl-package sbcl-rt))
+
+(define-public sbcl-nibbles
+ (package
+ (name "sbcl-nibbles")
+ (version "0.14")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sharplispers/nibbles/")
+ (commit (string-append "v" version))))
+ (sha256
+ (base32
+ "1v7qfgpvdr6nz7v63dj69d26dis0kff3rd8xamr1llfdvza2pm8f"))
+ (file-name (git-file-name "nibbles" version))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ ;; Tests only.
+ `(("rt" ,sbcl-rt)))
+ (synopsis "Common Lisp library for accessing octet-addressed blocks of data")
+ (description
+ "When dealing with network protocols and file formats, it's common to
+have to read or write 16-, 32-, or 64-bit datatypes in signed or unsigned
+flavors. Common Lisp sort of supports this by specifying :element-type for
+streams, but that facility is underspecified and there's nothing similar for
+read/write from octet vectors. What most people wind up doing is rolling their
+own small facility for their particular needs and calling it a day.
+
+This library attempts to be comprehensive and centralize such
+facilities. Functions to read 16-, 32-, and 64-bit quantities from octet
+vectors in signed or unsigned flavors are provided; these functions are also
+SETFable. Since it's sometimes desirable to read/write directly from streams,
+functions for doing so are also provided. On some implementations,
+reading/writing IEEE singles/doubles (i.e. single-float and double-float) will
+also be supported.")
+ (home-page "https://github.com/sharplispers/nibbles")
+ (license license:bsd-3)))
+
+(define-public cl-nibbles
+ (sbcl-package->cl-source-package sbcl-nibbles))
+
+(define-public ecl-nibbles
+ (sbcl-package->ecl-package sbcl-nibbles))
+
+(define-public sbcl-ironclad
+ (package
+ (name "sbcl-ironclad")
+ (version "0.46")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sharplispers/ironclad/")
+ (commit (string-append "v" version))))
+ (sha256
+ (base32
+ "1s391awi2lsl7m1dbjirgpkm4p9p8wd076pakgvsvpn1rrznisnd"))
+ (file-name (git-file-name name version))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ ;; Tests only.
+ `(("rt" ,sbcl-rt)))
+ (inputs
+ `(("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("flexi-streams" ,sbcl-flexi-streams)
+ ("nibbles" ,sbcl-nibbles)))
+ (synopsis "Cryptographic toolkit written in Common Lisp")
+ (description
+ "Ironclad is a cryptography library written entirely in Common Lisp.
+It includes support for several popular ciphers, digests, MACs and public key
+cryptography algorithms. For several implementations that support Gray
+streams, support is included for convenient stream wrappers.")
+ (home-page "https://github.com/sharplispers/ironclad")
+ (license license:bsd-3)))
+
+(define-public cl-ironclad
+ (sbcl-package->cl-source-package sbcl-ironclad))
+
+(define-public ecl-ironclad
+ (sbcl-package->ecl-package sbcl-ironclad))
+
+(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 (git-file-name "named-readtables" version))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ ;; Tests seem to be broken.
+ `(#:tests? #f))
+ (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 cl-named-readtables
+ (sbcl-package->cl-source-package sbcl-named-readtables))
+
+(define-public ecl-named-readtables
+ (sbcl-package->ecl-package sbcl-named-readtables))
+
+(define-public sbcl-pythonic-string-reader
+ (let ((commit "47a70ba1e32362e03dad6ef8e6f36180b560f86a"))
+ (package
+ (name "sbcl-pythonic-string-reader")
+ (version (git-version "0.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/smithzvk/pythonic-string-reader/")
+ (commit commit)))
+ (sha256
+ (base32 "1b5iryqw8xsh36swckmz8rrngmc39k92si33fgy5pml3n9l5rq3j"))
+ (file-name (git-file-name "pythonic-string-reader" version))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("named-readtables" ,sbcl-named-readtables)))
+ (home-page "https://github.com/smithzvk/pythonic-string-reader")
+ (synopsis "Read table modification inspired by Python's three quote strings")
+ (description "This piece of code sets up some reader macros that make it
+simpler to input string literals which contain backslashes and double quotes
+This is very useful for writing complicated docstrings and, as it turns out,
+writing code that contains string literals that contain code themselves.")
+ (license license:bsd-3))))
+
+(define-public cl-pythonic-string-reader
+ (sbcl-package->cl-source-package sbcl-pythonic-string-reader))
+
+(define-public ecl-pythonic-string-reader
+ (sbcl-package->ecl-package sbcl-pythonic-string-reader))
+
+;; SLIME does not have a ASDF system definition to build all of Swank. As a
+;; result, the asdf-build-system/sbcl will produce an almost empty package.
+;; Some work was done to fix this at
+;; https://github.com/sionescu/slime/tree/swank-asdf but it was never merged
+;; and is now lagging behind. Building SBCL fasls might not be worth the
+;; hassle, so let's just ship the source then.
+(define-public cl-slime-swank
+ (package
+ (name "cl-slime-swank")
+ (version "2.24")
+ (source
+ (origin
+ (file-name (string-append name "-" version ".tar.gz"))
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/slime/slime/")
+ (commit (string-append "v" version))))
+ (sha256
+ (base32
+ "0js24x42m7b5iymb4rxz501dff19vav5pywnzv50b673rbkaaqvh"))))
+ (build-system asdf-build-system/source)
+ (home-page "https://github.com/slime/slime")
+ (synopsis "Common Lisp Swank server")
+ (description
+ "This is only useful if you want to start a Swank server in a Lisp
+processes that doesn't run under Emacs. Lisp processes created by
+@command{M-x slime} automatically start the server.")
+ (license (list license:gpl2+ license:public-domain))))
+
+(define-public sbcl-slime-swank
+ (deprecated-package "sbcl-slime-swank" cl-slime-swank))
+
+(define-public sbcl-mgl-pax
+ (let ((commit "818448418d6b9de74620f606f5b23033c6082769"))
+ (package
+ (name "sbcl-mgl-pax")
+ (version (git-version "0.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/melisgl/mgl-pax")
+ (commit commit)))
+ (sha256
+ (base32
+ "1p97zfkh130bdxqqxwaw2j9psv58751wakx7czbfpq410lg7dd7i"))
+ (file-name (git-file-name "mgl-pax" version))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("3bmd" ,sbcl-3bmd)
+ ("3bmd-ext-code-blocks" ,sbcl-3bmd-ext-code-blocks)
+ ("babel" ,sbcl-babel)
+ ("cl-fad" ,sbcl-cl-fad)
+ ("ironclad" ,sbcl-ironclad)
+ ("named-readtables" ,sbcl-named-readtables)
+ ("pythonic-string-reader" ,sbcl-pythonic-string-reader)
+ ("swank" ,cl-slime-swank)))
+ (synopsis "Exploratory programming environment and documentation generator")
+ (description
+ "PAX provides an extremely poor man's Explorable Programming
+environment. Narrative primarily lives in so called sections that mix markdown
+docstrings with references to functions, variables, etc, all of which should
+probably have their own docstrings.
+
+The primary focus is on making code easily explorable by using SLIME's
+@command{M-.} (@command{slime-edit-definition}). See how to enable some
+fanciness in Emacs Integration. Generating documentation from sections and all
+the referenced items in Markdown or HTML format is also implemented.
+
+With the simplistic tools provided, one may accomplish similar effects as with
+Literate Programming, but documentation is generated from code, not vice versa
+and there is no support for chunking yet. Code is first, code must look
+pretty, documentation is code.")
+ (home-page "http://quotenil.com/")
+ (license license:expat))))
+
+(define-public cl-mgl-pax
+ (sbcl-package->cl-source-package sbcl-mgl-pax))
+
+(define-public ecl-mgl-pax
+ (sbcl-package->ecl-package sbcl-mgl-pax))
+
+(define-public sbcl-lisp-unit
+ (let ((commit "89653a232626b67400bf9a941f9b367da38d3815"))
+ (package
+ (name "sbcl-lisp-unit")
+ (version (git-version "0.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/OdonataResearchLLC/lisp-unit")
+ (commit commit)))
+ (sha256
+ (base32
+ "0p6gdmgr7p383nvd66c9y9fp2bjk4jx1lpa5p09g43hr9y9pp9ry"))
+ (file-name (git-file-name "lisp-unit" version))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Common Lisp Test framework inspired by JUnit to be simple of use")
+ (description
+ "@command{lisp-unit} is a Common Lisp library that supports unit
+testing. It is an extension of the library written by Chris Riesbeck.")
+ (home-page "https://github.com/OdonataResearchLLC/lisp-unit")
+ (license license:expat))))
+
+(define-public cl-lisp-unit
+ (sbcl-package->cl-source-package sbcl-lisp-unit))
+
+(define-public ecl-lisp-unit
+ (sbcl-package->ecl-package sbcl-lisp-unit))
+
+(define-public sbcl-anaphora
+ (package
+ (name "sbcl-anaphora")
+ (version "0.9.6")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/tokenrove/anaphora")
+ (commit version)))
+ (sha256
+ (base32
+ "19wfrk3asimznkli0x2rfy637hwpdgqyvwj3vhq9x7vjvyf5vv6x"))
+ (file-name (git-file-name "anaphora" version))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("rt" ,sbcl-rt)))
+ (synopsis "The anaphoric macro collection from Hell")
+ (description
+ "Anaphora is the anaphoric macro collection from Hell: it includes many
+new fiends in addition to old friends like @command{aif} and
+@command{awhen}.")
+ (home-page "https://github.com/tokenrove/anaphora")
+ (license license:public-domain)))
+
+(define-public cl-anaphora
+ (sbcl-package->cl-source-package sbcl-anaphora))
+
+(define-public ecl-anaphora
+ (sbcl-package->ecl-package sbcl-anaphora))
+
+(define-public sbcl-lift
+ (let ((commit "7d49a66c62759535624037826891152223d4206c"))
+ (package
+ (name "sbcl-lift")
+ (version (git-version "1.7.1" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/gwkkwg/lift")
+ (commit commit)))
+ (sha256
+ (base32
+ "127v5avpz1i4m0lkaxqrq8hrl69rdazqaxf6s8awf0nd7wj2g4dp"))
+ (file-name (git-file-name "lift" version))
+ (modules '((guix build utils)))
+ (snippet
+ ;; Don't keep the bundled website
+ `(begin
+ (delete-file-recursively "website")
+ #t))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ ;; The tests require a debugger, but we run with the debugger disabled.
+ '(#:tests? #f))
+ (synopsis "LIsp Framework for Testing")
+ (description
+ "The LIsp Framework for Testing (LIFT) is a unit and system test tool for LISP.
+Though inspired by SUnit and JUnit, it's built with Lisp in mind. In LIFT,
+testcases are organized into hierarchical testsuites each of which can have
+its own fixture. When run, a testcase can succeed, fail, or error. LIFT
+supports randomized testing, benchmarking, profiling, and reporting.")
+ (home-page "https://github.com/gwkkwg/lift")
+ (license license:expat))))
+
+(define-public cl-lift
+ (sbcl-package->cl-source-package sbcl-lift))
+
+(define-public ecl-lift
+ (sbcl-package->ecl-package sbcl-lift))
+
+(define-public sbcl-let-plus
+ (let ((commit "5f14af61d501ecead02ec6b5a5c810efc0c9fdbb"))
+ (package
+ (name "sbcl-let-plus")
+ (version (git-version "0.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sharplispers/let-plus")
+ (commit commit)))
+ (sha256
+ (base32
+ "0i050ca2iys9f5mb7dgqgqdxfnc3b0rnjdwv95sqd490vkiwrsaj"))
+ (file-name (git-file-name "let-plus" version))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("anaphora" ,sbcl-anaphora)))
+ (native-inputs
+ `(("lift" ,sbcl-lift)))
+ (synopsis "Destructuring extension of let*")
+ (description
+ "This library implements the let+ macro, which is a dectructuring
+extension of let*. It features:
+
+@itemize
+@item Clean, consistent syntax and small implementation (less than 300 LOC,
+not counting tests)
+@item Placeholder macros allow editor hints and syntax highlighting
+@item @command{&ign} for ignored values (in forms where that makes sense)
+@item Very easy to extend
+@end itemize\n")
+ (home-page "https://github.com/sharplispers/let-plus")
+ (license license:boost1.0))))
+
+(define-public cl-let-plus
+ (sbcl-package->cl-source-package sbcl-let-plus))
+
+(define-public ecl-let-plus
+ (sbcl-package->ecl-package sbcl-let-plus))
+
+(define-public sbcl-cl-colors
+ (let ((commit "827410584553f5c717eec6182343b7605f707f75"))
+ (package
+ (name "sbcl-cl-colors")
+ (version (git-version "0.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/tpapp/cl-colors")
+ (commit commit)))
+ (sha256
+ (base32
+ "0l446lday4hybsm9bq3jli97fvv8jb1d33abg79vbylpwjmf3y9a"))
+ (file-name (git-file-name "cl-colors" version))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("let-plus" ,sbcl-let-plus)))
+ (synopsis "Simple color library for Common Lisp")
+ (description
+ "This is a very simple color library for Common Lisp, providing
+
+@itemize
+@item Types for representing colors in HSV and RGB spaces.
+@item Simple conversion functions between the above types (and also
+hexadecimal representation for RGB).
+@item Some predefined colors (currently X11 color names – of course the
+library does not depend on X11).Because color in your terminal is nice.
+@end itemize
+
+This library is no longer supported by its author.")
+ (home-page "https://github.com/tpapp/cl-colors")
+ (license license:boost1.0))))
+
+(define-public cl-colors
+ (sbcl-package->cl-source-package sbcl-cl-colors))
+
+(define-public ecl-cl-colors
+ (sbcl-package->ecl-package sbcl-cl-colors))
+
+(define-public sbcl-cl-ansi-text
+ (let ((commit "53badf7878f27f22f2d4a2a43e6df458e43acbe9"))
+ (package
+ (name "sbcl-cl-ansi-text")
+ (version (git-version "1.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/pnathan/cl-ansi-text")
+ (commit commit)))
+ (sha256
+ (base32
+ "11i27n0dbz5lmygiw65zzr8lx0rac6b6yysqranphn31wls6ja3v"))
+ (file-name (git-file-name "cl-ansi-text" version))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-colors" ,sbcl-cl-colors)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (synopsis "ANSI terminal color implementation for Common Lisp")
+ (description
+ "@command{cl-ansi-text} provides utilities which enable printing to an
+ANSI terminal with colored text. It provides the macro @command{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.")
+ (home-page "https://github.com/pnathan/cl-ansi-text")
+ (license license:llgpl))))
+
+(define-public cl-ansi-text
+ (sbcl-package->cl-source-package sbcl-cl-ansi-text))
+
+(define-public ecl-cl-ansi-text
+ (sbcl-package->ecl-package sbcl-cl-ansi-text))
+
+(define-public sbcl-prove-asdf
+ (let ((commit "4f9122bd393e63c5c70c1fba23070622317cfaa0"))
+ (package
+ (name "sbcl-prove-asdf")
+ (version (git-version "1.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/prove")
+ (commit commit)))
+ (sha256
+ (base32
+ "07sbfw459z8bbjvx1qlmfa8qk2mvbjnnzi2mi0x72blaj8bkl4vc"))
+ (file-name (git-file-name "prove" version))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:asd-file "prove-asdf.asd"))
+ (synopsis "Test requirement for the Common Lisp 'prove' library")
+ (description
+ "Test requirement for the Common Lisp @command{prove} library.")
+ (home-page "https://github.com/fukamachi/prove")
+ (license license:expat))))
+
+(define-public cl-prove-asdf
+ (sbcl-package->cl-source-package sbcl-prove-asdf))
+
+(define-public ecl-prove-asdf
+ (sbcl-package->ecl-package sbcl-prove-asdf))
+
+(define-public sbcl-prove
+ (package
+ (inherit sbcl-prove-asdf)
+ (name "sbcl-prove")
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("cl-ansi-text" ,sbcl-cl-ansi-text)))
+ (native-inputs
+ `(("prove-asdf" ,sbcl-prove-asdf)))
+ (arguments
+ `(#:asd-file "prove.asd"))
+ (synopsis "Yet another unit testing framework for Common Lisp")
+ (description
+ "This project was originally called @command{cl-test-more}.
+@command{prove} is yet another unit testing framework for Common Lisp. The
+advantages of @command{prove} are:
+
+@itemize
+@item Various simple functions for testing and informative error messages
+@item ASDF integration
+@item Extensible test reporters
+@item Colorizes the report if it's available (note for SLIME)
+@item Reports test durations
+@end itemize\n")))
+
+(define-public cl-prove
+ (sbcl-package->cl-source-package sbcl-prove))
+
+(define-public ecl-prove
+ (sbcl-package->ecl-package sbcl-prove))
+
+(define-public sbcl-proc-parse
+ (let ((commit "ac3636834d561bdc2686c956dbd82494537285fd"))
+ (package
+ (name "sbcl-proc-parse")
+ (version (git-version "0.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/proc-parse")
+ (commit commit)))
+ (sha256
+ (base32
+ "06rnl0h4cx6xv2wj3jczmmcxqn2703inmmvg1s4npbghmijsybfh"))
+ (file-name (git-file-name "proc-parse" version))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("babel" ,sbcl-babel)))
+ (native-inputs
+ `(("prove" ,sbcl-prove)
+ ("prove-asdf" ,sbcl-prove-asdf)))
+ (arguments
+ ;; TODO: Tests don't find "proc-parse-test", why?
+ `(#:tests? #f))
+ (synopsis "Procedural vector parser")
+ (description
+ "This is a string/octets parser library for Common Lisp with speed and
+readability in mind. Unlike other libraries, the code is not a
+pattern-matching-like, but a char-by-char procedural parser.")
+ (home-page "https://github.com/fukamachi/proc-parse")
+ (license license:bsd-2))))
+
+(define-public cl-proc-parse
+ (sbcl-package->cl-source-package sbcl-proc-parse))
+
+(define-public ecl-proc-parse
+ (sbcl-package->ecl-package sbcl-proc-parse))
+
+(define-public sbcl-parse-float
+ (let ((commit "2aae569f2a4b2eb3bfb5401a959425dcf151b09c"))
+ (package
+ (name "sbcl-parse-float")
+ (version (git-version "0.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/soemraws/parse-float")
+ (commit commit)))
+ (sha256
+ (base32
+ "08xw8cchhmqcc0byng69m3f5a2izc9y2290jzz2k0qrbibp1fdk7"))
+ (file-name (git-file-name "proc-parse" version))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("babel" ,sbcl-babel)))
+ (native-inputs
+ `(("prove" ,sbcl-prove)
+ ("prove-asdf" ,sbcl-prove-asdf)))
+ (arguments
+ ;; TODO: Tests don't find "proc-parse-test", why?
+ `(#:tests? #f))
+ (synopsis "Parse a floating point value from a string in Common Lisp")
+ (description
+ "This package exports the following function to parse floating-point
+values from a string in Common Lisp.")
+ (home-page "https://github.com/soemraws/parse-float")
+ (license license:public-domain))))
+
+(define-public cl-parse-float
+ (sbcl-package->cl-source-package sbcl-parse-float))
+
+(define-public ecl-parse-float
+ (sbcl-package->ecl-package sbcl-parse-float))
+
+(define-public sbcl-ascii-strings
+ (let ((revision "1")
+ (changeset "5048480a61243e6f1b02884012c8f25cdbee6d97"))
+ (package
+ (name "sbcl-ascii-strings")
+ (version (string-append "0-" revision "." (string-take changeset 7)))
+ (source
+ (origin
+ (method hg-fetch)
+ (uri (hg-reference
+ (url "https://bitbucket.org/vityok/cl-string-match/")
+ (changeset changeset)))
+ (sha256
+ (base32
+ "01wn5qx562w43ssy92xlfgv79w7p0nv0wbl76mpmba131n9ziq2y"))
+ (file-name (git-file-name "cl-string-match" version))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("babel" ,sbcl-babel)))
+ (arguments
+ `(#:asd-file "ascii-strings.asd"))
+ (synopsis "Operations on ASCII strings")
+ (description
+ "Operations on ASCII strings. Essentially this can be any kind of
+single-byte encoded strings.")
+ (home-page "https://bitbucket.org/vityok/cl-string-match/")
+ (license license:bsd-3))))
+
+(define-public cl-ascii-strings
+ (sbcl-package->cl-source-package sbcl-ascii-strings))
+
+(define-public ecl-ascii-strings
+ (sbcl-package->ecl-package sbcl-ascii-strings))
+
+(define-public sbcl-simple-scanf
+ (package
+ (inherit sbcl-ascii-strings)
+ (name "sbcl-simple-scanf")
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("iterate" ,sbcl-iterate)
+ ("proc-parse" ,sbcl-proc-parse)
+ ("parse-float" ,sbcl-parse-float)))
+ (arguments
+ `(#:asd-file "simple-scanf.asd"))
+ (synopsis "Simple scanf-like functionality implementation")
+ (description
+ "A simple scanf-like functionality implementation.")))
+
+(define-public cl-simple-scanf
+ (sbcl-package->cl-source-package sbcl-simple-scanf))
+
+(define-public ecl-simple-scanf
+ (sbcl-package->ecl-package sbcl-simple-scanf))
+
+(define-public sbcl-cl-string-match
+ (package
+ (inherit sbcl-ascii-strings)
+ (name "sbcl-cl-string-match")
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("ascii-strings" ,sbcl-ascii-strings)
+ ("yacc" ,sbcl-cl-yacc)
+ ("jpl-util" ,sbcl-jpl-util)
+ ("jpl-queues" ,sbcl-jpl-queues)
+ ("mgl-pax" ,sbcl-mgl-pax)
+ ("iterate" ,sbcl-iterate)))
+ ;; TODO: Tests are not evaluated properly.
+ (native-inputs
+ ;; For testing:
+ `(("lisp-unit" ,sbcl-lisp-unit)
+ ("simple-scanf" ,sbcl-simple-scanf)))
+ (arguments
+ `(#:tests? #f
+ #:asd-file "cl-string-match.asd"))
+ (synopsis "Portable, dependency-free set of utilities to manipulate strings in Common Lisp")
+ (description
+ "@command{cl-strings} is a small, portable, dependency-free set of
+utilities that make it even easier to manipulate text in Common Lisp. It has
+100% test coverage and works at least on sbcl, ecl, ccl, abcl and clisp.")))
+
+(define-public cl-string-match
+ (sbcl-package->cl-source-package sbcl-cl-string-match))
+
+(define-public ecl-cl-string-match
+ (sbcl-package->ecl-package sbcl-cl-string-match))
+
+(define-public sbcl-ptester
+ (package
+ (name "sbcl-ptester")
+ (version "20160929")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "http://beta.quicklisp.org/archive/ptester/"
+ (date->string (string->date version "~Y~m~d") "~Y-~m-~d")
+ "/ptester-"
+ version
+ "-git.tgz"))
+ (sha256
+ (base32
+ "04rlq1zljhxc65pm31bah3sq3as24l0sdivz440s79qlnnyh13hz"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "http://quickdocs.org/ptester/")
+ (synopsis "Portable test harness package")
+ (description
+ "@command{ptester} is a portable testing framework based on Franz's
+tester module.")
+ (license license:lgpl3+)))
+
+(define-public cl-ptester
+ (sbcl-package->cl-source-package sbcl-ptester))
+
+(define-public ecl-ptester
+ (sbcl-package->ecl-package sbcl-ptester))
+
+(define-public sbcl-puri
+ (package
+ (name "sbcl-puri")
+ (version "20180228")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "http://beta.quicklisp.org/archive/puri/"
+ (date->string (string->date version "~Y~m~d") "~Y-~m-~d")
+ "/puri-"
+ version
+ "-git.tgz"))
+ (sha256
+ (base32
+ "1s4r5adrjy5asry45xbcbklxhdjydvf6n55z897nvyw33bigrnbz"))))
+ (build-system asdf-build-system/sbcl)
+ ;; REVIEW: Webiste down?
+ (native-inputs
+ `(("ptester" ,sbcl-ptester)))
+ (home-page "http://files.kpe.io/puri/")
+ (synopsis "Portable URI Library")
+ (description
+ "This is portable Universal Resource Identifier library for Common Lisp
+programs. It parses URI according to the RFC 2396 specification")
+ (license license:lgpl3+)))
+
+(define-public cl-puri
+ (sbcl-package->cl-source-package sbcl-puri))
+
+(define-public ecl-puri
+ (sbcl-package->ecl-package sbcl-puri))
+
+(define-public sbcl-queues
+ (let ((commit "47d4da65e9ea20953b74aeeab7e89a831b66bc94"))
+ (package
+ (name "sbcl-queues")
+ (version (git-version "0.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/oconnore/queues")
+ (commit commit)))
+ (file-name (git-file-name "queues" version))
+ (sha256
+ (base32
+ "0wdhfnzi4v6d97pggzj2aw55si94w4327br94jrmyvwf351wqjvv"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/oconnore/queues")
+ (synopsis "Common Lisp queue library")
+ (description
+ "This is a simple queue library for Common Lisp with features such as
+non-consing thread safe queues and fibonacci priority queues.")
+ (license license:expat))))
+
+(define-public cl-queues
+ (sbcl-package->cl-source-package sbcl-queues))
+
+(define-public ecl-queues
+ (sbcl-package->ecl-package sbcl-queues))
+
+(define-public sbcl-queues.simple-queue
+ (package
+ (inherit sbcl-queues)
+ (name "sbcl-queues.simple-queue")
+ (inputs
+ `(("sbcl-queues" ,sbcl-queues)))
+ (arguments
+ `(#:asd-file "queues.simple-queue.asd"))
+ (synopsis "Simple queue implementation")
+ (description
+ "This is a simple queue library for Common Lisp with features such as
+non-consing thread safe queues and fibonacci priority queues.")
+ (license license:expat)))
+
+(define-public cl-queues.simple-queue
+ (sbcl-package->cl-source-package sbcl-queues.simple-queue))
+
+(define-public ecl-queues.simple-queue
+ (sbcl-package->ecl-package sbcl-queues.simple-queue))
+
+(define-public sbcl-queues.simple-cqueue
+ (package
+ (inherit sbcl-queues)
+ (name "sbcl-queues.simple-cqueue")
+ (inputs
+ `(("sbcl-queues" ,sbcl-queues)
+ ("sbcl-queues.simple-queue" ,sbcl-queues.simple-queue)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)))
+ (arguments
+ `(#:asd-file "queues.simple-cqueue.asd"))
+ (synopsis "Thread safe queue implementation")
+ (description
+ "This is a simple queue library for Common Lisp with features such as
+non-consing thread safe queues and fibonacci priority queues.")
+ (license license:expat)))
+
+(define-public cl-queues.simple-cqueue
+ (sbcl-package->cl-source-package sbcl-queues.simple-cqueue))
+
+(define-public ecl-queues.simple-cqueue
+ (sbcl-package->ecl-package sbcl-queues.simple-cqueue))
+
+(define-public sbcl-queues.priority-queue
+ (package
+ (inherit sbcl-queues)
+ (name "sbcl-queues.priority-queue")
+ (inputs
+ `(("sbcl-queues" ,sbcl-queues)))
+ (arguments
+ `(#:asd-file "queues.priority-queue.asd"))
+ (synopsis "Priority queue (Fibonacci) implementation")
+ (description
+ "This is a simple queue library for Common Lisp with features such as
+non-consing thread safe queues and fibonacci priority queues.")
+ (license license:expat)))
+
+(define-public cl-queues.priority-queue
+ (sbcl-package->cl-source-package sbcl-queues.priority-queue))
+
+(define-public ecl-queues.priority-queue
+ (sbcl-package->ecl-package sbcl-queues.priority-queue))
+
+(define-public sbcl-queues.priority-cqueue
+ (package
+ (inherit sbcl-queues)
+ (name "sbcl-queues.priority-cqueue")
+ (inputs
+ `(("sbcl-queues" ,sbcl-queues)
+ ("sbcl-queues.priority-queue" ,sbcl-queues.priority-queue)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)))
+ (arguments
+ `(#:asd-file "queues.priority-cqueue.asd"))
+ (synopsis "Thread safe fibonacci priority queue implementation")
+ (description
+ "This is a simple queue library for Common Lisp with features such as
+non-consing thread safe queues and fibonacci priority queues.")
+ (license license:expat)))
+
+(define-public cl-queues.priority-cqueue
+ (sbcl-package->cl-source-package sbcl-queues.priority-cqueue))
+
+(define-public ecl-queues.priority-cqueue
+ (sbcl-package->ecl-package sbcl-queues.priority-cqueue))
+
+(define sbcl-cffi-bootstrap
+ (package
+ (name "sbcl-cffi-bootstrap")
+ (version "0.19.0")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/cffi/cffi.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cffi-bootstrap" version))
+ (sha256
+ (base32 "09sfgc6r7ihmbkwfpvkq5fxc7h45cabpvgbvs47i5cvnmv3k72xy"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("libffi" ,libffi)
+ ("alexandria" ,sbcl-alexandria)
+ ("babel" ,sbcl-babel)
+ ("trivial-features" ,sbcl-trivial-features)))
+ (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 "https://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:expat)))
+
+(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)
+ ("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 cl-cffi
+ (sbcl-package->cl-source-package sbcl-cffi))
+
+(define-public sbcl-cl-sqlite
+ (let ((commit "c738e66d4266ef63a1debc4ef4a1b871a068c112"))
+ (package
+ (name "sbcl-cl-sqlite")
+ (version (git-version "0.2" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/dmitryvk/cl-sqlite")
+ (commit commit)))
+ (file-name (git-file-name "cl-sqlite" version))
+ (sha256
+ (base32
+ "1ng45k1hdb84sqjryrfx93g66bsbybmpy301wd0fdybnc5jzr36q"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("iterate" ,sbcl-iterate)
+ ("cffi" ,sbcl-cffi)
+ ("sqlite" ,sqlite)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)))
+ (arguments
+ `(#:tests? #f ; Upstream seems to have issues with tests: https://github.com/dmitryvk/cl-sqlite/issues/7
+ #:asd-file "sqlite.asd"
+ #:asd-system-name "sqlite"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "sqlite-ffi.lisp"
+ (("libsqlite3" all) (string-append
+ (assoc-ref inputs "sqlite")"/lib/" all))))))))
+ (home-page "https://common-lisp.net/project/cl-sqlite/")
+ (synopsis "Common Lisp binding for SQLite")
+ (description
+ "The @command{cl-sqlite} package is an interface to the SQLite embedded
+relational database engine.")
+ (license license:public-domain))))
+
+(define-public cl-sqlite
+ (sbcl-package->cl-source-package sbcl-cl-sqlite))
+
+(define-public sbcl-parenscript
+ (let ((commit "061d8e286c81c3f45c84fb2b11ee7d83f590a8f8"))
+ (package
+ (name "sbcl-parenscript")
+ (version (git-version "2.6" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://gitlab.common-lisp.net/parenscript/parenscript")
+ (commit commit)))
+ (file-name (git-file-name "parenscript" version))
+ (sha256
+ (base32
+ "1kbhgsjbikc73m5cwdp4d4fdafyqcr1b7b630qjrziql0nh6mi3k"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("cl-ppcre" ,sbcl-cl-ppcre)
+ ("anaphora" ,sbcl-anaphora)
+ ("named-readtables" ,sbcl-named-readtables)))
+ (home-page "https://common-lisp.net/project/parenscript/")
+ (synopsis "Translator from a subset of Common Lisp to JavaScript")
+ (description
+ "Parenscript is a translator from an extended subset of Common Lisp to
+JavaScript. Parenscript code can run almost identically on both the
+browser (as JavaScript) and server (as Common Lisp).
+
+Parenscript code is treated the same way as Common Lisp code, making the full
+power of Lisp macros available for JavaScript. This provides a web
+development environment that is unmatched in its ability to reduce code
+duplication and provide advanced meta-programming facilities to web
+developers.
+
+At the same time, Parenscript is different from almost all other \"language
+X\" to JavaScript translators in that it imposes almost no overhead:
+
+@itemize
+@item No run-time dependencies: Any piece of Parenscript code is runnable
+as-is. There are no JavaScript files to include.
+@item Native types: Parenscript works entirely with native JavaScript data
+types. There are no new types introduced, and object prototypes are not
+touched.
+@item Native calling convention: Any JavaScript code can be called without the
+need for bindings. Likewise, Parenscript can be used to make efficient,
+self-contained JavaScript libraries.
+@item Readable code: Parenscript generates concise, formatted, idiomatic
+JavaScript code. Identifier names are preserved. This enables seamless
+debugging in tools like Firebug.
+@item Efficiency: Parenscript introduces minimal overhead for advanced Common
+Lisp features. The generated code is almost as fast as hand-written
+JavaScript.
+@end itemize\n")
+ (license license:bsd-3))))
+
+(define-public cl-parenscript
+ (sbcl-package->cl-source-package sbcl-parenscript))
+
+(define-public ecl-parenscript
+ (sbcl-package->ecl-package sbcl-parenscript))
+
+(define-public sbcl-cl-json
+ (let ((commit "6dfebb9540bfc3cc33582d0c03c9ec27cb913e79"))
+ (package
+ (name "sbcl-cl-json")
+ (version (git-version "0.5" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/hankhero/cl-json")
+ (commit commit)))
+ (file-name (git-file-name "cl-json" version))
+ (sha256
+ (base32
+ "0fx3m3x3s5ji950yzpazz4s0img3l6b3d6l3jrfjv0lr702496lh"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (home-page "https://github.com/hankhero/cl-json")
+ (synopsis "JSON encoder and decoder for Common-Lisp")
+ (description
+ "@command{cl-json} provides an encoder of Lisp objects to JSON format
+and a corresponding decoder of JSON data to Lisp objects. Both the encoder
+and the decoder are highly customizable; at the same time, the default
+settings ensure a very simple mode of operation, similar to that provided by
+@command{yason} or @command{st-json}.")
+ (license license:expat))))
+
+(define-public cl-json
+ (sbcl-package->cl-source-package sbcl-cl-json))
+
+(define-public ecl-cl-json
+ (sbcl-package->ecl-package sbcl-cl-json))
+
+(define-public sbcl-unix-opts
+ (package
+ (name "sbcl-unix-opts")
+ (version "0.1.7")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/libre-man/unix-opts")
+ (commit version)))
+ (file-name (git-file-name "unix-opts" version))
+ (sha256
+ (base32
+ "08djdi1ard09fijb7w9bdmhmwd98b1hzmcnjw9fqjiqa0g3b44rr"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/hankhero/cl-json")
+ (synopsis "Unix-style command line options parser")
+ (description
+ "This is a minimalistic parser of command line options. The main
+advantage of the library is the ability to concisely define command line
+options once and then use this definition for parsing and extraction of
+command line arguments, as well as printing description of command line
+options (you get --help for free). This way you don't need to repeat
+yourself. Also, @command{unix-opts} doesn't depend on anything and allows to
+precisely control behavior of the parser via Common Lisp restarts.")
+ (license license:expat)))
+
+(define-public cl-unix-opts
+ (sbcl-package->cl-source-package sbcl-unix-opts))
+
+(define-public ecl-unix-opts
+ (sbcl-package->ecl-package sbcl-unix-opts))
+
+(define-public sbcl-trivial-garbage
+ (package
+ (name "sbcl-trivial-garbage")
+ (version "0.21")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/trivial-garbage/trivial-garbage.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "trivial-garbage" version))
+ (sha256
+ (base32 "0122jicfg7pca1wxw8zak1n92h5friqy60988ns0ysksj3fphw9n"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("rt" ,sbcl-rt)))
+ (home-page "https://common-lisp.net/project/trivial-garbage/")
+ (synopsis "Portable GC-related APIs for Common Lisp")
+ (description "@command{trivial-garbage} provides a portable API to
+finalizers, weak hash-tables and weak pointers on all major implementations of
+the Common Lisp programming language.")
+ (license license:public-domain)))
+
+(define-public cl-trivial-garbage
+ (sbcl-package->cl-source-package sbcl-trivial-garbage))
+
+(define-public ecl-trivial-garbage
+ (sbcl-package->ecl-package sbcl-trivial-garbage))
+
+(define-public sbcl-closer-mop
+ (let ((commit "fac29ce90e3a46e1fc6cf182190e193526fa9dbc"))
+ (package
+ (name "sbcl-closer-mop")
+ (version (git-version "1.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/pcostanza/closer-mop")
+ (commit commit)))
+ (sha256
+ (base32 "0hvh77y869h8fg9di5snyg85fxq6fdh9gj1igmx1g6j6j5x915dl"))
+ (file-name (git-file-name "closer-mop" version ))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/pcostanza/closer-mop")
+ (synopsis "Rectifies absent or incorrect CLOS MOP features")
+ (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:expat))))
+
+(define-public cl-closer-mop
+ (sbcl-package->cl-source-package sbcl-closer-mop))
+
+(define-public ecl-closer-mop
+ (sbcl-package->ecl-package sbcl-closer-mop))
+
+(define sbcl-cl-cffi-gtk-boot0
+ (let ((commit "29443c5aaca975709df8025c4649366d882033cb"))
+ (package
+ (name "sbcl-cl-cffi-gtk-boot0")
+ (version (git-version "0.11.2" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Ferada/cl-cffi-gtk/")
+ (commit commit)))
+ (file-name (git-file-name "cl-cffi-gtk" version))
+ (sha256
+ (base32
+ "0f6s92sf8xyzh1yksqx8bsy1sv0zmy0c13j3b8bavaba5hlxpxah"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("iterate" ,sbcl-iterate)
+ ("cffi" ,sbcl-cffi)
+ ("trivial-features" ,sbcl-trivial-features)))
+ (home-page "https://github.com/Ferada/cl-cffi-gtk/")
+ (synopsis "Common Lisp binding for GTK+3")
+ (description
+ "@command{cl-cffi-gtk} is a Lisp binding to GTK+ 3 (GIMP Toolkit) which
+is a library for creating graphical user interfaces.")
+ (license license:lgpl3))))
+
+(define-public sbcl-cl-cffi-gtk-glib
+ (package
+ (inherit sbcl-cl-cffi-gtk-boot0)
+ (name "sbcl-cl-cffi-gtk-glib")
+ (inputs
+ `(("glib" ,glib)
+ ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
+ (arguments
+ `(#:asd-file "glib/cl-cffi-gtk-glib.asd"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "glib/glib.init.lisp"
+ (("libglib|libgthread" all) (string-append
+ (assoc-ref inputs "glib") "/lib/" all))))))))))
+
+(define-public sbcl-cl-cffi-gtk-gobject
+ (package
+ (inherit sbcl-cl-cffi-gtk-boot0)
+ (name "sbcl-cl-cffi-gtk-gobject")
+ (inputs
+ `(("glib" ,glib)
+ ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
+ ("trivial-garbage" ,sbcl-trivial-garbage)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("closer-mop" ,sbcl-closer-mop)
+ ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
+ (arguments
+ `(#:asd-file "gobject/cl-cffi-gtk-gobject.asd"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "gobject/gobject.init.lisp"
+ (("libgobject" all) (string-append
+ (assoc-ref inputs "glib") "/lib/" all))))))))))
+
+(define-public sbcl-cl-cffi-gtk-gio
+ (package
+ (inherit sbcl-cl-cffi-gtk-boot0)
+ (name "sbcl-cl-cffi-gtk-gio")
+ (inputs
+ `(("glib" ,glib)
+ ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
+ ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
+ ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
+ (arguments
+ `(#:asd-file "gio/cl-cffi-gtk-gio.asd"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "gio/gio.init.lisp"
+ (("libgio" all)
+ (string-append
+ (assoc-ref inputs "glib") "/lib/" all))))))))))
+
+(define-public sbcl-cl-cffi-gtk-cairo
+ (package
+ (inherit sbcl-cl-cffi-gtk-boot0)
+ (name "sbcl-cl-cffi-gtk-cairo")
+ (inputs
+ `(("cairo" ,cairo)
+ ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
+ ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
+ (arguments
+ `(#:asd-file "cairo/cl-cffi-gtk-cairo.asd"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "cairo/cairo.init.lisp"
+ (("libcairo" all)
+ (string-append
+ (assoc-ref inputs "cairo") "/lib/" all))))))))))
+
+(define-public sbcl-cl-cffi-gtk-pango
+ (package
+ (inherit sbcl-cl-cffi-gtk-boot0)
+ (name "sbcl-cl-cffi-gtk-pango")
+ (inputs
+ `(("pango" ,pango)
+ ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
+ ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
+ ("cl-cffi-gtk-cairo" ,sbcl-cl-cffi-gtk-cairo)
+ ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
+ (arguments
+ `(#:asd-file "pango/cl-cffi-gtk-pango.asd"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "pango/pango.init.lisp"
+ (("libpango" all)
+ (string-append
+ (assoc-ref inputs "pango") "/lib/" all))))))))))
+
+(define-public sbcl-cl-cffi-gtk-gdk-pixbuf
+ (package
+ (inherit sbcl-cl-cffi-gtk-boot0)
+ (name "sbcl-cl-cffi-gtk-gdk-pixbuf")
+ (inputs
+ `(("gdk-pixbuf" ,gdk-pixbuf)
+ ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
+ ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
+ (arguments
+ `(#:asd-file "gdk-pixbuf/cl-cffi-gtk-gdk-pixbuf.asd"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "gdk-pixbuf/gdk-pixbuf.init.lisp"
+ (("libgdk_pixbuf" all)
+ (string-append
+ (assoc-ref inputs "gdk-pixbuf") "/lib/" all))))))))))
+
+(define-public sbcl-cl-cffi-gtk-gdk
+ (package
+ (inherit sbcl-cl-cffi-gtk-boot0)
+ (name "sbcl-cl-cffi-gtk-gdk")
+ (inputs
+ `(("gtk" ,gtk+)
+ ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
+ ("cl-cffi-gtk-gio" ,sbcl-cl-cffi-gtk-gio)
+ ("cl-cffi-gtk-gdk-pixbuf" ,sbcl-cl-cffi-gtk-gdk-pixbuf)
+ ("cl-cffi-gtk-cairo" ,sbcl-cl-cffi-gtk-cairo)
+ ("cl-cffi-gtk-pango" ,sbcl-cl-cffi-gtk-pango)
+ ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
+ (arguments
+ `(#:asd-file "gdk/cl-cffi-gtk-gdk.asd"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "gdk/gdk.init.lisp"
+ (("libgdk" all)
+ (string-append
+ (assoc-ref inputs "gtk") "/lib/" all)))
+ (substitute* "gdk/gdk.package.lisp"
+ (("libgtk" all)
+ (string-append
+ (assoc-ref inputs "gtk") "/lib/" all))))))))))
+
+(define-public sbcl-cl-cffi-gtk
+ (package
+ (inherit sbcl-cl-cffi-gtk-boot0)
+ (name "sbcl-cl-cffi-gtk")
+ (inputs
+ `(("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
+ ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
+ ("cl-cffi-gtk-gio" ,sbcl-cl-cffi-gtk-gio)
+ ("cl-cffi-gtk-gdk" ,sbcl-cl-cffi-gtk-gdk)
+ ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (arguments
+ `(#:asd-file "gtk/cl-cffi-gtk.asd"
+ #:test-asd-file "test/cl-cffi-gtk-test.asd"
+ ;; TODO: Tests fail with memory fault.
+ ;; See https://github.com/Ferada/cl-cffi-gtk/issues/24.
+ #:tests? #f))))
+
+(define-public cl-cffi-gtk
+ (sbcl-package->cl-source-package sbcl-cl-cffi-gtk))
+
+(define-public sbcl-cl-webkit
+ (let ((commit "cd2a9008e0c152e54755e8a7f07b050fe36bab31"))
+ (package
+ (name "sbcl-cl-webkit")
+ (version (git-version "2.4" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/jmercouris/cl-webkit")
+ (commit commit)))
+ (file-name (git-file-name "cl-webkit" version))
+ (sha256
+ (base32
+ "0f5lyn9i7xrn3g1bddga377mcbawkbxydijpg389q4n04gqj0vwf"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("cffi" ,sbcl-cffi)
+ ("cl-cffi-gtk" ,sbcl-cl-cffi-gtk)
+ ("webkitgtk" ,webkitgtk)))
+ (arguments
+ `(#:asd-file "webkit2/cl-webkit2.asd"
+ #:asd-system-name "cl-webkit2"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "webkit2/webkit2.init.lisp"
+ (("libwebkit2gtk" all)
+ (string-append
+ (assoc-ref inputs "webkitgtk") "/lib/" all))))))))
+ (home-page "https://github.com/jmercouris/cl-webkit")
+ (synopsis "Binding to WebKitGTK+ for Common Lisp")
+ (description
+ "@command{cl-webkit} is a binding to WebKitGTK+ for Common Lisp,
+currently targeting WebKit version 2. The WebKitGTK+ library adds web
+browsing capabilities to an application, leveraging the full power of the
+WebKit browsing engine.")
+ (license license:expat))))
+
+(define-public cl-webkit
+ (sbcl-package->cl-source-package sbcl-cl-webkit))
+
+(define-public sbcl-lparallel
+ (package
+ (name "sbcl-lparallel")
+ (version "2.8.4")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/lmj/lparallel/")
+ (commit (string-append "lparallel-" version))))
+ (file-name (git-file-name "lparallel" version))
+ (sha256
+ (base32
+ "0g0aylrbbrqsz0ahmwhvnk4cmc2931fllbpcfgzsprwnqqd7vwq9"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("trivial-garbage" ,sbcl-trivial-garbage)))
+ (home-page "https://lparallel.org/")
+ (synopsis "Parallelism for Common Lisp")
+ (description
+ "@command{lparallel} is a library for parallel programming in Common
+Lisp, featuring:
+
+@itemize
+@item a simple model of task submission with receiving queue,
+@item constructs for expressing fine-grained parallelism,
+@item asynchronous condition handling across thread boundaries,
+@item parallel versions of map, reduce, sort, remove, and many others,
+@item promises, futures, and delayed evaluation constructs,
+@item computation trees for parallelizing interconnected tasks,
+@item bounded and unbounded FIFO queues,
+@item high and low priority tasks,
+@item task killing by category,
+@item integrated timeouts.
+@end itemize\n")
+ (license license:expat)))
+
+(define-public cl-lparallel
+ (sbcl-package->cl-source-package sbcl-lparallel))
+
+(define-public ecl-lparallel
+ (sbcl-package->ecl-package sbcl-lparallel))
+
+(define-public sbcl-cl-markup
+ (let ((commit "e0eb7debf4bdff98d1f49d0f811321a6a637b390"))
+ (package
+ (name "sbcl-cl-markup")
+ (version (git-version "0.1" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/arielnetworks/cl-markup/")
+ (commit commit)))
+ (file-name (git-file-name "cl-markup" version))
+ (sha256
+ (base32
+ "10l6k45971dl13fkdmva7zc6i453lmq9j4xax2ci6pjzlc6xjhp7"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/arielnetworks/cl-markup/")
+ (synopsis "Markup generation library for Common Lisp")
+ (description
+ "A modern markup generation library for Common Lisp that features:
+
+@itemize
+@item Fast (even faster through compiling the code)
+@item Safety
+@item Support for multiple document types (markup, xml, html, html5, xhtml)
+@item Output with doctype
+@item Direct output to stream
+@end itemize\n")
+ (license license:lgpl3+))))
+
+(define-public cl-markup
+ (sbcl-package->cl-source-package sbcl-cl-markup))
+
+(define-public ecl-cl-markup
+ (sbcl-package->ecl-package sbcl-cl-markup))
+
+(define-public sbcl-cl-css
+ (let ((commit "8fe654c8f0cf95b300718101cce4feb517f78e2f"))
+ (package
+ (name "sbcl-cl-css")
+ (version (git-version "0.1" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/inaimathi/cl-css/")
+ (commit commit)))
+ (file-name (git-file-name "cl-css" version))
+ (sha256
+ (base32
+ "1lc42zi2sw11fl2589sc19nr5sd2p0wy7wgvgwaggxa5f3ajhsmd"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/inaimathi/cl-css/")
+ (synopsis "Non-validating, inline CSS generator for Common Lisp")
+ (description
+ "This is a dead-simple, non validating, inline CSS generator for Common
+Lisp. Its goals are axiomatic syntax, simple implementation to support
+portability, and boilerplate reduction in CSS.")
+ (license license:expat))))
+
+(define-public cl-css
+ (sbcl-package->cl-source-package sbcl-cl-css))
+
+(define-public ecl-cl-css
+ (sbcl-package->ecl-package sbcl-cl-css))
+
+(define-public sbcl-portable-threads
+ (let ((commit "c0e61a1faeb0583c80fd3f20b16cc4c555226920"))
+ (package
+ (name "sbcl-portable-threads")
+ (version (git-version "2.3" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/binghe/portable-threads/")
+ (commit commit)))
+ (file-name (git-file-name "portable-threads" version))
+ (sha256
+ (base32
+ "03fmxyarc0xf4kavwkfa0a2spkyfrz6hbgbi9y4q7ny5aykdyfaq"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ `(;; Tests seem broken.
+ #:tests? #f))
+ (home-page "https://github.com/binghe/portable-threads")
+ (synopsis "Portable threads (and scheduled and periodic functions) API for Common Lisp")
+ (description
+ "Portable Threads (and Scheduled and Periodic Functions) API for Common
+Lisp (from GBBopen project).")
+ (license license:asl2.0))))
+
+(define-public cl-portable-threads
+ (sbcl-package->cl-source-package sbcl-portable-threads))
+
+(define-public ecl-portable-threada
+ (sbcl-package->ecl-package sbcl-portable-threads))
+
+(define-public sbcl-usocket-boot0
+ ;; usocket's test rely on usocket-server which depends on usocket itself.
+ ;; We break this cyclic dependency with -boot0 that packages usocket.
+ (let ((commit "86e7efbfe50101931edf4b67cdcfa7e221ecfde9"))
+ (package
+ (name "sbcl-usocket-boot0")
+ (version (git-version "0.7.1" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/usocket/usocket/")
+ (commit commit)))
+ (file-name (git-file-name "usocket" version))
+ (sha256
+ (base32
+ "1lk6ipakrib7kdgzw44hrgmls9akp5pz4h35yynw0k5zwmmq6374"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("split-sequence" ,sbcl-split-sequence)))
+ (arguments
+ `(#:tests? #f
+ #:asd-system-name "usocket"))
+ (home-page "https://common-lisp.net/project/usocket/")
+ (synopsis "Universal socket library for Common Lisp (server side)")
+ (description
+ "This library strives to provide a portable TCP/IP and UDP/IP socket
+interface for as many Common Lisp implementations as possible, while keeping
+the abstraction and portability layer as thin as possible.")
+ (license license:expat))))
+
+(define-public sbcl-usocket-server
+ (package
+ (inherit sbcl-usocket-boot0)
+ (name "sbcl-usocket-server")
+ (inputs
+ `(("usocket" ,sbcl-usocket-boot0)
+ ("portable-threads" ,sbcl-portable-threads)))
+ (arguments
+ '(#:asd-system-name "usocket-server"))
+ (synopsis "Universal socket library for Common Lisp (server side)")))
+
+(define-public cl-usocket-server
+ (sbcl-package->cl-source-package sbcl-usocket-server))
+
+(define-public ecl-socket-server
+ (sbcl-package->ecl-package sbcl-usocket-server))
+
+(define-public sbcl-usocket
+ (package
+ (inherit sbcl-usocket-boot0)
+ (name "sbcl-usocket")
+ (arguments
+ ;; FIXME: Tests need network access?
+ `(#:tests? #f))
+ (native-inputs
+ ;; Testing only.
+ `(("usocket-server" ,sbcl-usocket-server)
+ ("rt" ,sbcl-rt)))))
+
+(define-public cl-usocket
+ (sbcl-package->cl-source-package sbcl-usocket))
+
+(define-public ecl-socket
+ (sbcl-package->ecl-package sbcl-usocket))
+
+(define-public sbcl-s-xml
+ (package
+ (name "sbcl-s-xml")
+ (version "3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri "https://common-lisp.net/project/s-xml/s-xml.tgz")
+ (sha256
+ (base32
+ "061qcr0dzshsa38s5ma4ay924cwak2nq9gy59dw6v9p0qb58nzjf"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://common-lisp.net/project/s-xml/")
+ (synopsis "Simple XML parser implemented in Common Lisp")
+ (description
+ "S-XML is a simple XML parser implemented in Common Lisp. This XML
+parser implementation has the following features:
+
+@itemize
+@item It works (handling many common XML usages).
+@item It is very small (the core is about 700 lines of code, including
+comments and whitespace).
+@item It has a core API that is simple, efficient and pure functional, much
+like that from SSAX (see also http://ssax.sourceforge.net).
+@item It supports different DOM models: an XSML-based one, an LXML-based one
+and a classic xml-element struct based one.
+@item It is reasonably time and space efficient (internally avoiding garbage
+generatation as much as possible).
+@item It does support CDATA.
+@item It should support the same character sets as your Common Lisp
+implementation.
+@item It does support XML name spaces.
+@end itemize
+
+This XML parser implementation has the following limitations:
+
+@itemize
+@item It does not support any special tags (like processing instructions).
+@item It is not validating, even skips DTD's all together.
+@end itemize\n")
+ (license license:lgpl3+)))
+
+(define-public cl-s-xml
+ (sbcl-package->cl-source-package sbcl-s-xml))
+
+(define-public ecl-s-xml
+ (sbcl-package->ecl-package sbcl-s-xml))
+
+(define-public sbcl-s-xml-rpc
+ (package
+ (name "sbcl-s-xml-rpc")
+ (version "7")
+ (source
+ (origin
+ (method url-fetch)
+ (uri "https://common-lisp.net/project/s-xml-rpc/s-xml-rpc.tgz")
+ (sha256
+ (base32
+ "02z7k163d51v0pzk8mn1xb6h5s6x64gjqkslhwm3a5x26k2gfs11"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("s-xml" ,sbcl-s-xml)))
+ (home-page "https://common-lisp.net/project/s-xml-rpc/")
+ (synopsis "Implementation of XML-RPC in Common Lisp for both client and server")
+ (description
+ "S-XML-RPC is an implementation of XML-RPC in Common Lisp for both
+client and server.")
+ (license license:lgpl3+)))
+
+(define-public cl-s-xml-rpc
+ (sbcl-package->cl-source-package sbcl-s-xml-rpc))
+
+(define-public ecl-s-xml-rpc
+ (sbcl-package->ecl-package sbcl-s-xml-rpc))
+
+(define-public sbcl-trivial-clipboard
+ (let ((commit "5af3415d1484e6d69a1b5c178f24680d9fd01796"))
+ (package
+ (name "sbcl-trivial-clipboard")
+ (version (git-version "0.0.0.0" "2" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/snmsts/trivial-clipboard")
+ (commit commit)))
+ (file-name (git-file-name "trivial-clipboard" version))
+ (sha256
+ (base32
+ "1gb515z5yq6h5548pb1fwhmb0hhq1ssyb78pvxh4alq799xipxs9"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("xclip" ,xclip)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/text.lisp"
+ (("\\(executable-find \"xclip\"\\)")
+ (string-append "(executable-find \""
+ (assoc-ref inputs "xclip")
+ "/bin/xclip\")"))))))))
+ (home-page "https://github.com/snmsts/trivial-clipboard")
+ (synopsis "Access system clipboard in Common Lisp")
+ (description
+ "@command{trivial-clipboard} gives access to the system clipboard.")
+ (license license:expat))))
+
+(define-public cl-trivial-clipboard
+ (sbcl-package->cl-source-package sbcl-trivial-clipboard))
+
+(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)))
+ (file-name (git-file-name "trivial-backtrace" version))
+ (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. @code{trivial-backtrace} is a simple solution to generating a
+backtrace portably.")
+ (license license:expat))))
+
+(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)))
+ (file-name (git-file-name "rfc2388" version))
+ (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-md5
+ (package
+ (name "sbcl-md5")
+ (version "2.0.4")
+ (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)
+ (home-page "https://github.com/pmai/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.")
+ (license license:public-domain)))
+
+(define-public cl-md5
+ (sbcl-package->cl-source-package sbcl-md5))
+
+(define-public sbcl-cl+ssl
+ (let ((commit "141ae91416bc40f1618dc07e48429b84388aa599")
+ (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)))
+ (file-name (git-file-name "cl+ssl" version))
+ (sha256
+ (base32 "1s0hg1h9sf8q89v0yrxmzg5f5sng29rgx3n21r9h9yql8351myan"))))
+ (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))))))))
+ (inputs
+ `(("openssl" ,openssl)
+ ("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)
+ ("sbcl-alexandria" ,sbcl-alexandria)
+ ("sbcl-trivial-features" ,sbcl-trivial-features)))
+ (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))
+
+(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)))
+ (file-name (git-file-name name version))
+ (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 "General utilities for Common Lisp programs")
+ (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))
+
+(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))))
+ (file-name (git-file-name "cl-base64" 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-base64
+ (sbcl-package->cl-source-package sbcl-cl-base64))
+
+(define-public sbcl-chunga
+ (package
+ (name "sbcl-chunga")
+ (version "1.1.7")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/edicl/chunga.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0jzn3nyb3f22gm983rfk99smqs3mhb9ivjmasvhq9qla5cl9pyhd"))))
+ (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))
+
+(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))
+
+(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
+ "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))
+
+(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))
+
+(define-public sbcl-hunchentoot
+ (package
+ (name "sbcl-hunchentoot")
+ (version "1.2.38")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/edicl/hunchentoot.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "hunchentoot" version))
+ (sha256
+ (base32 "1anpcad7w045m4rsjs1f3xdhjwx5cppq1h0vlb3q7dz81fi3i6yq"))))
+ (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))
+
+(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")))
+ (file-name (git-file-name name version))
+ (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))
+
+(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")))
+ (file-name (git-file-name "cl-syntax" version))
+ (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-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)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1wq1gs9jjd5m6iwrv06c2d7i5dvqsfjcljgbspfbc93cg5xahk4n"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-file "cl-annot.asd"
+ #:asd-system-name "cl-annot"))
+ (inputs
+ `(("sbcl-alexandria" ,sbcl-alexandria)))
+ (home-page "https://github.com/m2ym/cl-annot")
+ (synopsis "Python-like Annotation Syntax for Common Lisp.")
+ (description
+ "@code{cl-annot} is an general annotation library for Common Lisp.")
+ (license license:llgpl))))
+
+(define-public 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")))
+ (file-name (git-file-name name version))
+ (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-syntax-annot
+ (sbcl-package->cl-source-package sbcl-cl-syntax-annot))
+
+(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
+ '(#:asd-file "cl-utilities.asd"
+ #:asd-system-name "cl-utilities"
+ #: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-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 "Set-like data structure")
+ (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))
+
+(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)))
+ (file-name (git-file-name name version))
+ (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))
+
+(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)))
+ (file-name (git-file-name "myway" version))
+ (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))
+
+(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)))
+ (file-name (git-file-name name version))
+ (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))
+
+(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)))
+ (file-name (git-file-name name version))
+ (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))
+
+(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)))
+ (file-name (git-file-name name version))
+ (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 "HTTP request/response parser for Common Lisp")
+ (description
+ "@code{fast-http} is a 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))
+
+(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)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "138nlsq14hv8785ycjm6jw3i6ablhq8vcwys7q09y80arcgrg6r3"))))
+ (native-inputs
+ `(("sbcl-fiveam" ,sbcl-fiveam)))
+ (inputs
+ `(("sbcl-cffi-grovel" ,sbcl-cffi-grovel)
+ ("sbcl-cffi" ,sbcl-cffi)))
+ (build-system asdf-build-system/sbcl)
+ (home-page "http://common-lisp.net/projects/iolib/")
+ (synopsis "Allocate SIMPLE-ARRAYs in static memory")
+ (description
+ "With @code{static-vectors}, you can create vectors allocated in static
+memory.")
+ (license license:expat))))
+
+(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)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "08qs6fhk38xpkkjkpcj92mxx0lgy4ygrbbzrmnivdx281syr0gwh"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/wlbr/cl-marshal")
+ (synopsis "Simple (de)serialization of Lisp datastructures")
+ (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.")
+ (license license:expat))))
+
+(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)))
+ (file-name (git-file-name name version))
+ (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 "Dynamic testing for Common Lisp")
+ (description
+ "CheckL lets you write tests dynamically, it checks resulting values
+against the last run.")
+ ;; 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))
+
+(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)))
+ (file-name (git-file-name name version))
+ (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))
+
+(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)))
+ (file-name (git-file-name name version))
+ (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
+ "High performance JSON encoder and decoder. Currently support: SBCL,
+CCL.")
+ ;; Author specifies the MIT license
+ (license license:expat))))
+
+(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)))
+ (file-name (git-file-name name version))
+ (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))
+
+(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)))
+ (file-name (git-file-name name version))
+ (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))
+
+(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)))
+ (file-name (git-file-name "lack-request" version))
+ (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"
+ ;; XXX: Component :CLACK-TEST not found
+ #: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))
+
+(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)))
+ (file-name (git-file-name name version))
+ (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\".")
+ (license license:expat))))
+
+(define-public cl-local-time
+ (sbcl-package->cl-source-package sbcl-local-time))
+
+(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)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-file "lack-response.asd"
+ #:asd-system-name "lack-response"
+ ;; XXX: no tests for lack-response.
+ #: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))
+
+(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)))
+ (file-name (git-file-name "lack-component" version))
+ (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"
+ ;; XXX: Component :LACK-TEST not found
+ #:tests? #f))
+ (native-inputs
+ `(("prove-asdf" ,sbcl-prove-asdf)))
+ (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))
+
+(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)))
+ (file-name (git-file-name "lack-util" version))
+ (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"
+ ;; XXX: Component :LACK-TEST not found
+ #:tests? #f))
+ (native-inputs
+ `(("prove-asdf" ,sbcl-prove-asdf)))
+ (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))
+
+(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)))
+ (file-name (git-file-name "lack-middleware-backtrace" version))
+ (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"
+ ;; XXX: Component :LACK not found
+ #:tests? #f))
+ (native-inputs
+ `(("prove-asdf" ,sbcl-prove-asdf)))
+ (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))
+
+(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)))
+ (file-name (git-file-name name version))
+ (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/" (%lisp-type)
+ "-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))
+
+(define-public ecl-trivial-mimes
+ (sbcl-package->ecl-package sbcl-trivial-mimes))
+
+(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)))
+ (file-name (git-file-name "lack-middleware-static" version))
+ (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"
+ ;; XXX: Component :LACK not found
+ #:tests? #f))
+ (native-inputs
+ `(("prove-asdf" ,sbcl-prove-asdf)))
+ (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))
+
+(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)))
+ (file-name (git-file-name "lack" version))
+ (sha256
+ (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:test-asd-file "t-lack.asd"
+ ;; XXX: Component :CLACK not found
+ #:tests? #f))
+ (native-inputs
+ `(("prove-asdf" ,sbcl-prove-asdf)))
+ (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))
+
+(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)))
+ (file-name (git-file-name name version))
+ (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)
+ #t)))))
+ (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))
+
+(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)))
+ (file-name (git-file-name name version))
+ (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 "Web Application Environment for Common Lisp")
+ (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))
+
+(define-public sbcl-log4cl
+ (let ((commit "611e094458504b938d49de904eab141285328c7c")
+ (revision "1"))
+ (package
+ (name "sbcl-log4cl")
+ (build-system asdf-build-system/sbcl)
+ (version "1.1.2")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sharplispers/log4cl")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "08jly0s0g26b56hhpfizxsb4j0yvbh946sd205gr42dkzv8l7dsc"))))
+ ;; FIXME: tests require stefil, sbcl-hu.dwim.stefil wont work
+ (arguments
+ `(#:tests? #f))
+ (inputs `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
+ (synopsis "Common Lisp logging framework, modeled after Log4J")
+ (home-page "https://github.com/7max/log4cl")
+ (description "This is a Common Lisp logging framework that can log at
+various levels and mix text with expressions.")
+ (license license:asl2.0))))
+
+(define-public cl-log4cl
+ (sbcl-package->cl-source-package sbcl-log4cl))
+
+(define-public ecl-log4cl
+ (sbcl-package->ecl-package sbcl-log4cl))
+
+(define-public sbcl-find-port
+ (let ((commit "00c96a25af93a0f8681d34ec548861f2d7485478")
+ (revision "1"))
+ (package
+ (name "sbcl-find-port")
+ (build-system asdf-build-system/sbcl)
+ (version "0.1")
+ (home-page "https://github.com/eudoxia0/find-port")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0d6dzbb45jh0rx90wgs6v020k2xa87mvzas3mvfzvivjvqqlpryq"))))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (inputs
+ `(("sbcl-usocket" ,sbcl-usocket)))
+ (synopsis "Find open ports programmatically in Common Lisp")
+ (description "This is a small Common Lisp library that finds an open
+port within a range.")
+ (license license:expat))))
+
+(define-public cl-find-port
+ (sbcl-package->cl-source-package sbcl-find-port))
+
+(define-public ecl-find-port
+ (sbcl-package->ecl-package sbcl-find-port))
+
(define-public txr
(package
(name "txr")
@@ -781,3 +5469,2626 @@ command line, to data scanning and extracting scripts, to full application
development in a wide-range of areas.")
(home-page "https://nongnu.org/txr/")
(license license:bsd-2)))
+
+(define-public sbcl-clunit
+ (let ((commit "6f6d72873f0e1207f037470105969384f8380628")
+ (revision "1"))
+ (package
+ (name "sbcl-clunit")
+ (version (git-version "0.2.3" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/tgutu/clunit.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1idf2xnqzlhi8rbrqmzpmb3i1l6pbdzhhajkmhwbp6qjkmxa4h85"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "CLUnit is a Common Lisp unit testing framework")
+ (description
+ "CLUnit is a Common Lisp unit testing framework. It is designed
+to be easy to use so that you can quickly start testing. CLUnit
+provides a rich set of features aimed at improving your unit testing
+experience.")
+ (home-page "http://tgutu.github.io/clunit/")
+ ;; MIT License
+ (license license:expat))))
+
+(define-public cl-clunit
+ (sbcl-package->cl-source-package sbcl-clunit))
+
+(define-public ecl-clunit
+ (sbcl-package->ecl-package sbcl-clunit))
+
+(define-public sbcl-py4cl
+ (let ((commit "4c8a2b0814fd311f978964f825ce012290f60136")
+ (revision "1"))
+ (package
+ (name "sbcl-py4cl")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/bendudson/py4cl.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "15mk7qdqjkj56gdnbyrdyz6r7m1h26ldvn6ch96pmvg5vmr1m45r"))
+ (modules '((guix build utils)))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("sbcl-clunit" ,sbcl-clunit)))
+ (inputs
+ `(("sbcl-trivial-garbage" ,sbcl-trivial-garbage)))
+ (propagated-inputs
+ ;; This package doesn't do anything without python available
+ `(("python" ,python)
+ ;; For multi-dimensional array support
+ ("python-numpy" ,python-numpy)))
+ (arguments
+ '(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'replace-*base-directory*-var
+ (lambda* (#:key outputs #:allow-other-keys)
+ ;; In the ASD, the author makes an attempt to
+ ;; programatically determine the location of the
+ ;; source-code so lisp can call into "py4cl.py". We can
+ ;; hard-code this since we know where this file will
+ ;; reside.
+ (substitute* "src/callpython.lisp"
+ (("py4cl/config:\\*base-directory\\*")
+ (string-append
+ "\""
+ (assoc-ref outputs "out")
+ "/share/common-lisp/sbcl-source/py4cl/"
+ "\""))))))))
+ (synopsis "Call python from Common Lisp")
+ (description
+ "Py4CL is a bridge between Common Lisp and Python, which enables Common
+Lisp to interact with Python code. It uses streams to communicate with a
+separate python process, the approach taken by cl4py. This is different to
+the CFFI approach used by burgled-batteries, but has the same goal.")
+ (home-page "https://github.com/bendudson/py4cl")
+ ;; MIT License
+ (license license:expat))))
+
+(define-public cl-py4cl
+ (sbcl-package->cl-source-package sbcl-py4cl))
+
+(define-public ecl-py4cl
+ (sbcl-package->ecl-package sbcl-py4cl))
+
+(define-public sbcl-parse-declarations
+ (package
+ (name "sbcl-parse-declarations")
+ (version "1.0.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://beta.quicklisp.org/archive/parse-declarations/"
+ "2010-10-06/parse-declarations-20101006-darcs.tgz"))
+ (sha256
+ (base32
+ "0r85b0jfacd28kr65kw9c13dx4i6id1dpmby68zjy63mqbnyawrd"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:asd-file "parse-declarations-1.0.asd"
+ #:asd-system-name "parse-declarations-1.0"))
+ (home-page "https://common-lisp.net/project/parse-declarations/")
+ (synopsis "Parse, filter, and build declarations")
+ (description
+ "Parse-Declarations is a Common Lisp library to help writing
+macros which establish bindings. To be semantically correct, such
+macros must take user declarations into account, as these may affect
+the bindings they establish. Yet the ANSI standard of Common Lisp does
+not provide any operators to work with declarations in a convenient,
+high-level way. This library provides such operators.")
+ ;; MIT License
+ (license license:expat)))
+
+(define-public cl-parse-declarations
+ (sbcl-package->cl-source-package sbcl-parse-declarations))
+
+(define-public ecl-parse-declarations
+ (sbcl-package->ecl-package sbcl-parse-declarations))
+
+(define-public sbcl-cl-quickcheck
+ (let ((commit "807b2792a30c883a2fbecea8e7db355b50ba662f")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-quickcheck")
+ (version (git-version "0.0.4" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/mcandre/cl-quickcheck.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "165lhypq5xkcys6hvzb3jq7ywnmqvzaflda29qk2cbs3ggas4767"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis
+ "Common Lisp port of the QuickCheck unit test framework")
+ (description
+ "Common Lisp port of the QuickCheck unit test framework")
+ (home-page "https://github.com/mcandre/cl-quickcheck")
+ ;; MIT
+ (license license:expat))))
+
+(define-public cl-cl-quickcheck
+ (sbcl-package->cl-source-package sbcl-cl-quickcheck))
+
+(define-public ecl-cl-quickcheck
+ (sbcl-package->ecl-package sbcl-cl-quickcheck))
+
+(define-public sbcl-burgled-batteries3
+ (let ((commit "9c0f6667e1a71ddf77e21793a0bea524710fef6e")
+ (revision "1"))
+ (package
+ (name "sbcl-burgled-batteries3")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/snmsts/burgled-batteries3.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0b726kz2xxcg5l930gz035rsdvhxrzmp05iwfwympnb4z4ammicb"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:tests? #f
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'set-*cpython-include-dir*-var
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "grovel-include-dir.lisp"
+ (("\\(defparameter \\*cpython-include-dir\\* \\(detect-python\\)\\)")
+ (string-append
+ "(defparameter *cpython-include-dir* \""
+ (assoc-ref inputs "python")
+ "/include/python3.7m"
+ "\")")))
+ (substitute* "ffi-interface.lisp"
+ (("\\*cpython-lib\\*")
+ (format #f "'(\"~a/lib/libpython3.so\")"
+ (assoc-ref inputs "python"))))
+ #t)))))
+ (native-inputs
+ `(("python" ,python)
+ ("sbcl-cl-fad" ,sbcl-cl-fad)
+ ("sbcl-lift" ,sbcl-lift)
+ ("sbcl-cl-quickcheck" ,sbcl-cl-quickcheck)))
+ (inputs
+ `(("sbcl-cffi" ,sbcl-cffi)
+ ("sbcl-cffi-grovel" ,sbcl-cffi-grovel)
+ ("sbcl-alexandria" , sbcl-alexandria)
+ ("sbcl-parse-declarations-1.0" ,sbcl-parse-declarations)
+ ("sbcl-trivial-garbage" ,sbcl-trivial-garbage)))
+ (synopsis "Bridge between Python and Lisp (FFI bindings, etc.)")
+ (description
+ "This package provides a shim between Python3 (specifically, the
+CPython implementation of Python) and Common Lisp.")
+ (home-page "https://github.com/snmsts/burgled-batteries3")
+ ;; MIT
+ (license license:expat))))
+
+(define-public cl-burgled-batteries3
+ (sbcl-package->cl-source-package sbcl-burgled-batteries3))
+
+(define-public ecl-burgled-batteries3
+ (sbcl-package->ecl-package sbcl-burgled-batteries3))
+
+(define-public sbcl-metabang-bind
+ (let ((commit "c93b7f7e1c18c954c2283efd6a7fdab36746ab5e")
+ (revision "1"))
+ (package
+ (name "sbcl-metabang-bind")
+ (version (git-version "0.8.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/gwkkwg/metabang-bind.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0hd0kr91795v77akpbcyqiss9p0p7ypa9dznrllincnmgvsxlmf0"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("sbcl-lift" ,sbcl-lift)))
+ (synopsis "Macro that generalizes @code{multiple-value-bind} etc.")
+ (description
+ "Bind extends the idea of of let and destructing to provide a uniform
+syntax for all your accessor needs. It combines @code{let},
+@code{destructuring-bind}, @code{with-slots}, @code{with-accessors}, structure
+editing, property or association-lists, and @code{multiple-value-bind} and a
+whole lot more into a single form.")
+ (home-page "https://common-lisp.net/project/metabang-bind/")
+ ;; MIT License
+ (license license:expat))))
+
+(define-public cl-metabang-bind
+ (sbcl-package->cl-source-package sbcl-metabang-bind))
+
+(define-public ecl-metabang-bind
+ (sbcl-package->ecl-package sbcl-metabang-bind))
+
+(define-public sbcl-fare-utils
+ (let ((commit "66e9c6f1499140bc00ccc22febf2aa528cbb5724")
+ (revision "1"))
+ (package
+ (name "sbcl-fare-utils")
+ (version (git-version "1.0.0.5" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri
+ (git-reference
+ (url
+ "https://gitlab.common-lisp.net/frideau/fare-utils.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "01wsr1aap3jdzhn4hrqjbhsjx6qci9dbd3gh4gayv1p49rbg8aqr"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:test-asd-file "test/fare-utils-test.asd"))
+ (native-inputs
+ `(("sbcl-hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
+ (synopsis "Collection of utilities and data structures")
+ (description
+ "fare-utils is a small collection of utilities. It contains a lot of
+basic everyday functions and macros.")
+ (home-page "https://gitlab.common-lisp.net/frideau/fare-utils")
+ ;; MIT License
+ (license license:expat))))
+
+(define-public cl-fare-utils
+ (sbcl-package->cl-source-package sbcl-fare-utils))
+
+(define-public ecl-fare-utils
+ (sbcl-package->ecl-package sbcl-fare-utils))
+
+(define-public sbcl-trivial-utf-8
+ (let ((commit "4d427cfbb1c452436a0efb71c3205c9da67f718f")
+ (revision "1"))
+ (package
+ (name "sbcl-trivial-utf-8")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri
+ (git-reference
+ (url (string-append "https://gitlab.common-lisp.net/"
+ "trivial-utf-8/trivial-utf-8.git"))
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1jz27gz8gvqdmvp3k9bxschs6d5b3qgk94qp2bj6nv1d0jc3m1l1"))))
+ (arguments
+ ;; Guix incorrectly assumes the "8" is part of the version
+ ;; number and lobs it off.
+ `(#:asd-file "trivial-utf-8.asd"
+ #:asd-system-name "trivial-utf-8"))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "UTF-8 input/output library")
+ (description
+ "The Babel library solves a similar problem while understanding more
+encodings. Trivial UTF-8 was written before Babel existed, but for new
+projects you might be better off going with Babel. The one plus that Trivial
+UTF-8 has is that it doesn't depend on any other libraries.")
+ (home-page "https://common-lisp.net/project/trivial-utf-8/")
+ (license license:bsd-3))))
+
+(define-public cl-trivial-utf-8
+ (sbcl-package->cl-source-package sbcl-trivial-utf-8))
+
+(define-public ecl-trivial-utf-8
+ (sbcl-package->ecl-package sbcl-trivial-utf-8))
+
+(define-public sbcl-idna
+ (package
+ (name "sbcl-idna")
+ (build-system asdf-build-system/sbcl)
+ (version "0.2.2")
+ (home-page "https://github.com/antifuchs/idna")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit version)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "00nbr3mffxhlq14gg9d16pa6691s4qh35inyw76v906s77khm5a2"))))
+ (inputs
+ `(("split-sequence" ,sbcl-split-sequence)))
+ (synopsis "IDNA string encoding and decoding routines for Common Lisp")
+ (description "This Common Lisp library provides string encoding and
+decoding routines for IDNA, the International Domain Names in Applications.")
+ (license license:expat)))
+
+(define-public cl-idna
+ (sbcl-package->cl-source-package sbcl-idna))
+
+(define-public ecl-idna
+ (sbcl-package->ecl-package sbcl-idna))
+
+(define-public sbcl-swap-bytes
+ (package
+ (name "sbcl-swap-bytes")
+ (build-system asdf-build-system/sbcl)
+ (version "1.1")
+ (home-page "https://github.com/sionescu/swap-bytes")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1qysbv0jngdfkv53y874qjhcxc4qi8ixaqq6j8bzxh5z0931wv55"))))
+ (inputs
+ `(("trivial-features" ,sbcl-trivial-features)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (arguments
+ ;; TODO: Tests fail, why?
+ `(#:tests? #f))
+ (synopsis "Efficient endianness conversion for Common Lisp")
+ (description "This Common Lisp library provides optimized byte-swapping
+primitives. The library can change endianness of unsigned integers of length
+1/2/4/8. Very useful in implementing various network protocols and file
+formats.")
+ (license license:expat)))
+
+(define-public cl-swap-bytes
+ (sbcl-package->cl-source-package sbcl-swap-bytes))
+
+(define-public ecl-swap-bytes
+ (sbcl-package->ecl-package sbcl-swap-bytes))
+
+(define-public sbcl-iolib.asdf
+ ;; Latest release is from June 2017.
+ (let ((commit "81e20614c0d27f9605bf9766214e236fd31b99b4")
+ (revision "1"))
+ (package
+ (name "sbcl-iolib.asdf")
+ (build-system asdf-build-system/sbcl)
+ (version "0.8.3")
+ (home-page "https://github.com/sionescu/iolib")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1j81r0wm7nfbwl991f26s4npcy7kybzybd3m47rbxy31h0cfcmdm"))))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)))
+ (arguments
+ '(#:asd-file "iolib.asdf.asd"))
+ (synopsis "ASDF component classes for IOLib, a Common Lisp I/O library")
+ (description "IOlib is to be a better and more modern I/O library than
+the standard Common Lisp library. It contains a socket library, a DNS
+resolver, an I/O multiplexer(which supports @code{select(2)}, @code{epoll(4)}
+and @code{kqueue(2)}), a pathname library and file-system utilities.")
+ (license license:expat))))
+
+(define-public sbcl-iolib.conf
+ (package
+ (inherit sbcl-iolib.asdf)
+ (name "sbcl-iolib.conf")
+ (inputs
+ `(("iolib.asdf" ,sbcl-iolib.asdf)))
+ (arguments
+ '(#:asd-file "iolib.conf.asd"))
+ (synopsis "Compile-time configuration for IOLib, a Common Lisp I/O library")))
+
+(define-public sbcl-iolib.common-lisp
+ (package
+ (inherit sbcl-iolib.asdf)
+ (name "sbcl-iolib.common-lisp")
+ (inputs
+ `(("iolib.asdf" ,sbcl-iolib.asdf)
+ ("iolib.conf" ,sbcl-iolib.conf)))
+ (arguments
+ '(#:asd-file "iolib.common-lisp.asd"))
+ (synopsis "Slightly modified Common Lisp for IOLib, a Common Lisp I/O library")))
+
+(define-public sbcl-iolib.base
+ (package
+ (inherit sbcl-iolib.asdf)
+ (name "sbcl-iolib.base")
+ (inputs
+ `(("iolib.asdf" ,sbcl-iolib.asdf)
+ ("iolib.conf" ,sbcl-iolib.conf)
+ ("iolib.common-lisp" ,sbcl-iolib.common-lisp)
+ ("split-sequence" ,sbcl-split-sequence)))
+ (arguments
+ '(#:asd-file "iolib.base.asd"))
+ (synopsis "Base package for IOLib, a Common Lisp I/O library")))
+
+(define-public sbcl-iolib.grovel
+ (package
+ (inherit sbcl-iolib.asdf)
+ (name "sbcl-iolib.grovel")
+ (inputs
+ `(("iolib.asdf" ,sbcl-iolib.asdf)
+ ("iolib.conf" ,sbcl-iolib.conf)
+ ("iolib.base", sbcl-iolib.base)
+ ("cffi", sbcl-cffi)))
+ (arguments
+ '(#:asd-file "iolib.grovel.asd"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'install 'install-header
+ (lambda* (#:key outputs #:allow-other-keys)
+ ;; This header is required by sbcl-iolib.
+ (install-file "src/grovel/grovel-common.h"
+ (string-append (assoc-ref outputs "out")
+ "/lib/sbcl"))
+ #t)))))
+ (synopsis "CFFI Groveller for IOLib, a Common Lisp I/O library")))
+
+(define-public sbcl-iolib
+ (package
+ (inherit sbcl-iolib.asdf)
+ (name "sbcl-iolib")
+ (inputs
+ `(("iolib.asdf" ,sbcl-iolib.asdf)
+ ("iolib.conf" ,sbcl-iolib.conf)
+ ("iolib.grovel" ,sbcl-iolib.grovel)
+ ("iolib.base" ,sbcl-iolib.base)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("idna" ,sbcl-idna)
+ ("swap-bytes" ,sbcl-swap-bytes)
+ ("libfixposix" ,libfixposix)
+ ("cffi" ,sbcl-cffi)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (arguments
+ '(#:asd-file "iolib.asd"
+ #:asd-system-name "iolib"
+ #:test-asd-file "iolib.tests.asd"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/syscalls/ffi-functions-unix.lisp"
+ (("\\(:default \"libfixposix\"\\)")
+ (string-append
+ "(:default \""
+ (assoc-ref inputs "libfixposix") "/lib/libfixposix\")")))
+ ;; Socket tests need Internet access, disable them.
+ (substitute* "iolib.tests.asd"
+ (("\\(:file \"sockets\" :depends-on \\(\"pkgdcl\" \"defsuites\"\\)\\)")
+ "")))))))
+ (synopsis "Common Lisp I/O library")))
+
+(define-public cl-iolib
+ (sbcl-package->cl-source-package sbcl-iolib))
+
+(define sbcl-iolib+multiplex
+ (package
+ (inherit sbcl-iolib)
+ (name "sbcl-iolib+multiplex")
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-iolib)
+ ((#:asd-system-name _) "iolib/multiplex")))))
+
+(define sbcl-iolib+syscalls
+ (package
+ (inherit sbcl-iolib)
+ (name "sbcl-iolib+syscalls")
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-iolib)
+ ((#:asd-system-name _) "iolib/syscalls")))))
+
+(define sbcl-iolib+streams
+ (package
+ (inherit sbcl-iolib)
+ (name "sbcl-iolib+streams")
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-iolib)
+ ((#:asd-system-name _) "iolib/streams")))))
+
+(define sbcl-iolib+sockets
+ (package
+ (inherit sbcl-iolib)
+ (name "sbcl-iolib+sockets")
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-iolib)
+ ((#:asd-system-name _) "iolib/sockets")))))
+
+(define-public sbcl-ieee-floats
+ (let ((commit "566b51a005e81ff618554b9b2f0b795d3b29398d")
+ (revision "1"))
+ (package
+ (name "sbcl-ieee-floats")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "20170924" revision commit))
+ (home-page "https://github.com/marijnh/ieee-floats/")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1xyj49j9x3lc84cv3dhbf9ja34ywjk1c46dklx425fxw9mkwm83m"))))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (synopsis "IEEE 754 binary representation for floats in Common Lisp")
+ (description "This is a Common Lisp library that allows to convert
+floating point values to IEEE 754 binary representation.")
+ (license license:bsd-3))))
+
+(define-public cl-ieee-floats
+ (sbcl-package->cl-source-package sbcl-ieee-floats))
+
+(define sbcl-closure-common
+ (let ((commit "e3c5f5f454b72b01b89115e581c3c52a7e201e5c")
+ (revision "1"))
+ (package
+ (name "sbcl-closure-common")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "20101006" revision commit))
+ (home-page "https://common-lisp.net/project/cxml/")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sharplispers/closure-common")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0k5r2qxn122pxi301ijir3nayi9sg4d7yiy276l36qmzwhp4mg5n"))))
+ (inputs
+ `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)
+ ("babel" ,sbcl-babel)))
+ (synopsis "Support Common Lisp library for CXML")
+ (description "Closure-common is an internal helper library. The name
+Closure is a reference to the web browser it was originally written for.")
+ ;; TODO: License?
+ (license #f))))
+
+(define-public sbcl-cxml+xml
+ (let ((commit "00b22bf4c4cf11c993d5866fae284f95ab18e6bf")
+ (revision "1"))
+ (package
+ (name "sbcl-cxml+xml")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "0.0.0" revision commit))
+ (home-page "https://common-lisp.net/project/cxml/")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sharplispers/cxml")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "13kif7rf3gqdycsk9zq0d7y0g9y81krkl0z87k0p2fkbjfgrph37"))))
+ (inputs
+ `(("closure-common" ,sbcl-closure-common)
+ ("puri" ,sbcl-puri)
+ ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
+ (arguments
+ `(#:asd-file "cxml.asd"
+ #:asd-system-name "cxml/xml"))
+ (synopsis "Common Lisp XML parser")
+ (description "CXML implements a namespace-aware, validating XML 1.0
+parser as well as the DOM Level 2 Core interfaces. Two parser interfaces are
+offered, one SAX-like, the other similar to StAX.")
+ (license license:llgpl))))
+
+(define sbcl-cxml+dom
+ (package
+ (inherit sbcl-cxml+xml)
+ (name "sbcl-cxml+dom")
+ (inputs
+ `(("closure-common" ,sbcl-closure-common)
+ ("puri" ,sbcl-puri)
+ ("cxml+xml" ,sbcl-cxml+xml)))
+ (arguments
+ `(#:asd-file "cxml.asd"
+ #:asd-system-name "cxml/dom"))))
+
+(define sbcl-cxml+klacks
+ (package
+ (inherit sbcl-cxml+xml)
+ (name "sbcl-cxml+klacks")
+ (inputs
+ `(("closure-common" ,sbcl-closure-common)
+ ("puri" ,sbcl-puri)
+ ("cxml+xml" ,sbcl-cxml+xml)))
+ (arguments
+ `(#:asd-file "cxml.asd"
+ #:asd-system-name "cxml/klacks"))))
+
+(define sbcl-cxml+test
+ (package
+ (inherit sbcl-cxml+xml)
+ (name "sbcl-cxml+test")
+ (inputs
+ `(("closure-common" ,sbcl-closure-common)
+ ("puri" ,sbcl-puri)
+ ("cxml+xml" ,sbcl-cxml+xml)))
+ (arguments
+ `(#:asd-file "cxml.asd"
+ #:asd-system-name "cxml/test"))))
+
+(define-public sbcl-cxml
+ (package
+ (inherit sbcl-cxml+xml)
+ (name "sbcl-cxml")
+ (inputs
+ `(("closure-common" ,sbcl-closure-common)
+ ("puri" ,sbcl-puri)
+ ("trivial-gray-streams" ,sbcl-trivial-gray-streams)
+ ("cxml+dom" ,sbcl-cxml+dom)
+ ("cxml+klacks" ,sbcl-cxml+klacks)
+ ("cxml+test" ,sbcl-cxml+test)))
+ (arguments
+ `(#:asd-file "cxml.asd"
+ #:asd-system-name "cxml"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'build 'install-dtd
+ (lambda* (#:key outputs #:allow-other-keys)
+ (install-file "catalog.dtd"
+ (string-append
+ (assoc-ref outputs "out")
+ "/lib/" (%lisp-type)))))
+ (add-after 'create-asd 'remove-component
+ ;; XXX: The original .asd has no components, but our build system
+ ;; creates an entry nonetheless. We need to remove it for the
+ ;; generated .asd to load properly. See trivia.trivial for a
+ ;; similar problem.
+ (lambda* (#:key outputs #:allow-other-keys)
+ (let* ((out (assoc-ref outputs "out"))
+ (asd (string-append out "/lib/sbcl/cxml.asd")))
+ (substitute* asd
+ ((" :components
+")
+ ""))
+ (substitute* asd
+ ((" *\\(\\(:compiled-file \"cxml--system\"\\)\\)")
+ ""))))))))))
+
+(define-public cl-cxml
+ (sbcl-package->cl-source-package sbcl-cxml))
+
+(define-public sbcl-cl-reexport
+ (let ((commit "312f3661bbe187b5f28536cd7ec2956e91366c3b")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-reexport")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "0.1" revision commit))
+ (home-page "https://github.com/takagi/cl-reexport")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1cwpn1m3wrl0fl9plznn7p464db646gnfc8zkyk97dyxski2aq0x"))))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)))
+ (arguments
+ ;; TODO: Tests fail because cl-test-more is missing, but I can't find it online.
+ `(#:tests? #f))
+ (synopsis "HTTP cookie manager for Common Lisp")
+ (description "cl-cookie is a Common Lisp library featuring parsing of
+cookie headers, cookie creation, cookie jar creation and more.")
+ (license license:llgpl))))
+
+(define-public cl-reexport
+ (sbcl-package->cl-source-package sbcl-cl-reexport))
+
+(define-public sbcl-cl-cookie
+ (let ((commit "cea55aed8b9ad25fafd13defbcb9fe8f41b29546")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-cookie")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "0.9.10" revision commit))
+ (home-page "https://github.com/fukamachi/cl-cookie")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "090g7z75h98zvc1ldx0vh4jn4086dhjm2w30jcwkq553qmyxwl8h"))))
+ (inputs
+ `(("proc-parse" ,sbcl-proc-parse)
+ ("alexandria" ,sbcl-alexandria)
+ ("quri" ,sbcl-quri)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("local-time" ,sbcl-local-time)))
+ (native-inputs
+ `(("prove-asdf" ,sbcl-prove-asdf)
+ ("prove" ,sbcl-prove)))
+ (arguments
+ ;; TODO: Tests fail because cl-cookie depends on cl-cookie-test.
+ `(#:tests? #f))
+ (synopsis "HTTP cookie manager for Common Lisp")
+ (description "cl-cookie is a Common Lisp library featuring parsing of
+cookie headers, cookie creation, cookie jar creation and more.")
+ (license license:bsd-2))))
+
+(define-public cl-cookie
+ (sbcl-package->cl-source-package sbcl-cl-cookie))
+
+(define-public sbcl-dexador
+ (let ((commit "a2714d126cc94bc7a9a6e1e3c08de455b3a66378")
+ (revision "1"))
+ (package
+ (name "sbcl-dexador")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "0.9.10" revision commit))
+ (home-page "https://github.com/fukamachi/dexador")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0nbqgn4v3l2z6m1k1bdxfnqpfrk84nxdmz7csz11zzcfs4flkv79"))))
+ (inputs
+ `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)
+ ("babel" ,sbcl-babel)
+ ("usocket" ,sbcl-usocket)
+ ("fast-http" ,sbcl-fast-http)
+ ("quri" ,sbcl-quri)
+ ("fast-io" ,sbcl-fast-io)
+ ("chunga" ,sbcl-chunga)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("cl-cookie" ,sbcl-cl-cookie)
+ ("trivial-mimes" ,sbcl-trivial-mimes)
+ ("chipz" ,sbcl-chipz)
+ ("cl-base64" ,sbcl-cl-base64)
+ ("cl-reexport" ,sbcl-cl-reexport)
+ ("cl+ssl" ,sbcl-cl+ssl)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("alexandria" ,sbcl-alexandria)))
+ (native-inputs
+ `(("prove" ,sbcl-prove)
+ ("prove-asdf" ,sbcl-prove-asdf)
+ ("lack-request" ,sbcl-lack-request)
+ ("clack" ,sbcl-clack)
+ ("babel" ,sbcl-babel)
+ ("alexandria" ,sbcl-alexandria)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("local-time" ,sbcl-local-time)))
+ (arguments
+ ;; TODO: Circular dependency: tests depend on clack-test which depends on dexador.
+ `(#:tests? #f
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-permissions
+ (lambda _ (make-file-writable "t/data/test.gz") #t)))))
+ (synopsis "Yet another HTTP client for Common Lisp")
+ (description "Dexador is yet another HTTP client for Common Lisp with
+neat APIs and connection-pooling. It is meant to supersede Drakma.")
+ (license license:expat))))
+
+(define-public cl-dexador
+ (package
+ (inherit (sbcl-package->cl-source-package sbcl-dexador))
+ (arguments
+ `(#:phases
+ ;; asdf-build-system/source has its own phases and does not inherit
+ ;; from asdf-build-system/sbcl phases.
+ (modify-phases %standard-phases/source
+ (add-after 'unpack 'fix-permissions
+ (lambda _ (make-file-writable "t/data/test.gz") #t)))))))
+
+(define-public ecl-dexador
+ (sbcl-package->ecl-package sbcl-dexador))
+
+(define-public sbcl-lisp-namespace
+ (let ((commit "28107cafe34e4c1c67490fde60c7f92dc610b2e0")
+ (revision "1"))
+ (package
+ (name "sbcl-lisp-namespace")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "0.1" revision commit))
+ (home-page "https://github.com/guicho271828/lisp-namespace")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1jw2wykp06z2afb9nm1lgfzll5cjlj36pnknjx614057zkkxq4iy"))))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (arguments
+ `(#:test-asd-file "lisp-namespace.test.asd"
+ ;; XXX: Component LISP-NAMESPACE-ASD::LISP-NAMESPACE.TEST not found
+ #:tests? #f))
+ (synopsis "LISP-N, or extensible namespaces in Common Lisp")
+ (description "Common Lisp already has major 2 namespaces, function
+namespace and value namespace (or variable namespace), but there are actually
+more — e.g., class namespace.
+This library offers macros to deal with symbols from any namespace.")
+ (license license:llgpl))))
+
+(define-public cl-lisp-namespace
+ (sbcl-package->cl-source-package sbcl-lisp-namespace))
+
+(define-public sbcl-trivial-cltl2
+ (let ((commit "8eec8407df833e8f27df8a388bc10913f16d9e83")
+ (revision "1"))
+ (package
+ (name "sbcl-trivial-cltl2")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "0.1.1" revision commit))
+ (home-page "https://github.com/Zulu-Inuoe/trivial-cltl2")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1dyyxz17vqv8hlfwq287gl8xxbvcnq798ajb7p5jdjz91wqf4bgk"))))
+ (synopsis "Simple CLtL2 compatibility layer for Common Lisp")
+ (description "This library is a portable compatibility layer around
+\"Common Lisp the Language, 2nd
+Edition\" (@url{https://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node102.html})
+and it exports symbols from implementation-specific packages.")
+ (license license:llgpl))))
+
+(define-public cl-trivial-cltl2
+ (sbcl-package->cl-source-package sbcl-trivial-cltl2))
+
+(define-public sbcl-introspect-environment
+ (let ((commit "fff42f8f8fd0d99db5ad6c5812e53de7d660020b")
+ (revision "1"))
+ (package
+ (name "sbcl-introspect-environment")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "0.1" revision commit))
+ (home-page "https://github.com/Bike/introspect-environment")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1i305n0wfmpac63ni4i3vixnnkl8daw5ncxy0k3dv92krgx6qzhp"))))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (synopsis "Common Lisp environment introspection portability layer")
+ (description "This library is a small interface to portable but
+nonstandard introspection of Common Lisp environments. It is intended to
+allow a bit more compile-time introspection of environments in Common Lisp.
+
+Quite a bit of information is available at the time a macro or compiler-macro
+runs; inlining info, type declarations, that sort of thing. This information
+is all standard - any Common Lisp program can @code{(declare (integer x))} and
+such.
+
+This info ought to be accessible through the standard @code{&environment}
+parameters, but it is not. Several implementations keep the information for
+their own purposes but do not make it available to user programs, because
+there is no standard mechanism to do so.
+
+This library uses implementation-specific hooks to make information available
+to users. This is currently supported on SBCL, CCL, and CMUCL. Other
+implementations have implementations of the functions that do as much as they
+can and/or provide reasonable defaults.")
+ (license license:wtfpl2))))
+
+(define-public cl-introspect-environment
+ (sbcl-package->cl-source-package sbcl-introspect-environment))
+
+(define-public sbcl-type-i
+ (let ((commit "dea233f45f94064105ec09f0767de338f67dcbe2")
+ (revision "1"))
+ (package
+ (name "sbcl-type-i")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "0.1" revision commit))
+ (home-page "https://github.com/guicho271828/type-i")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "039g5pbrhh65s0bhr9314gmd2nwc2y5lp2377c5qrc2lxky89qs3"))))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("introspect-environment" ,sbcl-introspect-environment)
+ ("trivia.trivial" ,sbcl-trivia.trivial)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (arguments
+ `(#:test-asd-file "type-i.test.asd"))
+ (synopsis "Type inference utility on unary predicates for Common Lisp")
+ (description "This library tries to provide a way to detect what kind of
+type the given predicate is trying to check. This is different from inferring
+the return type of a function.")
+ (license license:llgpl))))
+
+(define-public cl-type-i
+ (sbcl-package->cl-source-package sbcl-type-i))
+
+(define-public sbcl-optima
+ (let ((commit "373b245b928c1a5cce91a6cb5bfe5dd77eb36195")
+ (revision "1"))
+ (package
+ (name "sbcl-optima")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "1.0" revision commit))
+ (home-page "https://github.com/m2ym/optima")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1yw4ymq7ms89342kkvb3aqxgv0w38m9kd8ikdqxxzyybnkjhndal"))))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("closer-mop" ,sbcl-closer-mop)))
+ (native-inputs
+ `(("eos" ,sbcl-eos)))
+ (arguments
+ ;; XXX: Circular dependencies: tests depend on optima.ppcre which depends on optima.
+ `(#:tests? #f
+ #:test-asd-file "optima.test.asd"))
+ (synopsis "Optimized pattern matching library for Common Lisp")
+ (description "Optima is a fast pattern matching library which uses
+optimizing techniques widely used in the functional programming world.")
+ (license license:expat))))
+
+(define-public cl-optima
+ (sbcl-package->cl-source-package sbcl-optima))
+
+(define-public sbcl-fare-quasiquote
+ (package
+ (name "sbcl-fare-quasiquote")
+ (build-system asdf-build-system/sbcl)
+ (version "20171130")
+ (home-page "http://common-lisp.net/project/fare-quasiquote")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "http://beta.quicklisp.org/archive/fare-quasiquote/"
+ (date->string (string->date version "~Y~m~d") "~Y-~m-~d")
+ "/fare-quasiquote-"
+ version
+ "-git.tgz"))
+ (sha256
+ (base32
+ "00brmh7ndsi0c97nibi8cy10j3l4gmkyrfrr5jr5lzkfb7ngyfqa"))))
+ (inputs
+ `(("fare-utils" ,sbcl-fare-utils)))
+ (arguments
+ ;; XXX: Circular dependencies: Tests depend on subsystems, which depend on the main systems.
+ `(#:tests? #f
+ #:phases
+ (modify-phases %standard-phases
+ ;; XXX: Require 1.0.0 version of fare-utils, and we package some
+ ;; commits after 1.0.0.5, but ASDF fails to read the
+ ;; "-REVISION-COMMIT" part generated by Guix.
+ (add-after 'unpack 'patch-requirement
+ (lambda _
+ (substitute* "fare-quasiquote.asd"
+ (("\\(:version \"fare-utils\" \"1.0.0\"\\)") "\"fare-utils\"")))))))
+ (synopsis "Pattern-matching friendly implementation of quasiquote for Common Lisp")
+ (description "The main purpose of this n+2nd reimplementation of
+quasiquote is enable matching of quasiquoted patterns, using Optima or
+Trivia.")
+ (license license:expat)))
+
+(define-public cl-fare-quasiquote
+ (sbcl-package->cl-source-package sbcl-fare-quasiquote))
+
+(define-public sbcl-fare-quasiquote-optima
+ (package
+ (inherit sbcl-fare-quasiquote)
+ (name "sbcl-fare-quasiquote-optima")
+ (inputs
+ `(("optima" ,sbcl-optima)
+ ("fare-quasiquote" ,sbcl-fare-quasiquote)))
+ (arguments
+ '(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'patch-requirement
+ (lambda _
+ (substitute* "fare-quasiquote-optima.asd"
+ (("\\(:version \"optima\" \"1\\.0\"\\)")
+ "\"optima\""))
+ #t)))))))
+
+(define-public cl-fare-quasiquote-optima
+ (sbcl-package->cl-source-package sbcl-fare-quasiquote-optima))
+
+(define-public sbcl-fare-quasiquote-readtable
+ (package
+ (inherit sbcl-fare-quasiquote)
+ (name "sbcl-fare-quasiquote-readtable")
+ (inputs
+ `(("fare-quasiquote" ,sbcl-fare-quasiquote)
+ ("named-readtables" ,sbcl-named-readtables)))
+ (description "The main purpose of this n+2nd reimplementation of
+quasiquote is enable matching of quasiquoted patterns, using Optima or
+Trivia.
+
+This package uses fare-quasiquote with named-readtable.")))
+
+(define-public cl-fare-quasiquote-readtable
+ (sbcl-package->cl-source-package sbcl-fare-quasiquote-readtable))
+
+;; TODO: Add support for component-less system in asdf-build-system/sbcl.
+(define-public cl-fare-quasiquote-extras
+ (package
+ (inherit cl-fare-quasiquote)
+ (name "cl-fare-quasiquote-extras")
+ (build-system asdf-build-system/source)
+ (propagated-inputs
+ `(("fare-quasiquote" ,cl-fare-quasiquote)
+ ("fare-quasiquote-optima" ,cl-fare-quasiquote-optima)
+ ("fare-quasiquote-readtable" ,cl-fare-quasiquote-readtable)))
+ (description "This library combines @code{fare-quasiquote-readtable} and
+@code{fare-quasiquote-optima}.")))
+
+(define-public sbcl-trivia.level0
+ (let ((commit "902e0c65602bbfe96ae82e679330b3771ddc7603")
+ (revision "1"))
+ (package
+ (name "sbcl-trivia.level0")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "0.0.0" revision commit))
+ (home-page "https://github.com/guicho271828/trivia")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "11qbab30qqnfy9mx3x9fvgcw1jbvh1qn2cqv3p8xdn2m8981jvhr"))))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)))
+ (synopsis "Pattern matching in Common Lisp")
+ (description "Trivia is a pattern matching compiler that is compatible
+with Optima, another pattern matching library for Common Lisp. It is meant to
+be faster and more extensible than Optima.")
+ (license license:llgpl))))
+
+(define-public sbcl-trivia.level1
+ (package
+ (inherit sbcl-trivia.level0)
+ (name "sbcl-trivia.level1")
+ (inputs
+ `(("trivia.level0" ,sbcl-trivia.level0)))
+ (description "Trivia is a pattern matching compiler that is compatible
+with Optima, another pattern matching library for Common Lisp. It is meant to
+be faster and more extensible than Optima.
+
+This system contains the core patterns of Trivia.")))
+
+(define-public sbcl-trivia.level2
+ (package
+ (inherit sbcl-trivia.level0)
+ (name "sbcl-trivia.level2")
+ (inputs
+ `(("trivia.level1" ,sbcl-trivia.level1)
+ ("lisp-namespace" ,sbcl-lisp-namespace)
+ ("trivial-cltl2" ,sbcl-trivial-cltl2)
+ ("closer-mop" ,sbcl-closer-mop)))
+ (description "Trivia is a pattern matching compiler that is compatible
+with Optima, another pattern matching library for Common Lisp. It is meant to
+be faster and more extensible than Optima.
+
+This system contains a non-optimized pattern matcher compatible with Optima,
+with extensible optimizer interface.")))
+
+(define-public sbcl-trivia.trivial
+ (package
+ (inherit sbcl-trivia.level0)
+ (name "sbcl-trivia.trivial")
+ (inputs
+ `(("trivia.level2" ,sbcl-trivia.level2)))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (replace 'create-asd-file
+ (lambda* (#:key outputs inputs #:allow-other-keys)
+ (let* ((out (assoc-ref outputs "out"))
+ (lib (string-append out "/lib/" (%lisp-type)))
+ (level2 (assoc-ref inputs "trivia.level2")))
+ (mkdir-p lib)
+ (install-file "trivia.trivial.asd" lib)
+ ;; XXX: This .asd does not have any component and the build
+ ;; system fails to work in this case. We should update the
+ ;; build system to handle component-less .asd.
+ ;; TODO: How do we append to file in Guile? It seems that
+ ;; (open-file ... "a") gets a "Permission denied".
+ (substitute* (string-append lib "/trivia.trivial.asd")
+ (("\"\\)")
+ (string-append "\")
+
+(progn (asdf/source-registry:ensure-source-registry)
+ (setf (gethash
+ \"trivia.level2\"
+ asdf/source-registry:*source-registry*)
+ #p\""
+ level2
+ "/share/common-lisp/sbcl-bundle-systems/trivia.level2.asd\"))")))))))))
+ (description "Trivia is a pattern matching compiler that is compatible
+with Optima, another pattern matching library for Common Lisp. It is meant to
+be faster and more extensible than Optima.
+
+This system contains the base level system of Trivia with a trivial optimizer.")))
+
+(define-public sbcl-trivia.balland2006
+ (package
+ (inherit sbcl-trivia.level0)
+ (name "sbcl-trivia.balland2006")
+ (inputs
+ `(("trivia.trivial" ,sbcl-trivia.trivial)
+ ("iterate" ,sbcl-iterate)
+ ("type-i" ,sbcl-type-i)
+ ("alexandria" ,sbcl-alexandria)))
+ (arguments
+ ;; Tests are done in trivia itself.
+ `(#:tests? #f))
+ (description "Trivia is a pattern matching compiler that is compatible
+with Optima, another pattern matching library for Common Lisp. It is meant to
+be faster and more extensible than Optima.
+
+This system contains the base level system of Trivia with a trivial optimizer.")))
+
+(define-public sbcl-trivia.ppcre
+ (package
+ (inherit sbcl-trivia.level0)
+ (name "sbcl-trivia.ppcre")
+ (inputs
+ `(("trivia.trivial" ,sbcl-trivia.trivial)
+ ("cl-ppcre" ,sbcl-cl-ppcre)))
+ (description "Trivia is a pattern matching compiler that is compatible
+with Optima, another pattern matching library for Common Lisp. It is meant to
+be faster and more extensible than Optima.
+
+This system contains the PPCRE extension.")))
+
+(define-public sbcl-trivia.quasiquote
+ (package
+ (inherit sbcl-trivia.level0)
+ (name "sbcl-trivia.quasiquote")
+ (inputs
+ `(("trivia.trivial" ,sbcl-trivia.trivial)
+ ("fare-quasiquote" ,sbcl-fare-quasiquote)
+ ("fare-quasiquote-readtable" ,sbcl-fare-quasiquote-readtable)))
+ (description "Trivia is a pattern matching compiler that is compatible
+with Optima, another pattern matching library for Common Lisp. It is meant to
+be faster and more extensible than Optima.
+
+This system contains the fare-quasiquote extension.")))
+
+(define-public sbcl-trivia.cffi
+ (package
+ (inherit sbcl-trivia.level0)
+ (name "sbcl-trivia.cffi")
+ (inputs
+ `(("cffi" ,sbcl-cffi)
+ ("trivia.trivial" ,sbcl-trivia.trivial)))
+ (description "Trivia is a pattern matching compiler that is compatible
+with Optima, another pattern matching library for Common Lisp. It is meant to
+be faster and more extensible than Optima.
+
+This system contains the CFFI foreign slot access extension.")))
+
+(define-public sbcl-trivia
+ (package
+ (inherit sbcl-trivia.level0)
+ (name "sbcl-trivia")
+ (inputs
+ `(("trivia.balland2006" ,sbcl-trivia.balland2006)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)
+ ("trivia.ppcre" ,sbcl-trivia.ppcre)
+ ("trivia.quasiquote" ,sbcl-trivia.quasiquote)
+ ("trivia.cffi" ,sbcl-trivia.cffi)
+ ("optima" ,sbcl-optima)))
+ (arguments
+ `(#:test-asd-file "trivia.test.asd"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'create-asd 'remove-component
+ ;; XXX: The original .asd has no components, but our build system
+ ;; creates an entry nonetheless. We need to remove it for the
+ ;; generated .asd to load properly. See trivia.trivial for a
+ ;; similar problem.
+ (lambda* (#:key outputs #:allow-other-keys)
+ (let* ((out (assoc-ref outputs "out"))
+ (asd (string-append out "/lib/" (%lisp-type) "/trivia.asd")))
+ (substitute* asd
+ ((" :components
+")
+ ""))
+ (substitute* asd
+ ((" *\\(\\(:compiled-file \"trivia--system\"\\)\\)")
+ ""))))))))
+ (description "Trivia is a pattern matching compiler that is compatible
+with Optima, another pattern matching library for Common Lisp. It is meant to
+be faster and more extensible than Optima.")))
+
+(define-public cl-trivia
+ (sbcl-package->cl-source-package sbcl-trivia))
+
+(define-public sbcl-mk-string-metrics
+ (package
+ (name "sbcl-mk-string-metrics")
+ (version "0.1.2")
+ (home-page "https://github.com/cbaggers/mk-string-metrics/")
+ (source (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit version)))
+ (sha256
+ (base32 "0bg0bv2mfd4k0g3x72x563hvmrx18xavaffr6xk5rh4if5j7kcf6"))
+ (file-name (git-file-name name version))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Calculate various string metrics efficiently in Common Lisp")
+ (description "This library implements efficient algorithms that calculate
+various string metrics in Common Lisp:
+
+@itemize
+@item Damerau-Levenshtein distance
+@item Hamming distance
+@item Jaccard similarity coefficient
+@item Jaro distance
+@item Jaro-Winkler distance
+@item Levenshtein distance
+@item Normalized Damerau-Levenshtein distance
+@item Normalized Levenshtein distance
+@item Overlap coefficient
+@end itemize\n")
+ (license license:x11)))
+
+(define-public cl-mk-string-metrics
+ (sbcl-package->cl-source-package sbcl-mk-string-metrics))
+
+(define-public sbcl-cl-str
+ (let ((commit "3d5ec86e3a0199e5973aacde951086dfd754b5e5"))
+ (package
+ (name "sbcl-cl-str")
+ (version (git-version "0.8" "1" commit))
+ (home-page "https://github.com/vindarel/cl-str")
+ (source (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (sha256
+ (base32 "0szzzbygw9h985yxz909vvqrp69pmpcpahn7hn350lnyjislk9ga"))
+ (file-name (git-file-name name version))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("cl-ppcre" ,sbcl-cl-ppcre)
+ ("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)))
+ (native-inputs
+ `(("prove" ,sbcl-prove)
+ ("prove-asdf" ,sbcl-prove-asdf)))
+ (arguments
+ `(#:asd-file "str.asd"
+ #:asd-system-name "str"
+ #:test-asd-file "str.test.asd"))
+ (synopsis "Modern, consistent and terse Common Lisp string manipulation library")
+ (description "A modern and consistent Common Lisp string manipulation
+library that focuses on modernity, simplicity and discoverability:
+@code{(str:trim s)} instead of @code{(string-trim '(#\\Space ...) s)}), or
+@code{str:concat strings} instead of an unusual format construct; one
+discoverable library instead of many; consistency and composability, where
+@code{s} is always the last argument, which makes it easier to feed pipes and
+arrows.")
+ (license license:expat))))
+
+(define-public cl-str
+ (sbcl-package->cl-source-package sbcl-cl-str))
+
+(define-public sbcl-cl-xmlspam
+ (let ((commit "ea06abcca2a73a9779bcfb09081e56665f94e22a"))
+ (package
+ (name "sbcl-cl-xmlspam")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "0.0.0" "1" commit))
+ (home-page "https://github.com/rogpeppe/cl-xmlspam")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (string-append name "-" version))
+ (sha256
+ (base32
+ "0w4rqvrgdgk3fwfq3kx4r7wwdr2bv3b6n3bdqwsiriw9psqzpz2s"))))
+ (inputs
+ `(("cxml" ,sbcl-cxml)
+ ("cl-ppcre" ,sbcl-cl-ppcre)))
+ (synopsis "Concise, regexp-like pattern matching on streaming XML for Common Lisp")
+ (description "CXML does an excellent job at parsing XML elements, but what
+do you do when you have a XML file that's larger than you want to fit in
+memory, and you want to extract some information from it? Writing code to deal
+with SAX events, or even using Klacks, quickly becomes tedious.
+@code{cl-xmlspam} (for XML Stream PAttern Matcher) is designed to make it easy
+to write code that mirrors the structure of the XML that it's parsing. It
+also makes it easy to shift paradigms when necessary - the usual Lisp control
+constructs can be used interchangeably with pattern matching, and the full
+power of CXML is available when necessary.")
+ (license license:bsd-3))))
+
+;; TODO: dbus uses ASDF's package-inferred-system which is not supported by
+;; asdf-build-system/sbcl as of 2019-08-02. We should fix
+;; asdf-build-system/sbcl.
+(define-public cl-dbus
+ (let ((commit "24b452df3a45ca5dc95015500f34baad175c981a")
+ (revision "1"))
+ (package
+ (name "cl-dbus")
+ (build-system asdf-build-system/source)
+ (version (git-version "20190408" revision commit))
+ (home-page "https://github.com/death/dbus")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0fw2q866yddbf23nk9pxphm9gsasx35vjyss82xzvndnjmzlqfl5"))))
+ ;; Inputs must be propagated or else packages depending on this won't have the necessary packages.
+ (propagated-inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("trivial-garbage" ,sbcl-trivial-garbage)
+ ("babel" ,sbcl-babel)
+ ("iolib" ,sbcl-iolib)
+ ("iolib+multiplex" ,(@@ (gnu packages lisp) sbcl-iolib+multiplex))
+ ("iolib+syscalls" ,(@@ (gnu packages lisp) sbcl-iolib+syscalls))
+ ("iolib+streams" ,(@@ (gnu packages lisp) sbcl-iolib+streams))
+ ("iolib+sockets" ,(@@ (gnu packages lisp) sbcl-iolib+sockets))
+ ("ieee-floats" ,sbcl-ieee-floats)
+ ("flexi-streams" ,sbcl-flexi-streams)
+ ("cl-xmlspam" ,sbcl-cl-xmlspam)
+ ("ironclad" ,sbcl-ironclad)))
+ (synopsis "D-Bus client library for Common Lisp")
+ (description "This is a Common Lisp library that allows to publish D-Bus
+objects as well as send and notify other objects connected to a bus.")
+ (license license:bsd-2))))
+
+(define-public sbcl-cl-hooks
+ (let ((commit "5b638083f3b4f1221a52631d9c8a0a265565cac7")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-hooks")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "0.2.1" revision commit))
+ (home-page "https://github.com/scymtym/architecture.hooks")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0bg3l0a28lw5gqqjp6p6b5nhwqk46sgkb7184w5qbfngw1hk8x9y"))))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("let-plus" ,sbcl-let-plus)
+ ("trivial-garbage" ,sbcl-trivial-garbage)
+ ("closer-mop" ,sbcl-closer-mop)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (synopsis "Hooks extension point mechanism (as in Emacs) for Common Lisp")
+ (description "A hook, in the present context, is a certain kind of
+extension point in a program that allows interleaving the execution of
+arbitrary code with the execution of a the program without introducing any
+coupling between the two. Hooks are used extensively in the extensible editor
+Emacs.
+
+In the Common LISP Object System (CLOS), a similar kind of extensibility is
+possible using the flexible multi-method dispatch mechanism. It may even seem
+that the concept of hooks does not provide any benefits over the possibilities
+of CLOS. However, there are some differences:
+
+@itemize
+
+@item There can be only one method for each combination of specializers and
+qualifiers. As a result this kind of extension point cannot be used by
+multiple extensions independently.
+@item Removing code previously attached via a @code{:before}, @code{:after} or
+@code{:around} method can be cumbersome.
+@item There could be other or even multiple extension points besides @code{:before}
+and @code{:after} in a single method.
+@item Attaching codes to individual objects using eql specializers can be
+cumbersome.
+@item Introspection of code attached a particular extension point is
+cumbersome since this requires enumerating and inspecting the methods of a
+generic function.
+@end itemize
+
+This library tries to complement some of these weaknesses of method-based
+extension-points via the concept of hooks.")
+ (license license:llgpl))))
+
+(define-public cl-hooks
+ (sbcl-package->cl-source-package sbcl-cl-hooks))
+
+(define-public ecl-cl-hooks
+ (sbcl-package->ecl-package sbcl-cl-hooks))
+
+(define-public sbcl-s-sysdeps
+ (let ((commit "d28246b5dffef9e73a0e0e6cfbc4e878006fe34d")
+ (revision "1"))
+ (package
+ (name "sbcl-s-sysdeps")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "1" revision commit))
+ (home-page "https://github.com/svenvc/s-sysdeps")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "14b69b81yrxmjlvmm3lfxk04x5v7hqz4fql121334wh72czznfh9"))))
+ (synopsis "Common Lisp abstraction layer over platform dependent functionality")
+ (description "@code{s-sysdeps} is an abstraction layer over platform
+dependent functionality. This simple package is used as a building block in a
+number of other open source projects.
+
+@code{s-sysdeps} abstracts:
+
+@itemize
+@item managing processes,
+@item implementing a standard TCP/IP server,
+@item opening a client TCP/IP socket stream,
+@item working with process locks.
+@end itemize\n")
+ (license license:llgpl))))
+
+(define-public cl-s-sysdeps
+ (sbcl-package->cl-source-package sbcl-s-sysdeps))
+
+(define-public ecl-s-sysdeps
+ (sbcl-package->ecl-package sbcl-s-sysdeps))
+
+(define-public sbcl-cl-prevalence
+ (let ((commit "c163c227ed85d430b82cb1e3502f72d4f88e3cfa")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-prevalence")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "5" revision commit))
+ (home-page "https://github.com/40ants/cl-prevalence")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1i9zj1q2ahgwch56an21yzbgkynz0kab9fyxkq9mg8p3xrv38jjn"))))
+ (inputs
+ `(("s-sysdeps" ,sbcl-s-sysdeps)
+ ("s-xml" ,sbcl-s-xml)))
+ (synopsis "Implementation of object prevalence for Common Lisp")
+ (description "This Common Lisp library implements object prevalence (see
+@url{https://en.wikipedia.org/wiki/System_prevalence}). It allows
+for (de)serializing to and from s-exps as well as XML. Serialization of arbitrary
+classes and cyclic data structures are supported.")
+ (license license:llgpl))))
+
+(define-public cl-prevalence
+ (sbcl-package->cl-source-package sbcl-cl-prevalence))
+
+(define-public ecl-cl-prevalence
+ (sbcl-package->ecl-package sbcl-cl-prevalence))
+
+(define-public sbcl-series
+ (let ((commit "da9061b336119d1e5214aff9117171d494d5a58a")
+ (revision "1"))
+ (package
+ (name "sbcl-series")
+ (version (git-version "2.2.11" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "git://git.code.sf.net/p/series/series")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "07hk2lhfx42zk018pxqvn4gs77vd4n4g8m4xxbqaxgca76mifwfw"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ ;; Disable the tests, they are apparently buggy and I didn't find
+ ;; a simple way to make them run and pass.
+ '(#:tests? #f))
+ (synopsis "Series data structure for Common Lisp")
+ (description
+ "This Common Lisp library provides a series data structure much like
+a sequence, with similar kinds of operations. The difference is that in many
+situations, operations on series may be composed functionally and yet execute
+iteratively, without the need to construct intermediate series values
+explicitly. In this manner, series provide both the clarity of a functional
+programming style and the efficiency of an iterative programming style.")
+ (home-page "http://series.sourceforge.net/")
+ (license license:expat))))
+
+(define-public cl-series
+ (sbcl-package->cl-source-package sbcl-series))
+
+(define-public ecl-series
+ (sbcl-package->ecl-package sbcl-series))
+
+(define-public sbcl-periods
+ (let ((commit "983d4a57325db3c8def942f163133cec5391ec28")
+ (revision "1"))
+ (package
+ (name "sbcl-periods")
+ (version (git-version "0.0.2" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/jwiegley/periods.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0z30jr3lxz3cmi019fsl4lgcgwf0yqpn95v9zkkkwgymdrkd4lga"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("local-time" ,sbcl-local-time)))
+ (synopsis "Common Lisp library for manipulating date/time objects")
+ (description
+ "Periods is a Common Lisp library providing a set of utilities for
+manipulating times, distances between times, and both contiguous and
+discontiguous ranges of time.")
+ (home-page "https://github.com/jwiegley/periods")
+ (license license:bsd-3))))
+
+(define-public cl-periods
+ (sbcl-package->cl-source-package sbcl-periods))
+
+(define-public ecl-periods
+ (sbcl-package->ecl-package sbcl-periods))
+
+(define-public sbcl-periods-series
+ (package
+ (inherit sbcl-periods)
+ (name "sbcl-periods-series")
+ (inputs
+ `(("periods" ,sbcl-periods)
+ ("series" ,sbcl-series)))
+ (arguments
+ '(#:asd-file "periods-series.asd"
+ #:asd-system-name "periods-series"))
+ (description
+ "Periods-series is an extension of the periods Common Lisp library
+providing functions compatible with the series Common Lisp library.")))
+
+(define-public cl-periods-series
+ (sbcl-package->cl-source-package sbcl-periods-series))
+
+(define-public ecl-periods-series
+ (sbcl-package->ecl-package sbcl-periods-series))
+
+(define-public sbcl-metatilities-base
+ (let ((commit "6eaa9e3ff0939a93a92109dd0fcd218de85417d5")
+ (revision "1"))
+ (package
+ (name "sbcl-metatilities-base")
+ (version (git-version "0.6.6" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/gwkkwg/metatilities-base.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0xpa86pdzlnf4v5g64j3ifaplx71sx2ha8b7vvakswi652679ma0"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("lift" ,sbcl-lift)))
+ (synopsis "Core of the metatilities Common Lisp library")
+ (description
+ "Metatilities-base is the core of the metatilities Common Lisp library
+which implements a set of utilities.")
+ (home-page "https://common-lisp.net/project/metatilities-base/")
+ (license license:expat))))
+
+(define-public cl-metatilities-base
+ (sbcl-package->cl-source-package sbcl-metatilities-base))
+
+(define-public ecl-metatilities-base
+ (sbcl-package->ecl-package sbcl-metatilities-base))
+
+(define-public sbcl-cl-containers
+ (let ((commit "810927e19d933bcf38ffeb7a23ce521efc432d45")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-containers")
+ (version (git-version "0.12.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/gwkkwg/cl-containers.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1s9faxw7svhbjpkhfrz2qxgjm3cvyjb8wpyb4m8dx4i5g7vvprkv"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("lift" ,sbcl-lift)))
+ (inputs
+ `(("metatilities-base" ,sbcl-metatilities-base)))
+ (arguments
+ '(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'relax-version-checks
+ (lambda _
+ (substitute* "cl-containers.asd"
+ (("\\(:version \"metatilities-base\" \"0\\.6\\.6\"\\)")
+ "\"metatilities-base\""))
+ (substitute* "cl-containers-test.asd"
+ (("\\(:version \"lift\" \"1\\.7\\.0\"\\)")
+ "\"lift\""))
+ #t)))))
+ (synopsis "Container library for Common Lisp")
+ (description
+ "Common Lisp ships with a set of powerful built in data structures
+including the venerable list, full featured arrays, and hash-tables.
+CL-containers enhances and builds on these structures by adding containers
+that are not available in native Lisp (for example: binary search trees,
+red-black trees, sparse arrays and so on), and by providing a standard
+interface so that they are simpler to use and so that changing design
+decisions becomes significantly easier.")
+ (home-page "https://common-lisp.net/project/cl-containers/")
+ (license license:expat))))
+
+(define-public cl-containers
+ (sbcl-package->cl-source-package sbcl-cl-containers))
+
+(define-public ecl-cl-containers
+ (sbcl-package->ecl-package sbcl-cl-containers))
+
+(define-public sbcl-xlunit
+ (let ((commit "3805d34b1d8dc77f7e0ee527a2490194292dd0fc")
+ (revision "1"))
+ (package
+ (name "sbcl-xlunit")
+ (version (git-version "0.6.3" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "http://git.kpe.io/xlunit.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0argfmp9nghs4sihyj3f8ch9qfib2b7ll07v5m9ziajgzsfl5xw3"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-tests
+ (lambda _
+ (substitute* "xlunit.asd"
+ ((" :force t") ""))
+ #t)))))
+ (synopsis "Unit testing package for Common Lisp")
+ (description
+ "The XLUnit package is a toolkit for building test suites. It is based
+on the XPTest package by Craig Brozensky and the JUnit package by Kent Beck.")
+ (home-page "http://quickdocs.org/xlunit/")
+ (license license:bsd-3))))
+
+(define-public cl-xlunit
+ (sbcl-package->cl-source-package sbcl-xlunit))
+
+(define-public ecl-xlunit
+ (sbcl-package->ecl-package sbcl-xlunit))
+
+(define-public sbcl-fprog
+ (let ((commit "7016d1a98215f82605d1c158e7a16504ca1f4636")
+ (revision "1"))
+ (package
+ (name "sbcl-fprog")
+ (version (git-version "1.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/jwiegley/cambl.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "103mry04j2k9vznsxm7wcvccgxkil92cdrv52miwcmxl8daa4jiz"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Functional programming utilities for Common Lisp")
+ (description
+ "@code{fprog} is a Common Lisp library allowing iteration over
+immutable lists sharing identical sublists.")
+ (home-page "https://github.com/jwiegley/cambl")
+ (license license:bsd-3))))
+
+(define-public cl-fprog
+ (sbcl-package->cl-source-package sbcl-fprog))
+
+(define-public ecl-fprog
+ (sbcl-package->ecl-package sbcl-fprog))
+
+(define-public sbcl-cambl
+ (let ((commit "7016d1a98215f82605d1c158e7a16504ca1f4636")
+ (revision "1"))
+ (package
+ (inherit sbcl-fprog)
+ (name "sbcl-cambl")
+ (version (git-version "4.0.0" revision commit))
+ (native-inputs
+ `(("xlunit" ,sbcl-xlunit)))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-containers" ,sbcl-cl-containers)
+ ("local-time" ,sbcl-local-time)
+ ("periods" ,sbcl-periods)
+ ("fprog" ,sbcl-fprog)))
+ (synopsis "Commoditized amounts and balances for Common Lisp")
+ (description
+ "CAMBL is a Common Lisp library providing a convenient facility for
+working with commoditized values. It does not allow compound units (and so is
+not suited for scientific operations) but does work rather nicely for the
+purpose of financial calculations."))))
+
+(define-public cl-cambl
+ (sbcl-package->cl-source-package sbcl-cambl))
+
+(define-public ecl-cambl
+ (sbcl-package->ecl-package sbcl-cambl))
+
+(define-public sbcl-cl-ledger
+ (let ((commit "08e0be41795e804cd36142e51756ad0b1caa377b")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-ledger")
+ (version (git-version "4.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/ledger/cl-ledger.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1via0qf6wjcyxnfbmfxjvms0ik9j8rqbifgpmnhrzvkhrq9pv8h1"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("cambl" ,sbcl-cambl)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("local-time" ,sbcl-local-time)
+ ("periods-series" ,sbcl-periods-series)))
+ (arguments
+ '(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-system-definition
+ (lambda _
+ (substitute* "cl-ledger.asd"
+ ((" :build-operation program-op") "")
+ ((" :build-pathname \"cl-ledger\"") "")
+ ((" :entry-point \"ledger::main\"") ""))
+ #t)))))
+ (synopsis "Common Lisp port of the Ledger accounting system")
+ (description
+ "CL-Ledger is a Common Lisp port of the Ledger double-entry accounting
+system.")
+ (home-page "https://github.com/ledger/cl-ledger")
+ (license license:bsd-3))))
+
+(define-public cl-ledger
+ (sbcl-package->cl-source-package sbcl-cl-ledger))
+
+(define-public ecl-cl-ledger
+ (sbcl-package->ecl-package sbcl-cl-ledger))
+
+(define-public sbcl-bst
+ (let ((commit "34f9c7e8e0a9f2c952fe310ab36cb630d5d9c15a")
+ (revision "1"))
+ (package
+ (name "sbcl-bst")
+ (version (git-version "1.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/glv2/bst.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1amxns7hvvh4arwbh8ciwfzplg127vh37dnbamv1m1kmmnmihfc8"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("fiveam" ,sbcl-fiveam)))
+ (synopsis "Binary search tree for Common Lisp")
+ (description
+ "BST is a Common Lisp library for working with binary search trees that
+can contain any kind of values.")
+ (home-page "https://github.com/glv2/bst")
+ (license license:gpl3))))
+
+(define-public cl-bst
+ (sbcl-package->cl-source-package sbcl-bst))
+
+(define-public ecl-bst
+ (sbcl-package->ecl-package sbcl-bst))
+
+(define-public sbcl-cl-octet-streams
+ (package
+ (name "sbcl-cl-octet-streams")
+ (version "1.0")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/glv2/cl-octet-streams.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1d7mn6ydv0j2x4r7clpc9ijjwrnfpxmvhifv8n5j7jh7s744sf8d"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (inputs
+ `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
+ (synopsis "In-memory octet streams for Common Lisp")
+ (description
+ "CL-octet-streams is a library implementing in-memory octet
+streams for Common Lisp. It was inspired by the trivial-octet-streams and
+cl-plumbing libraries.")
+ (home-page "https://github.com/glv2/cl-octet-streams")
+ (license license:gpl3+)))
+
+(define-public cl-octet-streams
+ (sbcl-package->cl-source-package sbcl-cl-octet-streams))
+
+(define-public ecl-cl-octet-streams
+ (sbcl-package->ecl-package sbcl-cl-octet-streams))
+
+(define-public sbcl-lzlib
+ (let ((commit "0de1db7129fef9a58a059d35a2fa2ecfc5b47b47")
+ (revision "1"))
+ (package
+ (name "sbcl-lzlib")
+ (version (git-version "1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/glv2/cl-lzlib.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "12ny7vj52fgnd8hb8fc8mry92vq4c1x72x2350191m4476j95clz"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (inputs
+ `(("cffi" ,sbcl-cffi)
+ ("cl-octet-streams" ,sbcl-cl-octet-streams)
+ ("lzlib" ,lzlib)))
+ (arguments
+ '(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/lzlib.lisp"
+ (("liblz\\.so")
+ (string-append (assoc-ref inputs "lzlib") "/lib/liblz.so")))
+ #t)))))
+ (synopsis "Common Lisp library for lzip (de)compression")
+ (description
+ "This Common Lisp library provides functions for lzip (LZMA)
+compression/decompression using bindings to the lzlib C library.")
+ (home-page "https://github.com/glv2/cl-lzlib")
+ (license license:gpl3+))))
+
+(define-public cl-lzlib
+ (sbcl-package->cl-source-package sbcl-lzlib))
+
+(define-public ecl-lzlib
+ (sbcl-package->ecl-package sbcl-lzlib))
+
+(define-public sbcl-chanl
+ (let ((commit "2362b57550c2c9238cc882d03553aaa1040b7340")
+ (revision "0"))
+ (package
+ (name "sbcl-chanl")
+ (version (git-version "0.4.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/zkat/chanl.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0ag3wz7yrqwp0s5069wwda98z3rrqd25spg8sa8rdqghj084w28w"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (inputs
+ `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
+ (synopsis "Portable channel-based concurrency for Common Lisp")
+ (description "Common Lisp library for channel-based concurrency. In
+a nutshell, you create various threads sequentially executing tasks you need
+done, and use channel objects to communicate and synchronize the state of these
+threads.")
+ (home-page "https://github.com/zkat/chanl")
+ (license (list license:expat license:bsd-3)))))
+
+(define-public cl-chanl
+ (sbcl-package->cl-source-package sbcl-chanl))
+
+(define-public ecl-chanl
+ (let ((base (sbcl-package->ecl-package sbcl-chanl)))
+ (package
+ (inherit base)
+ (arguments
+ (substitute-keyword-arguments (package-arguments base)
+ ;; The CHANL.ACTORS package uses the :ARGUMENTS option of
+ ;; DEFINE-METHOD-COMBINATION, which is not implemented in ECL yet
+ ;; (see https://gitlab.com/embeddable-common-lisp/ecl/issues/305).
+ ;; So let's disable it for now, as it allows compiling the library
+ ;; and using the rest of it.
+ ((#:phases phases '%standard-phases)
+ `(modify-phases ,phases
+ (add-after 'unpack 'disable-chanl-actors
+ (lambda _
+ (substitute* "chanl.asd"
+ (("\\(:file \"actors\"\\)") ""))
+ #t))))
+ ;; Disable the tests for now, as the SEND-SEQUENCE test seems to
+ ;; never end.
+ ((#:tests? _ #f) #f))))))
+
+(define-public sbcl-cl-store
+ (let ((commit "cd01f2610d3360dc01ab972bd9317407aaea7745")
+ (revision "0"))
+ (package
+ (name "sbcl-cl-store")
+ (version (git-version "0.8.11" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/skypher/cl-store.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "05b7kh5af2ax7vlmphpac4vbqr84j5ivppj96qzb64fxpjpqglm4"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("rt" ,sbcl-rt)))
+ (synopsis "Common Lisp library to serialize data")
+ (description
+ "CL-STORE is a portable serialization package which should give you the
+ability to store all Common Lisp data types into streams.")
+ (home-page "http://www.common-lisp.net/project/cl-store/")
+ (license license:expat))))
+
+(define-public cl-store
+ (sbcl-package->cl-source-package sbcl-cl-store))
+
+(define-public ecl-cl-store
+ (sbcl-package->ecl-package sbcl-cl-store))
+
+(define-public sbcl-cl-gobject-introspection
+ (let ((commit "7b703e2384945ea0ac39d9b766de434a08d81560")
+ (revision "0"))
+ (package
+ (name "sbcl-cl-gobject-introspection")
+ (version (git-version "0.3" revision commit))
+ (home-page "https://github.com/andy128k/cl-gobject-introspection")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1zcqd2qj14f6b38vys8gr89s6cijsp9r8j43xa8lynilwva7bwyh"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cffi" ,sbcl-cffi)
+ ("iterate" ,sbcl-iterate)
+ ("trivial-garbage" ,sbcl-trivial-garbage)
+ ("glib" ,glib)
+ ("gobject-introspection" ,gobject-introspection)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (arguments
+ ;; TODO: Tests fail, see
+ ;; https://github.com/andy128k/cl-gobject-introspection/issues/70.
+ '(#:tests? #f
+ #:phases
+ (modify-phases %standard-phases
+ (add-after (quote unpack) (quote fix-paths)
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/init.lisp"
+ (("libgobject-2\\.0\\.so")
+ (string-append (assoc-ref inputs "glib") "/lib/libgobject-2.0.so"))
+ (("libgirepository-1\\.0\\.so")
+ (string-append (assoc-ref inputs "gobject-introspection")
+ "/lib/libgirepository-1.0.so")))
+ #t)))))
+ (synopsis "Common Lisp bindings to GObject Introspection")
+ (description
+ "This library is a bridge between Common Lisp and GObject
+Introspection, which enables Common Lisp programs to access the full interface
+of C+GObject libraries without the need of writing dedicated bindings.")
+ (license (list license:bsd-3
+ ;; Tests are under a different license.
+ license:llgpl)))))
+
+(define-public cl-gobject-introspection
+ (sbcl-package->cl-source-package sbcl-cl-gobject-introspection))
+
+(define-public sbcl-string-case
+ (let ((commit "718c761e33749e297cd2809c7ba3ade1985c49f7")
+ (revision "0"))
+ (package
+ (name "sbcl-string-case")
+ (version (git-version "0.0.2" revision commit))
+ (home-page "https://github.com/pkhuong/string-case")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1n5i3yh0h5s636rcnwn7jwqy3rjflikra04lymimhpcshhjsk0md"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Efficient string= case in Common Lisp")
+ (description
+ "@code{string-case} is a Common Lisp macro that generates specialised decision
+trees to dispatch on string equality.")
+ (license license:bsd-3))))
+
+(define-public cl-string-case
+ (sbcl-package->cl-source-package sbcl-string-case))
+
+(define-public ecl-string-case
+ (sbcl-package->ecl-package sbcl-string-case))
+
+(define-public sbcl-global-vars
+ (let ((commit "c749f32c9b606a1457daa47d59630708ac0c266e")
+ (revision "0"))
+ (package
+ (name "sbcl-global-vars")
+ (version (git-version "1.0.0" revision commit))
+ (home-page "https://github.com/lmj/global-vars")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "06m3xc8l3pgsapl8fvsi9wf6y46zs75cp9zn7zh6dc65v4s5wz3d"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Efficient global variables in Common Lisp")
+ (description
+ "In Common Lisp, a special variable that is never dynamically bound
+typically serves as a stand-in for a global variable. The @code{global-vars}
+library provides true global variables that are implemented by some compilers.
+An attempt to rebind a global variable properly results in a compiler error.
+That is, a global variable cannot be dynamically bound.
+
+Global variables therefore allow us to communicate an intended usage that
+differs from special variables. Global variables are also more efficient than
+special variables, especially in the presence of threads.")
+ (license license:expat))))
+
+(define-public cl-global-vars
+ (sbcl-package->cl-source-package sbcl-global-vars))
+
+(define-public ecl-global-vars
+ (sbcl-package->ecl-package sbcl-global-vars))
+
+(define-public sbcl-trivial-file-size
+ (let ((commit "1c1d672a01a446ba0391dbb4ffc40be3b0476f23")
+ (revision "0"))
+ (package
+ (name "sbcl-trivial-file-size")
+ (version (git-version "0.0.0" revision commit))
+ (home-page "https://github.com/ruricolist/trivial-file-size")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "17pp86c9zs4y7i1sh7q9gbfw9iqv6655k7fz8qbj9ly1ypgxp4qs"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (synopsis "Size of a file in bytes in Common Lisp")
+ (description
+ "The canonical way to determine the size of a file in bytes, using Common Lisp,
+is to open the file with an element type of (unsigned-byte 8) and then
+calculate the length of the stream. This is less than ideal. In most cases
+it is better to get the size of the file from its metadata, using a system
+call.
+
+This library exports a single function, file-size-in-octets. It returns the
+size of a file in bytes, using system calls when possible.")
+ (license license:expat))))
+
+(define-public cl-trivial-file-size
+ (sbcl-package->cl-source-package sbcl-trivial-file-size))
+
+(define-public ecl-trivial-file-size
+ (sbcl-package->ecl-package sbcl-trivial-file-size))
+
+(define-public sbcl-trivial-macroexpand-all
+ (let ((commit "933270ac7107477de1bc92c1fd641fe646a7a8a9")
+ (revision "0"))
+ (package
+ (name "sbcl-trivial-macroexpand-all")
+ (version (git-version "0.0.0" revision commit))
+ (home-page "https://github.com/cbaggers/trivial-macroexpand-all")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "191hnn4b5j4i3crydmlzbm231kj0h7l8zj6mzj69r1npbzkas4bd"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (synopsis "Portable macroexpand-all for Common Lisp")
+ (description
+ "This library provides a macroexpand-all function that calls the
+implementation specific equivalent.")
+ (license license:unlicense))))
+
+(define-public cl-trivial-macroexpand-all
+ (sbcl-package->cl-source-package sbcl-trivial-macroexpand-all))
+
+(define-public ecl-trivial-macroexpand-all
+ (sbcl-package->ecl-package sbcl-trivial-macroexpand-all))
+
+(define-public sbcl-serapeum
+ (let ((commit "65837f8a0d65b36369ec8d000fff5c29a395b5fe")
+ (revision "0"))
+ (package
+ (name "sbcl-serapeum")
+ (version (git-version "0.0.0" revision commit))
+ (home-page "https://github.com/ruricolist/serapeum")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0clwf81r2lvk1rbfvk91s9zmbkas9imf57ilqclw12mxaxlfsnbw"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("trivia" ,sbcl-trivia)
+ ("trivia.quasiquote" ,sbcl-trivia.quasiquote)
+ ("split-sequence" ,sbcl-split-sequence)
+ ("string-case" ,sbcl-string-case)
+ ("parse-number" ,sbcl-parse-number)
+ ("trivial-garbage" ,sbcl-trivial-garbage)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("named-readtables" ,sbcl-named-readtables)
+ ("fare-quasiquote-extras" ,cl-fare-quasiquote-extras)
+ ("parse-declarations-1.0" ,sbcl-parse-declarations)
+ ("global-vars" ,sbcl-global-vars)
+ ("trivial-file-size" ,sbcl-trivial-file-size)
+ ("trivial-macroexpand-all" ,sbcl-trivial-macroexpand-all)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)
+ ("local-time" ,sbcl-local-time)))
+ (arguments
+ '(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'disable-failing-tests
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "serapeum.asd"
+ ;; Guix does not have Quicklisp, and probably never will.
+ (("\\(:file \"quicklisp\"\\)") ""))
+ #t)))))
+ (synopsis "Common Lisp utility library beyond Alexandria")
+ (description
+ "Serapeum is a conservative library of Common Lisp utilities. It is a
+supplement, not a competitor, to Alexandria.")
+ (license license:expat))))
+
+(define-public cl-serapeum
+ (sbcl-package->cl-source-package sbcl-serapeum))
+
+(define-public sbcl-arrows
+ (let ((commit "df7cf0067e0132d9697ac8b1a4f1b9c88d4f5382")
+ (revision "0"))
+ (package
+ (name "sbcl-arrows")
+ (version (git-version "0.2.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://gitlab.com/Harleqin/arrows.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "042k9vkssrqx9nhp14wdzm942zgdxvp35mba0p2syz98i75im2yy"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
+ (synopsis "Clojure-like arrow macros for Common Lisp")
+ (description
+ "This library implements the @code{->} and @code{->>} macros from
+Clojure, as well as several expansions on the idea.")
+ (home-page "https://gitlab.com/Harleqin/arrows")
+ (license license:public-domain))))
+
+(define-public cl-arrows
+ (sbcl-package->cl-source-package sbcl-arrows))
+
+(define-public ecl-arrows
+ (sbcl-package->ecl-package sbcl-arrows))
+
+(define-public sbcl-simple-parallel-tasks
+ (let ((commit "db460f7a3f7bbfe2d3a2223ed21e162068d04dda")
+ (revision "0"))
+ (package
+ (name "sbcl-simple-parallel-tasks")
+ (version (git-version "1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/glv2/simple-parallel-tasks.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0amw3qk23wnlyrsgzszs6rs7y4zvxv8dr03rnqhc60mnm8ds4dd5"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (inputs
+ `(("chanl" ,sbcl-chanl)))
+ (synopsis "Common Lisp library to evaluate some forms in parallel")
+ (description "This is a simple Common Lisp library to evaluate some
+forms in parallel.")
+ (home-page "https://github.com/glv2/simple-parallel-tasks")
+ (license license:gpl3))))
+
+(define-public cl-simple-parallel-tasks
+ (sbcl-package->cl-source-package sbcl-simple-parallel-tasks))
+
+(define-public ecl-simple-parallel-tasks
+ (sbcl-package->ecl-package sbcl-simple-parallel-tasks))
+
+(define-public sbcl-cl-heap
+ (package
+ (name "sbcl-cl-heap")
+ (version "0.1.6")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://common-lisp.net/project/cl-heap/releases/"
+ "cl-heap_" version ".tar.gz"))
+ (sha256
+ (base32
+ "163hb07p2nxz126rpq3cj5dyala24n0by5i5786n2qcr1w0bak4i"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("xlunit" ,sbcl-xlunit)))
+ (arguments
+ `(#:test-asd-file "cl-heap-tests.asd"))
+ (synopsis "Heap and priority queue data structures for Common Lisp")
+ (description
+ "CL-HEAP provides various implementations of heap data structures (a
+binary heap and a Fibonacci heap) as well as an efficient priority queue.")
+ (home-page "https://common-lisp.net/project/cl-heap/")
+ (license license:gpl3+)))
+
+(define-public cl-heap
+ (sbcl-package->cl-source-package sbcl-cl-heap))
+
+(define-public ecl-cl-heap
+ (sbcl-package->ecl-package sbcl-cl-heap))
+
+(define-public sbcl-curry-compose-reader-macros
+ (let ((commit "beaa92dedf392726c042184bfd6149fa8d9e6ac2")
+ (revision "0"))
+ (package
+ (name "sbcl-curry-compose-reader-macros")
+ (version (git-version "1.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri
+ (git-reference
+ (url "https://github.com/eschulte/curry-compose-reader-macros.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0rv9bl8xrad5wfcg5zs1dazvnpmvqz6297lbn8bywsrcfnlf7h98"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("named-readtables" ,sbcl-named-readtables)))
+ (synopsis "Reader macros for partial application and composition")
+ (description
+ "This Common Lisp library provides reader macros for concise expression
+of function partial application and composition.")
+ (home-page "https://eschulte.github.io/curry-compose-reader-macros/")
+ (license license:public-domain))))
+
+(define-public cl-curry-compose-reader-macros
+ (sbcl-package->cl-source-package sbcl-curry-compose-reader-macros))
+
+(define-public ecl-curry-compose-reader-macros
+ (sbcl-package->ecl-package sbcl-curry-compose-reader-macros))
+
+(define-public sbcl-yason
+ (package
+ (name "sbcl-yason")
+ (version "0.7.7")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/phmarek/yason.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0479rbjgbj80jpk5bby18inlv1kfp771a82rlcq5psrz65qqa9bj"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
+ (synopsis "Common Lisp JSON parser/encoder")
+ (description
+ "YASON is a Common Lisp library for encoding and decoding data in the
+JSON interchange format.")
+ (home-page "https://github.com/phmarek/yason")
+ (license license:bsd-3)))
+
+(define-public cl-yason
+ (sbcl-package->cl-source-package sbcl-yason))
+
+(define-public ecl-yason
+ (sbcl-package->ecl-package sbcl-yason))
+
+(define-public sbcl-stefil
+ (let ((commit "0398548ec95dceb50fc2c2c03e5fb0ce49b86c7a")
+ (revision "0"))
+ (package
+ (name "sbcl-stefil")
+ (version (git-version "0.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://gitlab.common-lisp.net/stefil/stefil.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0bqz64q2szzhf91zyqyssmvrz7da6442rs01808pf3wrdq28bclh"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("iterate" ,sbcl-iterate)
+ ("metabang-bind" ,sbcl-metabang-bind)))
+ (propagated-inputs
+ ;; Swank doesn't have a pre-compiled package, therefore we must
+ ;; propagate its sources.
+ `(("swank" ,cl-slime-swank)))
+ (arguments
+ '(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'drop-unnecessary-dependency
+ (lambda _
+ (substitute* "package.lisp"
+ ((":stefil-system") ""))
+ #t)))))
+ (home-page "https://common-lisp.net/project/stefil/index-old.shtml")
+ (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 cl-stefil
+ (sbcl-package->cl-source-package sbcl-stefil))
+
+(define-public sbcl-graph
+ (let ((commit "78bf9ec930d8eae4f0861b5be76765fb1e45e24f")
+ (revision "0"))
+ (package
+ (name "sbcl-graph")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri
+ (git-reference
+ (url "https://github.com/eschulte/graph.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1qpij4xh8bqwc2myahpilcbh916v7vg0acz2fij14d3y0jm02h0g"))
+ (patches (search-patches "sbcl-graph-asdf-definitions.patch"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("stefil" ,sbcl-stefil)))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-heap" ,sbcl-cl-heap)
+ ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
+ ("metabang-bind" ,sbcl-metabang-bind)
+ ("named-readtables" ,sbcl-named-readtables)))
+ (arguments
+ '(#:test-asd-file "graph.test.asd"))
+ (synopsis "Graph data structure and algorithms for Common Lisp")
+ (description
+ "The GRAPH Common Lisp library provides a data structures to represent
+graphs, as well as some graph manipulation and analysis algorithms (shortest
+path, maximum flow, minimum spanning tree, etc.).")
+ (home-page "https://eschulte.github.io/graph/")
+ (license license:gpl3+))))
+
+(define-public cl-graph
+ (sbcl-package->cl-source-package sbcl-graph))
+
+(define-public sbcl-graph-dot
+ (package
+ (inherit sbcl-graph)
+ (name "sbcl-graph-dot")
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
+ ("graph" ,sbcl-graph)
+ ("metabang-bind" ,sbcl-metabang-bind)
+ ("named-readtables" ,sbcl-named-readtables)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-graph)
+ ((#:asd-file _ "") "graph.dot.asd")
+ ((#:asd-system-name _ #f) "graph-dot")))
+ (synopsis "Serialize graphs to and from DOT format")))
+
+(define-public sbcl-graph-json
+ (package
+ (inherit sbcl-graph)
+ (name "sbcl-graph-json")
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
+ ("graph" ,sbcl-graph)
+ ("metabang-bind" ,sbcl-metabang-bind)
+ ("named-readtables" ,sbcl-named-readtables)
+ ("yason" ,sbcl-yason)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-graph)
+ ((#:asd-file _ "") "graph.json.asd")
+ ((#:asd-system-name _ #f) "graph-json")))
+ (synopsis "Serialize graphs to and from JSON format")))