gnu/packages/lisp-xyz.scm

   1 ;;; GNU Guix --- Functional package management for GNU
   2 ;;; Copyright © 2014 John Darrington <jmd@gnu.org>
   3 ;;; Copyright © 2015 Taylan Ulrich Bayırlı/Kammer <taylanbayirli@gmail.com>
   4 ;;; Copyright © 2015 Mark H Weaver <mhw@netris.org>
   5 ;;; Copyright © 2016 Federico Beffa <beffa@fbengineering.ch>
   6 ;;; Copyright © 2016, 2017 ng0 <ng0@n0.is>
   7 ;;; Copyright © 2016, 2017 Andy Patterson <ajpatter@uwaterloo.ca>
   8 ;;; Copyright © 2017, 2019 Ricardo Wurmus <rekado@elephly.net>
   9 ;;; Copyright © 2017, 2018, 2019 Efraim Flashner <efraim@flashner.co.il>
  10 ;;; Copyright © 2017, 2019 Tobias Geerinckx-Rice <me@tobias.gr>
  11 ;;; Copyright © 2018 Benjamin Slade <slade@jnanam.net>
  12 ;;; Copyright © 2018 Alex Vong <alexvong1995@gmail.com>
  13 ;;; Copyright © 2018 Pierre Neidhardt <mail@ambrevar.xyz>
  14 ;;; Copyright © 2018, 2019 Pierre Langlois <pierre.langlois@gmx.com>
  15 ;;; Copyright © 2019 Katherine Cox-Buday <cox.katherine.e@gmail.com>
  16 ;;; Copyright © 2019 Jesse Gildersleve <jessejohngildersleve@protonmail.com>
  17 ;;; Copyright © 2019 Guillaume Le Vaillant <glv@posteo.net>
  18 ;;; Copyright © 2019 Brett Gilio <brettg@gnu.org>
  19 ;;;
  20 ;;; This file is part of GNU Guix.
  21 ;;;
  22 ;;; GNU Guix is free software; you can redistribute it and/or modify it
  23 ;;; under the terms of the GNU General Public License as published by
  24 ;;; the Free Software Foundation; either version 3 of the License, or (at
  25 ;;; your option) any later version.
  26 ;;;
  27 ;;; GNU Guix is distributed in the hope that it will be useful, but
  28 ;;; WITHOUT ANY WARRANTY; without even the implied warranty of
  29 ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  30 ;;; GNU General Public License for more details.
  31 ;;;
  32 ;;; You should have received a copy of the GNU General Public License
  33 ;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.
  34
  35 ;;; This file only contains Common Lisp libraries.
  36 ;;; Common Lisp compilers and tooling go to lisp.scm.
  37 ;;; Common Lisp applications should go to the most appropriate file,
  38 ;;; e.g. StumpWM is in wm.scm.
  39
  40 (define-module (gnu packages lisp-xyz)
  41   #:use-module (gnu packages)
  42   #:use-module ((guix licenses) #:prefix license:)
  43   #:use-module (guix packages)
  44   #:use-module (guix download)
  45   #:use-module (guix git-download)
  46   #:use-module (guix hg-download)
  47   #:use-module (guix utils)
  48   #:use-module (guix build-system asdf)
  49   #:use-module (guix build-system trivial)
  50   #:use-module (gnu packages c)
  51   #:use-module (gnu packages compression)
  52   #:use-module (gnu packages glib)
  53   #:use-module (gnu packages gtk)
  54   #:use-module (gnu packages libffi)
  55   #:use-module (gnu packages lisp)
  56   #:use-module (gnu packages pkg-config)
  57   #:use-module (gnu packages python)
  58   #:use-module (gnu packages python-xyz)
  59   #:use-module (gnu packages sqlite)
  60   #:use-module (gnu packages tls)
  61   #:use-module (gnu packages webkit)
  62   #:use-module (gnu packages xdisorg)
  63   #:use-module (ice-9 match)
  64   #:use-module (srfi srfi-19))
  65
  66 (define-public sbcl-alexandria
  67   (let ((revision "1")
  68         (commit "3b849bc0116ea70f215ee6b2fbf354e862aaa9dd"))
  69     (package
  70       (name "sbcl-alexandria")
  71       (version (git-version "1.0.0" revision commit))
  72       (source
  73        (origin
  74          (method git-fetch)
  75          (uri (git-reference
  76                (url "https://gitlab.common-lisp.net/alexandria/alexandria.git")
  77                (commit commit)))
  78          (sha256
  79           (base32
  80            "04amwvx2vl691f0plcfbqqwxgib9zimih7jrn5zl7mbwvrxy022b"))
  81          (file-name (git-file-name name version))))
  82       (build-system asdf-build-system/sbcl)
  83       (native-inputs
  84        `(("rt" ,sbcl-rt)))
  85       (synopsis "Collection of portable utilities for Common Lisp")
  86       (description
  87        "Alexandria is a collection of portable utilities.  It does not contain
  88 conceptual extensions to Common Lisp.  It is conservative in scope, and
  89 portable between implementations.")
  90       (home-page "https://common-lisp.net/project/alexandria/")
  91       (license license:public-domain))))
  92
  93 (define-public cl-alexandria
  94   (sbcl-package->cl-source-package sbcl-alexandria))
  95
  96 (define-public ecl-alexandria
  97   (sbcl-package->ecl-package sbcl-alexandria))
  98
  99 (define-public sbcl-net.didierverna.asdf-flv
 100   (package
 101     (name "sbcl-net.didierverna.asdf-flv")
 102     (version "2.1")
 103     (source
 104      (origin
 105        (method git-fetch)
 106        (uri (git-reference
 107              (url "https://github.com/didierverna/asdf-flv")
 108              (commit (string-append "version-" version))))
 109        (file-name (git-file-name "asdf-flv" version))
 110        (sha256
 111         (base32 "1fi2y4baxan103jbg4idjddzihy03kwnj2mzbwrknw4d4x7xlgwj"))))
 112     (build-system asdf-build-system/sbcl)
 113     (synopsis "Common Lisp ASDF extension to provide support for file-local variables")
 114     (description "ASDF-FLV provides support for file-local variables through
 115 ASDF.  A file-local variable behaves like @code{*PACKAGE*} and
 116 @code{*READTABLE*} with respect to @code{LOAD} and @code{COMPILE-FILE}: a new
 117 dynamic binding is created before processing the file, so that any
 118 modification to the variable becomes essentially file-local.
 119
 120 In order to make one or several variables file-local, use the macros
 121 @code{SET-FILE-LOCAL-VARIABLE(S)}.")
 122     (home-page "https://www.lrde.epita.fr/~didier/software/lisp/misc.php#asdf-flv")
 123     (license (license:non-copyleft
 124               "https://www.gnu.org/prep/maintain/html_node/License-Notices-for-Other-Files.html"
 125               "GNU All-Permissive License"))))
 126
 127 (define-public cl-net.didierverna.asdf-flv
 128   (sbcl-package->cl-source-package sbcl-net.didierverna.asdf-flv))
 129
 130 (define-public ecl-net.didierverna.asdf-flv
 131   (sbcl-package->ecl-package sbcl-net.didierverna.asdf-flv))
 132
 133 (define-public sbcl-fiveam
 134   (package
 135     (name "sbcl-fiveam")
 136     (version "1.4.1")
 137     (source
 138      (origin
 139        (method git-fetch)
 140        (uri (git-reference
 141              (url "https://github.com/sionescu/fiveam.git")
 142              (commit (string-append "v" version))))
 143        (file-name (git-file-name "fiveam" version))
 144        (sha256
 145         (base32 "1q3d38pwafnwnw42clq0f8g5xw7pbzr287jl9jsqmb1vb0n1vrli"))))
 146     (inputs
 147      `(("alexandria" ,sbcl-alexandria)
 148        ("net.didierverna.asdf-flv" ,sbcl-net.didierverna.asdf-flv)
 149        ("trivial-backtrace" ,sbcl-trivial-backtrace)))
 150     (build-system asdf-build-system/sbcl)
 151     (synopsis "Common Lisp testing framework")
 152     (description "FiveAM is a simple (as far as writing and running tests
 153 goes) regression testing framework.  It has been designed with Common Lisp's
 154 interactive development model in mind.")
 155     (home-page "https://common-lisp.net/project/fiveam/")
 156     (license license:bsd-3)))
 157
 158 (define-public cl-fiveam
 159   (sbcl-package->cl-source-package sbcl-fiveam))
 160
 161 (define-public ecl-fiveam
 162   (sbcl-package->ecl-package sbcl-fiveam))
 163
 164 (define-public sbcl-bordeaux-threads
 165   (let ((commit "5dce49fbc829f4d136a734f5ef4f5d599660984f")
 166         (revision "1"))
 167     (package
 168       (name "sbcl-bordeaux-threads")
 169       (version (git-version "0.8.6" revision commit))
 170       (source (origin
 171                 (method git-fetch)
 172                 (uri (git-reference
 173                       (url "https://github.com/sionescu/bordeaux-threads.git")
 174                       (commit commit)))
 175                 (sha256
 176                  (base32 "1gkh9rz7zw57n3110ikcf4835950wr4hgp8l79id5ai6nd86x7wv"))
 177                 (file-name
 178                  (git-file-name "bordeaux-threads" version))))
 179       (inputs `(("alexandria" ,sbcl-alexandria)))
 180       (native-inputs `(("fiveam" ,sbcl-fiveam)))
 181       (build-system asdf-build-system/sbcl)
 182       (synopsis "Portable shared-state concurrency library for Common Lisp")
 183       (description "BORDEAUX-THREADS is a proposed standard for a minimal
 184 MP/Threading interface.  It is similar to the CLIM-SYS threading and lock
 185 support.")
 186       (home-page "https://common-lisp.net/project/bordeaux-threads/")
 187       (license license:x11))))
 188
 189 (define-public cl-bordeaux-threads
 190   (sbcl-package->cl-source-package sbcl-bordeaux-threads))
 191
 192 (define-public ecl-bordeaux-threads
 193   (sbcl-package->ecl-package sbcl-bordeaux-threads))
 194
 195 (define-public sbcl-trivial-gray-streams
 196   (let ((revision "1")
 197         (commit "0483ade330508b4b2edeabdb47d16ec9437ee1cb"))
 198     (package
 199       (name "sbcl-trivial-gray-streams")
 200       (version (string-append "0.0.0-" revision "." (string-take commit 7)))
 201       (source
 202        (origin
 203          (method git-fetch)
 204          (uri
 205           (git-reference
 206            (url "https://github.com/trivial-gray-streams/trivial-gray-streams.git")
 207            (commit commit)))
 208          (sha256
 209           (base32 "0m3rpf2x0zmdk3nf1qfa01j6a55vj7gkwhyw78qslcgbjlgh8p4d"))
 210          (file-name
 211           (string-append "trivial-gray-streams-" version "-checkout"))))
 212       (build-system asdf-build-system/sbcl)
 213       (synopsis "Compatibility layer for Gray streams implementations")
 214       (description "Gray streams is an interface proposed for inclusion with
 215 ANSI CL by David N. Gray.  The proposal did not make it into ANSI CL, but most
 216 popular CL implementations implement it.  This package provides an extremely
 217 thin compatibility layer for gray streams.")
 218       (home-page "http://www.cliki.net/trivial-gray-streams")
 219       (license license:x11))))
 220
 221 (define-public cl-trivial-gray-streams
 222   (sbcl-package->cl-source-package sbcl-trivial-gray-streams))
 223
 224 (define-public ecl-trivial-gray-streams
 225   (sbcl-package->ecl-package sbcl-trivial-gray-streams))
 226
 227 (define-public sbcl-fiasco
 228   (let ((commit "d62f7558b21addc89f87e306f65d7f760632655f")
 229         (revision "1"))
 230     (package
 231       (name "sbcl-fiasco")
 232       (version (git-version "0.0.1" revision commit))
 233       (source
 234        (origin
 235          (method git-fetch)
 236          (uri (git-reference
 237                (url "https://github.com/joaotavora/fiasco.git")
 238                (commit commit)))
 239          (file-name (git-file-name "fiasco" version))
 240          (sha256
 241           (base32
 242            "1zwxs3d6iswayavcmb49z2892xhym7n556d8dnmvalc32pm9bkjh"))))
 243       (build-system asdf-build-system/sbcl)
 244       (inputs
 245        `(("alexandria" ,sbcl-alexandria)
 246          ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
 247       (synopsis "Simple and powerful test framework for Common Lisp")
 248       (description "A Common Lisp test framework that treasures your failures,
 249 logical continuation of Stefil.  It focuses on interactive debugging.")
 250       (home-page "https://github.com/joaotavora/fiasco")
 251       ;; LICENCE specifies this is public-domain unless the legislation
 252       ;; doesn't allow or recognize it.  In that case it falls back to a
 253       ;; permissive licence.
 254       (license (list license:public-domain
 255                      (license:x11-style "file://LICENCE"))))))
 256
 257 (define-public cl-fiasco
 258   (sbcl-package->cl-source-package sbcl-fiasco))
 259
 260 (define-public ecl-fiasco
 261   (sbcl-package->ecl-package sbcl-fiasco))
 262
 263 (define-public sbcl-flexi-streams
 264   (package
 265     (name "sbcl-flexi-streams")
 266     (version "1.0.16")
 267     (source
 268      (origin
 269        (method git-fetch)
 270        (uri (git-reference
 271              (url "https://github.com/edicl/flexi-streams.git")
 272              (commit (string-append "v" version))))
 273        (file-name (git-file-name "flexi-streams" version))
 274        (sha256
 275         (base32 "0gvykjlmja060zqq6nn6aqxlshh6r6ijahmmgf20q0d839rwpgxc"))))
 276     (build-system asdf-build-system/sbcl)
 277     (arguments
 278      `(#:phases
 279        (modify-phases %standard-phases
 280          (add-after 'unpack 'make-git-checkout-writable
 281            (lambda _
 282              (for-each make-file-writable (find-files "."))
 283              #t)))))
 284     (inputs `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
 285     (synopsis "Implementation of virtual bivalent streams for Common Lisp")
 286     (description "Flexi-streams is an implementation of \"virtual\" bivalent
 287 streams that can be layered atop real binary or bivalent streams and that can
 288 be used to read and write character data in various single- or multi-octet
 289 encodings which can be changed on the fly.  It also supplies in-memory binary
 290 streams which are similar to string streams.")
 291     (home-page "http://weitz.de/flexi-streams/")
 292     (license license:bsd-3)))
 293
 294 (define-public cl-flexi-streams
 295   (sbcl-package->cl-source-package sbcl-flexi-streams))
 296
 297 (define-public ecl-flexi-streams
 298   (sbcl-package->ecl-package sbcl-flexi-streams))
 299
 300 (define-public sbcl-cl-ppcre
 301   (package
 302     (name "sbcl-cl-ppcre")
 303     (version "2.0.11")
 304     (source
 305      (origin
 306        (method git-fetch)
 307        (uri (git-reference
 308              (url "https://github.com/edicl/cl-ppcre.git")
 309              (commit (string-append "v" version))))
 310        (file-name (git-file-name "cl-ppcre" version))
 311        (sha256
 312         (base32 "0q3iany07vgqm144lw6pj0af2d3vsikpbkwcxr30fci3kzsq4f49"))))
 313     (build-system asdf-build-system/sbcl)
 314     (native-inputs `(("flexi-streams" ,sbcl-flexi-streams)))
 315     (synopsis "Portable regular expression library for Common Lisp")
 316     (description "CL-PPCRE is a portable regular expression library for Common
 317 Lisp, which is compatible with perl.  It is pretty fast, thread-safe, and
 318 compatible with ANSI-compliant Common Lisp implementations.")
 319     (home-page "http://weitz.de/cl-ppcre/")
 320     (license license:bsd-2)))
 321
 322 (define-public cl-ppcre
 323   (sbcl-package->cl-source-package sbcl-cl-ppcre))
 324
 325 (define-public ecl-cl-ppcre
 326   (sbcl-package->ecl-package sbcl-cl-ppcre))
 327
 328 (define sbcl-cl-unicode-base
 329   (let ((revision "1")
 330         (commit "9fcd06fba1ddc9e66aed2f2d6c32dc9b764f03ea"))
 331     (package
 332       (name "sbcl-cl-unicode-base")
 333       (version (string-append "0.1.5-" revision "." (string-take commit 7)))
 334       (source (origin
 335                 (method git-fetch)
 336                 (uri (git-reference
 337                       (url "https://github.com/edicl/cl-unicode.git")
 338                       (commit commit)))
 339                 (file-name (string-append "cl-unicode-" version "-checkout"))
 340                 (sha256
 341                  (base32
 342                   "1jicprb5b3bv57dy1kg03572gxkcaqdjhak00426s76g0plmx5ki"))))
 343       (build-system asdf-build-system/sbcl)
 344       (arguments
 345        '(#:asd-file "cl-unicode.asd"
 346          #:asd-system-name "cl-unicode/base"))
 347       (inputs
 348        `(("cl-ppcre" ,sbcl-cl-ppcre)))
 349       (home-page "http://weitz.de/cl-unicode/")
 350       (synopsis "Portable Unicode library for Common Lisp")
 351       (description "CL-UNICODE is a portable Unicode library Common Lisp, which
 352 is compatible with perl.  It is pretty fast, thread-safe, and compatible with
 353 ANSI-compliant Common Lisp implementations.")
 354       (license license:bsd-2))))
 355
 356 (define-public sbcl-cl-unicode
 357   (package
 358     (inherit sbcl-cl-unicode-base)
 359     (name "sbcl-cl-unicode")
 360     (inputs
 361      `(("cl-unicode/base" ,sbcl-cl-unicode-base)
 362        ,@(package-inputs sbcl-cl-unicode-base)))
 363     (native-inputs
 364      `(("flexi-streams" ,sbcl-flexi-streams)))
 365     (arguments '())))
 366
 367 (define-public ecl-cl-unicode
 368   (sbcl-package->ecl-package sbcl-cl-unicode))
 369
 370 (define-public cl-unicode
 371   (sbcl-package->cl-source-package sbcl-cl-unicode))
 372
 373 (define-public sbcl-clx
 374   (package
 375     (name "sbcl-clx")
 376     (version "0.7.5")
 377     (source
 378      (origin
 379        (method git-fetch)
 380        (uri
 381         (git-reference
 382          (url "https://github.com/sharplispers/clx.git")
 383          (commit version)))
 384        (sha256
 385         (base32
 386          "1vi67z9hpj5rr4xcmfbfwzmlcc0ah7hzhrmfid6lqdkva238v2wf"))
 387        (file-name (string-append "clx-" version))))
 388     (build-system asdf-build-system/sbcl)
 389     (native-inputs
 390      `(("fiasco" ,sbcl-fiasco)))
 391     (home-page "http://www.cliki.net/portable-clx")
 392     (synopsis "X11 client library for Common Lisp")
 393     (description "CLX is an X11 client library for Common Lisp.  The code was
 394 originally taken from a CMUCL distribution, was modified somewhat in order to
 395 make it compile and run under SBCL, then a selection of patches were added
 396 from other CLXes around the net.")
 397     (license license:x11)))
 398
 399 (define-public cl-clx
 400   (sbcl-package->cl-source-package sbcl-clx))
 401
 402 (define-public ecl-clx
 403   (sbcl-package->ecl-package sbcl-clx))
 404
 405 (define-public sbcl-cl-ppcre-unicode
 406   (package (inherit sbcl-cl-ppcre)
 407     (name "sbcl-cl-ppcre-unicode")
 408     (arguments
 409      `(#:tests? #f ; tests fail with "Component :CL-PPCRE-TEST not found"
 410        #:asd-file "cl-ppcre-unicode.asd"))
 411     (inputs
 412      `(("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
 413        ("sbcl-cl-unicode" ,sbcl-cl-unicode)))))
 414
 415 ;; The slynk that users expect to install includes all of slynk's contrib
 416 ;; modules.  Therefore, we build the base module and all contribs first; then
 417 ;; we expose the union of these as `sbcl-slynk'.  The following variable
 418 ;; describes the base module.
 419 (define sbcl-slynk-boot0
 420   (let ((revision "2")
 421         (commit "cbf84c36c4eca8b032e3fd16177a7bc02df3ec4c"))
 422     (package
 423       (name "sbcl-slynk-boot0")
 424       (version (string-append "1.0.0-beta-" revision "." (string-take commit 7)))
 425       (source
 426        (origin
 427          (method git-fetch)
 428          (uri
 429           (git-reference
 430            (url "https://github.com/joaotavora/sly.git")
 431            (commit commit)))
 432          (sha256
 433           (base32 "13dyhsravn591p7g6is01mp2ynzjnnj7pwgi57r6xqmd4611y9vh"))
 434          (file-name (string-append "slynk-" version "-checkout"))
 435          (modules '((guix build utils)
 436                     (ice-9 ftw)))
 437          (snippet
 438           '(begin
 439              ;; Move the contribs into the main source directory for easier
 440              ;; access
 441              (substitute* "slynk/slynk.asd"
 442                (("\\.\\./contrib")
 443                 "contrib")
 444                (("\\(defsystem :slynk/util")
 445                 "(defsystem :slynk/util :depends-on (:slynk)")
 446                ((":depends-on \\(:slynk :slynk/util\\)")
 447                 ":depends-on (:slynk :slynk-util)"))
 448              (substitute* "contrib/slynk-trace-dialog.lisp"
 449                (("\\(slynk::reset-inspector\\)") ; Causes problems on load
 450                 "nil"))
 451              (substitute* "contrib/slynk-profiler.lisp"
 452                (("slynk:to-line")
 453                 "slynk-pprint-to-line"))
 454              (substitute* "contrib/slynk-fancy-inspector.lisp"
 455                (("slynk/util") "slynk-util")
 456                ((":compile-toplevel :load-toplevel") ""))
 457              (rename-file "contrib" "slynk/contrib")
 458              ;; Move slynk's contents into the base directory for easier
 459              ;; access
 460              (for-each (lambda (file)
 461                          (unless (string-prefix? "." file)
 462                            (rename-file (string-append "slynk/" file)
 463                                         (string-append "./" (basename file)))))
 464                        (scandir "slynk"))
 465              #t))))
 466       (build-system asdf-build-system/sbcl)
 467       (arguments
 468        `(#:tests? #f ; No test suite
 469          #:asd-system-name "slynk"))
 470       (synopsis "Common Lisp IDE for Emacs")
 471       (description "SLY is a fork of SLIME, an IDE backend for Common Lisp.
 472 It also features a completely redesigned REPL based on Emacs's own
 473 full-featured comint.el, live code annotations, and a consistent interactive
 474 button interface.  Everything can be copied to the REPL.  One can create
 475 multiple inspectors with independent history.")
 476       (home-page "https://github.com/joaotavora/sly")
 477       (license license:public-domain)
 478       (properties `((cl-source-variant . ,(delay cl-slynk)))))))
 479
 480 (define-public cl-slynk
 481   (package
 482     (inherit (sbcl-package->cl-source-package sbcl-slynk-boot0))
 483     (name "cl-slynk")))
 484
 485 (define ecl-slynk-boot0
 486   (sbcl-package->ecl-package sbcl-slynk-boot0))
 487
 488 (define sbcl-slynk-arglists
 489   (package
 490     (inherit sbcl-slynk-boot0)
 491     (name "sbcl-slynk-arglists")
 492     (inputs `(("slynk" ,sbcl-slynk-boot0)))
 493     (arguments
 494      (substitute-keyword-arguments (package-arguments sbcl-slynk-boot0)
 495        ((#:asd-file _ "") "slynk.asd")
 496        ((#:asd-system-name _ #f) "slynk/arglists")))))
 497
 498 (define ecl-slynk-arglists
 499   (sbcl-package->ecl-package sbcl-slynk-arglists))
 500
 501 (define sbcl-slynk-util
 502   (package
 503     (inherit sbcl-slynk-boot0)
 504     (name "sbcl-slynk-util")
 505     (inputs `(("slynk" ,sbcl-slynk-boot0)))
 506     (arguments
 507      (substitute-keyword-arguments (package-arguments sbcl-slynk-boot0)
 508        ((#:asd-file _ "") "slynk.asd")
 509        ((#:asd-system-name _ #f) "slynk/util")))))
 510
 511 (define ecl-slynk-util
 512   (sbcl-package->ecl-package sbcl-slynk-util))
 513
 514 (define sbcl-slynk-fancy-inspector
 515   (package
 516     (inherit sbcl-slynk-arglists)
 517     (name "sbcl-slynk-fancy-inspector")
 518     (inputs `(("slynk-util" ,sbcl-slynk-util)
 519               ,@(package-inputs sbcl-slynk-arglists)))
 520     (arguments
 521      (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
 522        ((#:asd-system-name _ #f) "slynk/fancy-inspector")))))
 523
 524 (define ecl-slynk-fancy-inspector
 525   (sbcl-package->ecl-package sbcl-slynk-fancy-inspector))
 526
 527 (define sbcl-slynk-package-fu
 528   (package
 529     (inherit sbcl-slynk-arglists)
 530     (name "sbcl-slynk-package-fu")
 531     (arguments
 532      (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
 533        ((#:asd-system-name _ #f) "slynk/package-fu")))))
 534
 535 (define ecl-slynk-package-fu
 536   (sbcl-package->ecl-package sbcl-slynk-package-fu))
 537
 538 (define sbcl-slynk-mrepl
 539   (package
 540     (inherit sbcl-slynk-fancy-inspector)
 541     (name "sbcl-slynk-mrepl")
 542     (arguments
 543      (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
 544        ((#:asd-system-name _ #f) "slynk/mrepl")))))
 545
 546 (define ecl-slynk-mrepl
 547   (sbcl-package->ecl-package sbcl-slynk-mrepl))
 548
 549 (define sbcl-slynk-trace-dialog
 550   (package
 551     (inherit sbcl-slynk-arglists)
 552     (name "sbcl-slynk-trace-dialog")
 553     (arguments
 554      (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
 555        ((#:asd-system-name _ #f) "slynk/trace-dialog")))))
 556
 557 (define ecl-slynk-trace-dialog
 558   (sbcl-package->ecl-package sbcl-slynk-trace-dialog))
 559
 560 (define sbcl-slynk-profiler
 561   (package
 562     (inherit sbcl-slynk-arglists)
 563     (name "sbcl-slynk-profiler")
 564     (arguments
 565      (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
 566        ((#:asd-system-name _ #f) "slynk/profiler")))))
 567
 568 (define ecl-slynk-profiler
 569   (sbcl-package->ecl-package sbcl-slynk-profiler))
 570
 571 (define sbcl-slynk-stickers
 572   (package
 573     (inherit sbcl-slynk-arglists)
 574     (name "sbcl-slynk-stickers")
 575     (arguments
 576      (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
 577        ((#:asd-system-name _ #f) "slynk/stickers")))))
 578
 579 (define ecl-slynk-stickers
 580   (sbcl-package->ecl-package sbcl-slynk-stickers))
 581
 582 (define sbcl-slynk-indentation
 583   (package
 584     (inherit sbcl-slynk-arglists)
 585     (name "sbcl-slynk-indentation")
 586     (arguments
 587      (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
 588        ((#:asd-system-name _ #f) "slynk/indentation")))))
 589
 590 (define ecl-slynk-indentation
 591   (sbcl-package->ecl-package sbcl-slynk-indentation))
 592
 593 (define sbcl-slynk-retro
 594   (package
 595     (inherit sbcl-slynk-arglists)
 596     (name "sbcl-slynk-retro")
 597     (arguments
 598      (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
 599        ((#:asd-system-name _ #f) "slynk/retro")))))
 600
 601 (define ecl-slynk-retro
 602   (sbcl-package->ecl-package sbcl-slynk-retro))
 603
 604 (define slynk-systems
 605   '("slynk"
 606     "slynk-util"
 607     "slynk-arglists"
 608     "slynk-fancy-inspector"
 609     "slynk-package-fu"
 610     "slynk-mrepl"
 611     "slynk-profiler"
 612     "slynk-trace-dialog"
 613     "slynk-stickers"
 614     "slynk-indentation"
 615     "slynk-retro"))
 616
 617 (define-public sbcl-slynk
 618   (package
 619     (inherit sbcl-slynk-boot0)
 620     (name "sbcl-slynk")
 621     (inputs
 622      `(("slynk" ,sbcl-slynk-boot0)
 623        ("slynk-util" ,sbcl-slynk-util)
 624        ("slynk-arglists" ,sbcl-slynk-arglists)
 625        ("slynk-fancy-inspector" ,sbcl-slynk-fancy-inspector)
 626        ("slynk-package-fu" ,sbcl-slynk-package-fu)
 627        ("slynk-mrepl" ,sbcl-slynk-mrepl)
 628        ("slynk-profiler" ,sbcl-slynk-profiler)
 629        ("slynk-trace-dialog" ,sbcl-slynk-trace-dialog)
 630        ("slynk-stickers" ,sbcl-slynk-stickers)
 631        ("slynk-indentation" ,sbcl-slynk-indentation)
 632        ("slynk-retro" ,sbcl-slynk-retro)))
 633     (native-inputs `(("sbcl" ,sbcl)))
 634     (build-system trivial-build-system)
 635     (source #f)
 636     (outputs '("out" "image"))
 637     (arguments
 638      `(#:modules ((guix build union)
 639                   (guix build utils)
 640                   (guix build lisp-utils))
 641        #:builder
 642        (begin
 643          (use-modules (ice-9 match)
 644                       (srfi srfi-1)
 645                       (guix build union)
 646                       (guix build lisp-utils))
 647
 648          (union-build
 649           (assoc-ref %outputs "out")
 650           (filter-map
 651            (match-lambda
 652              ((name . path)
 653               (if (string-prefix? "slynk" name) path #f)))
 654            %build-inputs))
 655
 656          (prepend-to-source-registry
 657           (string-append (assoc-ref %outputs "out") "//"))
 658
 659          (parameterize ((%lisp-type "sbcl")
 660                         (%lisp (string-append (assoc-ref %build-inputs "sbcl")
 661                                               "/bin/sbcl")))
 662            (build-image (string-append
 663                          (assoc-ref %outputs "image")
 664                          "/bin/slynk")
 665                         %outputs
 666                         #:dependencies ',slynk-systems))
 667          #t)))))
 668
 669 (define-public ecl-slynk
 670   (package
 671     (inherit sbcl-slynk)
 672     (name "ecl-slynk")
 673     (inputs
 674      (map (match-lambda
 675             ((name pkg . _)
 676              (list name (sbcl-package->ecl-package pkg))))
 677           (package-inputs sbcl-slynk)))
 678     (native-inputs '())
 679     (outputs '("out"))
 680     (arguments
 681      '(#:modules ((guix build union))
 682        #:builder
 683        (begin
 684          (use-modules (ice-9 match)
 685                       (guix build union))
 686          (match %build-inputs
 687            (((names . paths) ...)
 688             (union-build (assoc-ref %outputs "out")
 689                          paths)
 690             #t)))))))
 691
 692 (define-public sbcl-parse-js
 693   (let ((commit "fbadc6029bec7039602abfc06c73bb52970998f6")
 694         (revision "1"))
 695     (package
 696       (name "sbcl-parse-js")
 697       (version (string-append "0.0.0-" revision "." (string-take commit 9)))
 698       (source
 699        (origin
 700          (method git-fetch)
 701          (uri (git-reference
 702                (url "http://marijn.haverbeke.nl/git/parse-js")
 703                (commit commit)))
 704          (file-name (string-append name "-" commit "-checkout"))
 705          (sha256
 706           (base32
 707            "1wddrnr5kiya5s3gp4cdq6crbfy9fqcz7fr44p81502sj3bvdv39"))))
 708       (build-system asdf-build-system/sbcl)
 709       (home-page "http://marijnhaverbeke.nl/parse-js/")
 710       (synopsis "Parse JavaScript")
 711       (description "Parse-js is a Common Lisp package for parsing
 712 JavaScript (ECMAScript 3).  It has basic support for ECMAScript 5.")
 713       (license license:zlib))))
 714
 715 (define-public cl-parse-js
 716   (sbcl-package->cl-source-package sbcl-parse-js))
 717
 718 (define-public sbcl-parse-number
 719   (package
 720     (name "sbcl-parse-number")
 721     (version "1.7")
 722     (source
 723      (origin
 724        (method git-fetch)
 725        (uri (git-reference
 726               (url "https://github.com/sharplispers/parse-number/")
 727               (commit (string-append "v" version))))
 728        (file-name (git-file-name name version))
 729        (sha256
 730         (base32
 731          "0sk06ib1bhqv9y39vwnnw44vmbc4b0kvqm37xxmkxd4dwchq82d7"))))
 732     (build-system asdf-build-system/sbcl)
 733     (home-page "http://www.cliki.net/PARSE-NUMBER")
 734     (synopsis "Parse numbers")
 735     (description "@code{parse-number} is a library of functions for parsing
 736 strings into one of the standard Common Lisp number types without using the
 737 reader.  @code{parse-number} accepts an arbitrary string and attempts to parse
 738 the string into one of the standard Common Lisp number types, if possible, or
 739 else @code{parse-number} signals an error of type @code{invalid-number}.")
 740     (license license:bsd-3)))
 741
 742 (define-public cl-parse-number
 743   (sbcl-package->cl-source-package sbcl-parse-number))
 744
 745 (define-public sbcl-iterate
 746   (package
 747     (name "sbcl-iterate")
 748     ;; The latest official release (1.4.3) fails to build so we have to take
 749     ;; the current darcs tarball from quicklisp.
 750     (version "20160825")
 751     (source
 752      (origin
 753        (method url-fetch)
 754        (uri (string-append "http://beta.quicklisp.org/archive/iterate/"
 755                            "2016-08-25/iterate-"
 756                            version "-darcs.tgz"))
 757        (sha256
 758         (base32
 759          "0kvz16gnxnkdz0fy1x8y5yr28nfm7i2qpvix7mgwccdpjmsb4pgm"))))
 760     (build-system asdf-build-system/sbcl)
 761     (native-inputs
 762      `(("rt" ,sbcl-rt)))
 763     (home-page "https://common-lisp.net/project/iterate/")
 764     (synopsis "Iteration construct for Common Lisp")
 765     (description "@code{iterate} is an iteration construct for Common Lisp.
 766 It is similar to the @code{CL:LOOP} macro, with these distinguishing marks:
 767
 768 @itemize
 769 @item it is extensible,
 770 @item it helps editors like Emacs indent iterate forms by having a more
 771   lisp-like syntax, and
 772 @item it isn't part of the ANSI standard for Common Lisp.
 773 @end itemize\n")
 774     (license license:expat)))
 775
 776 (define-public cl-iterate
 777   (sbcl-package->cl-source-package sbcl-iterate))
 778
 779 (define-public ecl-iterate
 780   (sbcl-package->ecl-package sbcl-iterate))
 781
 782 (define-public sbcl-cl-uglify-js
 783   ;; There have been many bug fixes since the 2010 release.
 784   (let ((commit "429c5e1d844e2f96b44db8fccc92d6e8e28afdd5")
 785         (revision "1"))
 786     (package
 787       (name "sbcl-cl-uglify-js")
 788       (version (string-append "0.1-" revision "." (string-take commit 9)))
 789       (source
 790        (origin
 791          (method git-fetch)
 792          (uri (git-reference
 793                (url "https://github.com/mishoo/cl-uglify-js.git")
 794                (commit commit)))
 795          (file-name (git-file-name name version))
 796          (sha256
 797           (base32
 798            "0k39y3c93jgxpr7gwz7w0d8yknn1fdnxrjhd03057lvk5w8js27a"))))
 799       (build-system asdf-build-system/sbcl)
 800       (inputs
 801        `(("sbcl-parse-js" ,sbcl-parse-js)
 802          ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
 803          ("sbcl-cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)
 804          ("sbcl-parse-number" ,sbcl-parse-number)
 805          ("sbcl-iterate" ,sbcl-iterate)))
 806       (home-page "https://github.com/mishoo/cl-uglify-js")
 807       (synopsis "JavaScript compressor library for Common Lisp")
 808       (description "This is a Common Lisp version of UglifyJS, a JavaScript
 809 compressor.  It works on data produced by @code{parse-js} to generate a
 810 @dfn{minified} version of the code.  Currently it can:
 811
 812 @itemize
 813 @item reduce variable names (usually to single letters)
 814 @item join consecutive @code{var} statements
 815 @item resolve simple binary expressions
 816 @item group most consecutive statements using the @code{sequence} operator (comma)
 817 @item remove unnecessary blocks
 818 @item convert @code{IF} expressions in various ways that result in smaller code
 819 @item remove some unreachable code
 820 @end itemize\n")
 821       (license license:zlib))))
 822
 823 (define-public cl-uglify-js
 824   (sbcl-package->cl-source-package sbcl-cl-uglify-js))
 825
 826 (define-public uglify-js
 827   (package
 828     (inherit sbcl-cl-uglify-js)
 829     (name "uglify-js")
 830     (build-system trivial-build-system)
 831     (arguments
 832      `(#:modules ((guix build utils))
 833        #:builder
 834        (let* ((bin    (string-append (assoc-ref %outputs "out") "/bin/"))
 835               (script (string-append bin "uglify-js")))
 836          (use-modules (guix build utils))
 837          (mkdir-p bin)
 838          (with-output-to-file script
 839            (lambda _
 840              (format #t "#!~a/bin/sbcl --script
 841  (require :asdf)
 842  (push (truename \"~a/lib/sbcl\") asdf:*central-registry*)"
 843                      (assoc-ref %build-inputs "sbcl")
 844                      (assoc-ref %build-inputs "sbcl-cl-uglify-js"))
 845              ;; FIXME: cannot use progn here because otherwise it fails to
 846              ;; find cl-uglify-js.
 847              (for-each
 848               write
 849               '(;; Quiet, please!
 850                 (let ((*standard-output* (make-broadcast-stream))
 851                       (*error-output* (make-broadcast-stream)))
 852                   (asdf:load-system :cl-uglify-js))
 853                 (let ((file (cadr *posix-argv*)))
 854                   (if file
 855                       (format t "~a"
 856                               (cl-uglify-js:ast-gen-code
 857                                (cl-uglify-js:ast-mangle
 858                                 (cl-uglify-js:ast-squeeze
 859                                  (with-open-file (in file)
 860                                                  (parse-js:parse-js in))))
 861                                :beautify nil))
 862                       (progn
 863                        (format *error-output*
 864                                "Please provide a JavaScript file.~%")
 865                        (sb-ext:exit :code 1))))))))
 866          (chmod script #o755)
 867          #t)))
 868     (inputs
 869      `(("sbcl" ,sbcl)
 870        ("sbcl-cl-uglify-js" ,sbcl-cl-uglify-js)))
 871     (synopsis "JavaScript compressor")))
 872
 873 (define-public sbcl-cl-strings
 874   (let ((revision "1")
 875         (commit "c5c5cbafbf3e6181d03c354d66e41a4f063f00ae"))
 876     (package
 877       (name "sbcl-cl-strings")
 878       (version (git-version "0.0.0" revision commit))
 879       (source
 880        (origin
 881          (method git-fetch)
 882          (uri (git-reference
 883                (url "https://github.com/diogoalexandrefranco/cl-strings")
 884                (commit commit)))
 885          (sha256
 886           (base32
 887            "00754mfaqallj480lwd346nkfb6ra8pa8xcxcylf4baqn604zlmv"))
 888          (file-name (string-append "cl-strings-" version "-checkout"))))
 889       (build-system asdf-build-system/sbcl)
 890       (synopsis "Portable, dependency-free set of utilities to manipulate strings in Common Lisp")
 891       (description
 892        "@command{cl-strings} is a small, portable, dependency-free set of
 893 utilities that make it even easier to manipulate text in Common Lisp.  It has
 894 100% test coverage and works at least on sbcl, ecl, ccl, abcl and clisp.")
 895       (home-page "https://github.com/diogoalexandrefranco/cl-strings")
 896       (license license:expat))))
 897
 898 (define-public cl-strings
 899   (sbcl-package->cl-source-package sbcl-cl-strings))
 900
 901 (define-public ecl-cl-strings
 902   (sbcl-package->ecl-package sbcl-cl-strings))
 903
 904 (define-public sbcl-trivial-features
 905   (package
 906     (name "sbcl-trivial-features")
 907     (version "0.8")
 908     (source
 909      (origin
 910        (method git-fetch)
 911        (uri (git-reference
 912              (url "https://github.com/trivial-features/trivial-features.git")
 913              (commit (string-append "v" version))))
 914        (file-name (git-file-name "trivial-features" version))
 915        (sha256
 916         (base32 "0ccv7dqyrk55xga78i5vzlic7mdwp28in3g1a8fqhlk6626scsq9"))))
 917     (build-system asdf-build-system/sbcl)
 918     (arguments '(#:tests? #f))
 919     (home-page "http://cliki.net/trivial-features")
 920     (synopsis "Ensures consistency of @code{*FEATURES*} in Common Lisp")
 921     (description "Trivial-features ensures that @code{*FEATURES*} is
 922 consistent across multiple Common Lisp implementations.")
 923     (license license:expat)))
 924
 925 (define-public cl-trivial-features
 926   (sbcl-package->cl-source-package sbcl-trivial-features))
 927
 928 (define-public ecl-trivial-features
 929   (sbcl-package->ecl-package sbcl-trivial-features))
 930
 931 (define-public sbcl-hu.dwim.asdf
 932   (package
 933     (name "sbcl-hu.dwim.asdf")
 934     (version "20190521")
 935     (source
 936      (origin
 937        (method url-fetch)
 938        (uri (string-append "http://beta.quicklisp.org/archive/hu.dwim.asdf/"
 939                            "2019-05-21/hu.dwim.asdf-" version "-darcs.tgz"))
 940        (sha256
 941         (base32
 942          "0rsbv71vyszy8w35yjwb5h6zcmknjq223hkzir79y72qdsc6sabn"))))
 943     (build-system asdf-build-system/sbcl)
 944     (home-page "https://hub.darcs.net/hu.dwim/hu.dwim.asdf")
 945     (synopsis "Extensions to ASDF")
 946     (description "Various ASDF extensions such as attached test and
 947 documentation system, explicit development support, etc.")
 948     (license license:public-domain)))
 949
 950 (define-public cl-hu.dwim.asdf
 951   (sbcl-package->cl-source-package sbcl-hu.dwim.asdf))
 952
 953 (define-public ecl-hu.dwim.asdf
 954   (sbcl-package->ecl-package sbcl-hu.dwim.asdf))
 955
 956 (define-public sbcl-hu.dwim.stefil
 957   (let ((commit "ab6d1aa8995878a1b66d745dfd0ba021090bbcf9"))
 958     (package
 959       (name "sbcl-hu.dwim.stefil")
 960       (version (git-version "0.0.0" "1" commit))
 961       (source
 962        (origin
 963          (method git-fetch)
 964          (uri
 965           (git-reference
 966            (url "https://gitlab.common-lisp.net/xcvb/hu.dwim.stefil.git")
 967            (commit commit)))
 968          (sha256
 969           (base32 "1d8yccw65zj3zh46cbi3x6nmn1dwdb76s9d0av035077mvyirqqp"))
 970          (file-name (git-file-name "hu.dwim.stefil" version))))
 971       (build-system asdf-build-system/sbcl)
 972       (native-inputs
 973        `(("asdf:cl-hu.dwim.asdf" ,sbcl-hu.dwim.asdf)))
 974       (inputs
 975        `(("sbcl-alexandria" ,sbcl-alexandria)))
 976       (home-page "https://hub.darcs.net/hu.dwim/hu.dwim.stefil")
 977       (synopsis "Simple test framework")
 978       (description "Stefil is a simple test framework for Common Lisp,
 979 with a focus on interactive development.")
 980       (license license:public-domain))))
 981
 982 (define-public cl-hu.dwim.stefil
 983   (sbcl-package->cl-source-package sbcl-hu.dwim.stefil))
 984
 985 (define-public ecl-hu.dwim.stefil
 986   (sbcl-package->ecl-package sbcl-hu.dwim.stefil))
 987
 988 (define-public sbcl-babel
 989   (package
 990     (name "sbcl-babel")
 991     (version "0.5.0")
 992     (source
 993      (origin
 994        (method git-fetch)
 995        (uri (git-reference
 996              (url "https://github.com/cl-babel/babel.git")
 997              (commit (string-append "v" version))))
 998        (file-name (git-file-name "babel" version))
 999        (sha256
1000         (base32 "139a8rn2gnhj082n8jg01gc8fyr63hkj57hgrnmb3d1r327yc77f"))))
1001     (build-system asdf-build-system/sbcl)
1002     (native-inputs
1003      `(("tests:cl-hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
1004     (inputs
1005      `(("sbcl-alexandria" ,sbcl-alexandria)
1006        ("sbcl-trivial-features" ,sbcl-trivial-features)))
1007     (home-page "https://common-lisp.net/project/babel/")
1008     (synopsis "Charset encoding and decoding library")
1009     (description "Babel is a charset encoding and decoding library, not unlike
1010 GNU libiconv, but completely written in Common Lisp.")
1011     (license license:expat)))
1012
1013 (define-public cl-babel
1014   (sbcl-package->cl-source-package sbcl-babel))
1015
1016 (define-public ecl-babel
1017   (sbcl-package->ecl-package sbcl-babel))
1018
1019 (define-public sbcl-cl-yacc
1020   (package
1021     (name "sbcl-cl-yacc")
1022     (version "0.3")
1023     (source
1024      (origin
1025        (method git-fetch)
1026        (uri (git-reference
1027              (url "https://github.com/jech/cl-yacc")
1028              (commit (string-append "cl-yacc-" version))))
1029        (sha256
1030         (base32
1031          "16946pzf8vvadnyfayvj8rbh4zjzw90h0azz2qk1mxrvhh5wklib"))
1032        (file-name (string-append "cl-yacc-" version "-checkout"))))
1033     (build-system asdf-build-system/sbcl)
1034     (arguments
1035      `(#:asd-file "yacc.asd"
1036        #:asd-system-name "yacc"))
1037     (synopsis "LALR(1) parser generator for Common Lisp, similar in spirit to Yacc")
1038     (description
1039      "CL-Yacc is a LALR(1) parser generator for Common Lisp, similar in spirit
1040 to AT&T Yacc, Berkeley Yacc, GNU Bison, Zebu, lalr.cl or lalr.scm.
1041
1042 CL-Yacc uses the algorithm due to Aho and Ullman, which is the one also used
1043 by AT&T Yacc, Berkeley Yacc and Zebu.  It does not use the faster algorithm due
1044 to DeRemer and Pennello, which is used by Bison and lalr.scm (not lalr.cl).")
1045     (home-page "https://www.irif.fr/~jch//software/cl-yacc/")
1046     (license license:expat)))
1047
1048 (define-public cl-yacc
1049   (sbcl-package->cl-source-package sbcl-cl-yacc))
1050
1051 (define-public ecl-cl-yacc
1052   (sbcl-package->ecl-package sbcl-cl-yacc))
1053
1054 (define-public sbcl-jpl-util
1055   (let ((commit "0311ed374e19a49d43318064d729fe3abd9a3b62"))
1056     (package
1057       (name "sbcl-jpl-util")
1058       (version "20151005")
1059       (source
1060        (origin
1061          (method git-fetch)
1062          (uri (git-reference
1063                ;; Quicklisp uses this fork.
1064                (url "https://github.com/hawkir/cl-jpl-util")
1065                (commit commit)))
1066          (file-name
1067           (git-file-name "jpl-util" version))
1068          (sha256
1069           (base32
1070            "0nc0rk9n8grkg3045xsw34whmcmddn2sfrxki4268g7kpgz0d2yz"))))
1071       (build-system asdf-build-system/sbcl)
1072       (synopsis "Collection of Common Lisp utility functions and macros")
1073       (description
1074        "@command{cl-jpl-util} is a collection of Common Lisp utility functions
1075 and macros, primarily for software projects written in CL by the author.")
1076       (home-page "https://www.thoughtcrime.us/software/cl-jpl-util/")
1077       (license license:isc))))
1078
1079 (define-public cl-jpl-util
1080   (sbcl-package->cl-source-package sbcl-jpl-util))
1081
1082 (define-public ecl-jpl-util
1083   (sbcl-package->ecl-package sbcl-jpl-util))
1084
1085 (define-public sbcl-jpl-queues
1086   (package
1087     (name "sbcl-jpl-queues")
1088     (version "0.1")
1089     (source
1090      (origin
1091        (method url-fetch)
1092        (uri (string-append
1093              "http://www.thoughtcrime.us/software/jpl-queues/jpl-queues-"
1094              version
1095              ".tar.gz"))
1096        (sha256
1097         (base32
1098          "1wvvv7j117h9a42qaj1g4fh4mji28xqs7s60rn6d11gk9jl76h96"))))
1099     (build-system asdf-build-system/sbcl)
1100     (inputs
1101      `(("jpl-util" ,sbcl-jpl-util)
1102        ("bordeaux-threads" ,sbcl-bordeaux-threads)))
1103     (arguments
1104      ;; Tests seem to be broken.
1105      `(#:tests? #f))
1106     (synopsis "Common Lisp library implementing a few different kinds of queues")
1107     (description
1108      "A Common Lisp library implementing a few different kinds of queues:
1109
1110 @itemize
1111 @item Bounded and unbounded FIFO queues.
1112 @item Lossy bounded FIFO queues that drop elements when full.
1113 @item Unbounded random-order queues that use less memory than unbounded FIFO queues.
1114 @end itemize
1115
1116 Additionally, a synchronization wrapper is provided to make any queue
1117 conforming to the @command{jpl-queues} API thread-safe for lightweight
1118 multithreading applications.  (See Calispel for a more sophisticated CL
1119 multithreaded message-passing library with timeouts and alternation among
1120 several blockable channels.)")
1121     (home-page "https://www.thoughtcrime.us/software/jpl-queues/")
1122     (license license:isc)))
1123
1124 (define-public cl-jpl-queues
1125   (sbcl-package->cl-source-package sbcl-jpl-queues))
1126
1127 (define-public ecl-jpl-queues
1128   (sbcl-package->ecl-package sbcl-jpl-queues))
1129
1130 (define-public sbcl-eos
1131   (let ((commit "b0faca83781ead9a588661e37bd47f90362ccd94"))
1132     (package
1133       (name "sbcl-eos")
1134       (version (git-version "0.0.0" "1" commit))
1135       (source
1136        (origin
1137          (method git-fetch)
1138          (uri (git-reference
1139                (url "https://github.com/adlai/Eos")
1140                (commit commit)))
1141          (sha256
1142           (base32
1143            "1bq8cfg087iyxmxi1mwgx5cfgy3b8ydrf81xljcis8qbgb2vszph"))
1144          (file-name (git-file-name "eos" version))))
1145       (build-system asdf-build-system/sbcl)
1146       (synopsis "Unit Testing for Common Lisp")
1147       (description
1148        "Eos was a unit testing library for Common Lisp.
1149 It began as a fork of FiveAM; however, FiveAM development has continued, while
1150 that of Eos has not.  Thus, Eos is now deprecated in favor of FiveAM.")
1151       (home-page "https://github.com/adlai/Eos")
1152       (license license:expat))))
1153
1154 (define-public cl-eos
1155   (sbcl-package->cl-source-package sbcl-eos))
1156
1157 (define-public ecl-eos
1158   (sbcl-package->ecl-package sbcl-eos))
1159
1160 (define-public sbcl-esrap
1161   (let ((commit "133be8b05c2aae48696fe5b739eea2fa573fa48d"))
1162     (package
1163       (name "sbcl-esrap")
1164       (version (git-version "0.0.0" "1" commit))
1165       (source
1166        (origin
1167          (method git-fetch)
1168          (uri (git-reference
1169                (url "https://github.com/nikodemus/esrap")
1170                (commit commit)))
1171          (sha256
1172           (base32
1173            "02d5clihsdryhf7pix8c5di2571fdsffh75d40fkzhws90r5mksl"))
1174          (file-name (git-file-name "esrap" version))))
1175       (build-system asdf-build-system/sbcl)
1176       (native-inputs
1177        `(("eos" ,sbcl-eos)))            ;For testing only.
1178       (inputs
1179        `(("alexandria" ,sbcl-alexandria)))
1180       (synopsis "Common Lisp packrat parser")
1181       (description
1182        "A packrat parser for Common Lisp.
1183 In addition to regular Packrat / Parsing Grammar / TDPL features ESRAP supports:
1184
1185 @itemize
1186 @item dynamic redefinition of nonterminals
1187 @item inline grammars
1188 @item semantic predicates
1189 @item introspective facilities (describing grammars, tracing, setting breaks)
1190 @end itemize\n")
1191       (home-page "https://nikodemus.github.io/esrap/")
1192       (license license:expat))))
1193
1194 (define-public cl-esrap
1195   (sbcl-package->cl-source-package sbcl-esrap))
1196
1197 (define-public ecl-esrap
1198   (sbcl-package->ecl-package sbcl-esrap))
1199
1200 (define-public sbcl-split-sequence
1201   (package
1202     (name "sbcl-split-sequence")
1203     (version "1.4.1")
1204     (source
1205      (origin
1206        (method git-fetch)
1207        (uri (git-reference
1208              (url "https://github.com/sharplispers/split-sequence")
1209              (commit (string-append "v" version))))
1210        (sha256
1211         (base32
1212          "0c3zp6b7fmmp93sfhq112ind4zkld49ycw68z409xpnz3gc0wpf0"))
1213        (file-name (git-file-name "split-sequence" version))))
1214     (build-system asdf-build-system/sbcl)
1215     (arguments
1216      ;; TODO: Tests seem to be broken.
1217      ;; https://github.com/sharplispers/split-sequence/issues/8
1218      `(#:tests? #f))
1219     (synopsis "Member of the Common Lisp Utilities family of programs")
1220     (description
1221      "Splits sequence into a list of subsequences delimited by objects
1222 satisfying the test.")
1223     (home-page "https://cliki.net/split-sequence")
1224     (license license:expat)))
1225
1226 (define-public cl-split-sequence
1227   (sbcl-package->cl-source-package sbcl-split-sequence))
1228
1229 (define-public ecl-split-sequence
1230   (sbcl-package->ecl-package sbcl-split-sequence))
1231
1232 (define-public sbcl-html-encode
1233   (package
1234     (name "sbcl-html-encode")
1235     (version "1.2")
1236     (source
1237      (origin
1238        (method url-fetch)
1239        (uri (string-append
1240              "http://beta.quicklisp.org/archive/html-encode/2010-10-06/html-encode-"
1241              version ".tgz"))
1242        (sha256
1243         (base32
1244          "06mf8wn95yf5swhmzk4vp0xr4ylfl33dgfknkabbkd8n6jns8gcf"))
1245        (file-name (string-append "colorize" version "-checkout"))))
1246     (build-system asdf-build-system/sbcl)
1247     (synopsis "Common Lisp library for encoding text in various web-savvy encodings")
1248     (description
1249      "A library for encoding text in various web-savvy encodings.")
1250     (home-page "http://quickdocs.org/html-encode/")
1251     (license license:expat)))
1252
1253 (define-public cl-html-encode
1254   (sbcl-package->cl-source-package sbcl-html-encode))
1255
1256 (define-public ecl-html-encode
1257   (sbcl-package->ecl-package sbcl-html-encode))
1258
1259 (define-public sbcl-colorize
1260   (let ((commit "ea676b584e0899cec82f21a9e6871172fe3c0eb5"))
1261     (package
1262       (name "sbcl-colorize")
1263       (version (git-version "0.0.0" "1" commit))
1264       (source
1265        (origin
1266          (method git-fetch)
1267          (uri (git-reference
1268                (url "https://github.com/kingcons/colorize")
1269                (commit commit)))
1270          (sha256
1271           (base32
1272            "1pdg4kiaczmr3ivffhirp7m3lbr1q27rn7dhaay0vwghmi31zcw9"))
1273          (file-name (git-file-name "colorize" version))))
1274       (build-system asdf-build-system/sbcl)
1275       (inputs
1276        `(("alexandria" ,sbcl-alexandria)
1277          ("split-sequence" ,sbcl-split-sequence)
1278          ("html-encode" ,sbcl-html-encode)))
1279       (synopsis "Common Lisp for syntax highlighting")
1280       (description
1281        "@command{colorize} is a Lisp library for syntax highlighting
1282 supporting the following languages: Common Lisp, Emacs Lisp, Scheme, Clojure,
1283 C, C++, Java, Python, Erlang, Haskell, Objective-C, Diff, Webkit.")
1284       (home-page "https://github.com/kingcons/colorize")
1285       ;; TODO: Missing license?
1286       (license license:expat))))
1287
1288 (define-public cl-colorize
1289   (sbcl-package->cl-source-package sbcl-colorize))
1290
1291 (define-public ecl-colorize
1292   (sbcl-package->ecl-package sbcl-colorize))
1293
1294 (define-public sbcl-3bmd
1295   (let ((commit "192ea13435b605a96ef607df51317056914cabbd"))
1296     (package
1297       (name "sbcl-3bmd")
1298       (version (git-version "0.0.0" "1" commit))
1299       (source
1300        (origin
1301          (method git-fetch)
1302          (uri (git-reference
1303                (url "https://github.com/3b/3bmd")
1304                (commit commit)))
1305          (sha256
1306           (base32
1307            "1rgv3gi7wf963ikmmpk132wgn0icddf226gq3bmcnk1fr3v9gf2f"))
1308          (file-name (git-file-name "3bmd" version))))
1309       (build-system asdf-build-system/sbcl)
1310       (arguments
1311        ;; FIXME: We need to specify the name because the build-system thinks
1312        ;; "3" is a version marker.
1313        `(#:asd-system-name "3bmd"))
1314       (inputs
1315        `(("esrap" ,sbcl-esrap)
1316          ("split-sequence" ,sbcl-split-sequence)))
1317       (synopsis "Markdown processor in Command Lisp using esrap parser")
1318       (description
1319        "Common Lisp Markdown -> HTML converter, using @command{esrap} for
1320 parsing, and grammar based on @command{peg-markdown}.")
1321       (home-page "https://github.com/3b/3bmd")
1322       (license license:expat))))
1323
1324 (define-public cl-3bmd
1325   (sbcl-package->cl-source-package sbcl-3bmd))
1326
1327 (define-public ecl-3bmd
1328   (sbcl-package->ecl-package sbcl-3bmd))
1329
1330 (define-public sbcl-3bmd-ext-code-blocks
1331   (let ((commit "192ea13435b605a96ef607df51317056914cabbd"))
1332     (package
1333       (inherit sbcl-3bmd)
1334       (name "sbcl-3bmd-ext-code-blocks")
1335       (arguments
1336        `(#:asd-system-name "3bmd-ext-code-blocks"
1337          #:asd-file "3bmd-ext-code-blocks.asd"))
1338       (inputs
1339        `(("3bmd" ,sbcl-3bmd)
1340          ("colorize" ,sbcl-colorize)))
1341       (synopsis "3bmd extension which adds support for GitHub-style fenced
1342 code blocks")
1343       (description
1344        "3bmd extension which adds support for GitHub-style fenced code blocks,
1345 with @command{colorize} support."))))
1346
1347 (define-public cl-3bmd-ext-code-blocks
1348   (sbcl-package->cl-source-package sbcl-3bmd-ext-code-blocks))
1349
1350 (define-public ecl-3bmd-ext-code-blocks
1351   (sbcl-package->ecl-package sbcl-3bmd-ext-code-blocks))
1352
1353 (define-public sbcl-cl-fad
1354   (package
1355     (name "sbcl-cl-fad")
1356     (version "0.7.5")
1357     (source
1358      (origin
1359        (method git-fetch)
1360        (uri (git-reference
1361              (url "https://github.com/edicl/cl-fad/")
1362              (commit (string-append "v" version))))
1363        (sha256
1364         (base32
1365          "1l1qmk9z57q84bz5r04sxsksggsnd7dgkxlybzh9imz6ma7sm52m"))
1366        (file-name (string-append "cl-fad" version "-checkout"))))
1367     (build-system asdf-build-system/sbcl)
1368     (inputs
1369      `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
1370     (synopsis "Portable pathname library for Common Lisp")
1371     (description
1372      "CL-FAD (for \"Files and Directories\") is a thin layer atop Common
1373 Lisp's standard pathname functions.  It is intended to provide some
1374 unification between current CL implementations on Windows, OS X, Linux, and
1375 Unix.  Most of the code was written by Peter Seibel for his book Practical
1376 Common Lisp.")
1377     (home-page "https://edicl.github.io/cl-fad/")
1378     (license license:bsd-2)))
1379
1380 (define-public cl-fad
1381   (sbcl-package->cl-source-package sbcl-cl-fad))
1382
1383 (define-public ecl-cl-fad
1384   (sbcl-package->ecl-package sbcl-cl-fad))
1385
1386 (define-public sbcl-rt
1387   (package
1388     (name "sbcl-rt")
1389     (version "1990.12.19")
1390     (source
1391      (origin
1392        (method url-fetch)
1393        (uri (string-append "http://beta.quicklisp.org/archive/rt/2010-10-06/rt-"
1394                            "20101006-git" ".tgz"))
1395        (sha256
1396         (base32
1397          "1jncar0xwkqk8yrc2dln389ivvgzs7ijdhhs3zpfyi5d21f0qa1v"))))
1398     (build-system asdf-build-system/sbcl)
1399     (synopsis "MIT Regression Tester")
1400     (description
1401      "RT provides a framework for writing regression test suites.")
1402     (home-page "https://github.com/sharplispers/nibbles")
1403     (license license:unlicense)))
1404
1405 (define-public cl-rt
1406   (sbcl-package->cl-source-package sbcl-rt))
1407
1408 (define-public ecl-rt
1409   (sbcl-package->ecl-package sbcl-rt))
1410
1411 (define-public sbcl-nibbles
1412   (package
1413     (name "sbcl-nibbles")
1414     (version "0.14")
1415     (source
1416      (origin
1417        (method git-fetch)
1418        (uri (git-reference
1419              (url "https://github.com/sharplispers/nibbles/")
1420              (commit (string-append "v" version))))
1421        (sha256
1422         (base32
1423          "1v7qfgpvdr6nz7v63dj69d26dis0kff3rd8xamr1llfdvza2pm8f"))
1424        (file-name (git-file-name "nibbles" version))))
1425     (build-system asdf-build-system/sbcl)
1426     (native-inputs
1427      ;; Tests only.
1428      `(("rt" ,sbcl-rt)))
1429     (synopsis "Common Lisp library for accessing octet-addressed blocks of data")
1430     (description
1431      "When dealing with network protocols and file formats, it's common to
1432 have to read or write 16-, 32-, or 64-bit datatypes in signed or unsigned
1433 flavors.  Common Lisp sort of supports this by specifying :element-type for
1434 streams, but that facility is underspecified and there's nothing similar for
1435 read/write from octet vectors.  What most people wind up doing is rolling their
1436 own small facility for their particular needs and calling it a day.
1437
1438 This library attempts to be comprehensive and centralize such
1439 facilities.  Functions to read 16-, 32-, and 64-bit quantities from octet
1440 vectors in signed or unsigned flavors are provided; these functions are also
1441 SETFable.  Since it's sometimes desirable to read/write directly from streams,
1442 functions for doing so are also provided.  On some implementations,
1443 reading/writing IEEE singles/doubles (i.e. single-float and double-float) will
1444 also be supported.")
1445     (home-page "https://github.com/sharplispers/nibbles")
1446     (license license:bsd-3)))
1447
1448 (define-public cl-nibbles
1449   (sbcl-package->cl-source-package sbcl-nibbles))
1450
1451 (define-public ecl-nibbles
1452   (sbcl-package->ecl-package sbcl-nibbles))
1453
1454 (define-public sbcl-ironclad
1455   (package
1456     (name "sbcl-ironclad")
1457     (version "0.46")
1458     (source
1459      (origin
1460        (method git-fetch)
1461        (uri (git-reference
1462              (url "https://github.com/sharplispers/ironclad/")
1463              (commit (string-append "v" version))))
1464        (sha256
1465         (base32
1466          "1s391awi2lsl7m1dbjirgpkm4p9p8wd076pakgvsvpn1rrznisnd"))
1467        (file-name (git-file-name name version))))
1468     (build-system asdf-build-system/sbcl)
1469     (native-inputs
1470      ;; Tests only.
1471      `(("rt" ,sbcl-rt)))
1472     (inputs
1473      `(("bordeaux-threads" ,sbcl-bordeaux-threads)
1474        ("flexi-streams" ,sbcl-flexi-streams)
1475        ("nibbles" ,sbcl-nibbles)))
1476     (synopsis "Cryptographic toolkit written in Common Lisp")
1477     (description
1478      "Ironclad is a cryptography library written entirely in Common Lisp.
1479 It includes support for several popular ciphers, digests, MACs and public key
1480 cryptography algorithms.  For several implementations that support Gray
1481 streams, support is included for convenient stream wrappers.")
1482     (home-page "https://github.com/sharplispers/ironclad")
1483     (license license:bsd-3)))
1484
1485 (define-public cl-ironclad
1486   (sbcl-package->cl-source-package sbcl-ironclad))
1487
1488 (define-public ecl-ironclad
1489   (sbcl-package->ecl-package sbcl-ironclad))
1490
1491 (define-public sbcl-named-readtables
1492   (let ((commit "4dfb89fa1af6b305b6492b8af042f5190c11e9fc")
1493         (revision "1"))
1494     (package
1495       (name "sbcl-named-readtables")
1496       (version (string-append "0.9-" revision "." (string-take commit 7)))
1497       (source
1498        (origin
1499          (method git-fetch)
1500          (uri (git-reference
1501                (url "https://github.com/melisgl/named-readtables.git")
1502                (commit commit)))
1503          (sha256
1504           (base32 "083kgh5462iqbb4px6kq8s7sggvpvkm36hx4qi9rnaw53b6ilqkk"))
1505          (file-name (git-file-name "named-readtables" version))))
1506       (build-system asdf-build-system/sbcl)
1507       (arguments
1508        ;; Tests seem to be broken.
1509        `(#:tests? #f))
1510       (home-page "https://github.com/melisgl/named-readtables/")
1511       (synopsis "Library that creates a namespace for named readtables")
1512       (description "Named readtables is a library that creates a namespace for
1513 named readtables, which is akin to package namespacing in Common Lisp.")
1514       (license license:bsd-3))))
1515
1516 (define-public cl-named-readtables
1517   (sbcl-package->cl-source-package sbcl-named-readtables))
1518
1519 (define-public ecl-named-readtables
1520   (sbcl-package->ecl-package sbcl-named-readtables))
1521
1522 (define-public sbcl-pythonic-string-reader
1523   (let ((commit "47a70ba1e32362e03dad6ef8e6f36180b560f86a"))
1524     (package
1525       (name "sbcl-pythonic-string-reader")
1526       (version (git-version "0.0.0" "1" commit))
1527       (source
1528        (origin
1529          (method git-fetch)
1530          (uri (git-reference
1531                (url "https://github.com/smithzvk/pythonic-string-reader/")
1532                (commit commit)))
1533          (sha256
1534           (base32 "1b5iryqw8xsh36swckmz8rrngmc39k92si33fgy5pml3n9l5rq3j"))
1535          (file-name (git-file-name "pythonic-string-reader" version))))
1536       (build-system asdf-build-system/sbcl)
1537       (inputs
1538        `(("named-readtables" ,sbcl-named-readtables)))
1539       (home-page "https://github.com/smithzvk/pythonic-string-reader")
1540       (synopsis "Read table modification inspired by Python's three quote strings")
1541       (description "This piece of code sets up some reader macros that make it
1542 simpler to input string literals which contain backslashes and double quotes
1543 This is very useful for writing complicated docstrings and, as it turns out,
1544 writing code that contains string literals that contain code themselves.")
1545       (license license:bsd-3))))
1546
1547 (define-public cl-pythonic-string-reader
1548   (sbcl-package->cl-source-package sbcl-pythonic-string-reader))
1549
1550 (define-public ecl-pythonic-string-reader
1551   (sbcl-package->ecl-package sbcl-pythonic-string-reader))
1552
1553 ;; SLIME does not have a ASDF system definition to build all of Swank.  As a
1554 ;; result, the asdf-build-system/sbcl will produce an almost empty package.
1555 ;; Some work was done to fix this at
1556 ;; https://github.com/sionescu/slime/tree/swank-asdf but it was never merged
1557 ;; and is now lagging behind.  Building SBCL fasls might not be worth the
1558 ;; hassle, so let's just ship the source then.
1559 (define-public cl-slime-swank
1560   (package
1561     (name "cl-slime-swank")
1562     (version "2.24")
1563     (source
1564      (origin
1565        (file-name (string-append name "-" version ".tar.gz"))
1566        (method git-fetch)
1567        (uri (git-reference
1568              (url "https://github.com/slime/slime/")
1569              (commit (string-append "v" version))))
1570        (sha256
1571         (base32
1572          "0js24x42m7b5iymb4rxz501dff19vav5pywnzv50b673rbkaaqvh"))))
1573     (build-system asdf-build-system/source)
1574     (home-page "https://github.com/slime/slime")
1575     (synopsis "Common Lisp Swank server")
1576     (description
1577      "This is only useful if you want to start a Swank server in a Lisp
1578 processes that doesn't run under Emacs.  Lisp processes created by
1579 @command{M-x slime} automatically start the server.")
1580     (license (list license:gpl2+ license:public-domain))))
1581
1582 (define-public sbcl-slime-swank
1583   (deprecated-package "sbcl-slime-swank" cl-slime-swank))
1584
1585 (define-public sbcl-mgl-pax
1586   (let ((commit "818448418d6b9de74620f606f5b23033c6082769"))
1587     (package
1588       (name "sbcl-mgl-pax")
1589       (version (git-version "0.0.0" "1" commit))
1590       (source
1591        (origin
1592          (method git-fetch)
1593          (uri (git-reference
1594                (url "https://github.com/melisgl/mgl-pax")
1595                (commit commit)))
1596          (sha256
1597           (base32
1598            "1p97zfkh130bdxqqxwaw2j9psv58751wakx7czbfpq410lg7dd7i"))
1599          (file-name (git-file-name "mgl-pax" version))))
1600       (build-system asdf-build-system/sbcl)
1601       (inputs
1602        `(("3bmd" ,sbcl-3bmd)
1603          ("3bmd-ext-code-blocks" ,sbcl-3bmd-ext-code-blocks)
1604          ("babel" ,sbcl-babel)
1605          ("cl-fad" ,sbcl-cl-fad)
1606          ("ironclad" ,sbcl-ironclad)
1607          ("named-readtables" ,sbcl-named-readtables)
1608          ("pythonic-string-reader" ,sbcl-pythonic-string-reader)
1609          ("swank" ,cl-slime-swank)))
1610       (synopsis "Exploratory programming environment and documentation generator")
1611       (description
1612        "PAX provides an extremely poor man's Explorable Programming
1613 environment.  Narrative primarily lives in so called sections that mix markdown
1614 docstrings with references to functions, variables, etc, all of which should
1615 probably have their own docstrings.
1616
1617 The primary focus is on making code easily explorable by using SLIME's
1618 @command{M-.} (@command{slime-edit-definition}).  See how to enable some
1619 fanciness in Emacs Integration.  Generating documentation from sections and all
1620 the referenced items in Markdown or HTML format is also implemented.
1621
1622 With the simplistic tools provided, one may accomplish similar effects as with
1623 Literate Programming, but documentation is generated from code, not vice versa
1624 and there is no support for chunking yet.  Code is first, code must look
1625 pretty, documentation is code.")
1626       (home-page "http://quotenil.com/")
1627       (license license:expat))))
1628
1629 (define-public cl-mgl-pax
1630   (sbcl-package->cl-source-package sbcl-mgl-pax))
1631
1632 (define-public ecl-mgl-pax
1633   (sbcl-package->ecl-package sbcl-mgl-pax))
1634
1635 (define-public sbcl-lisp-unit
1636   (let ((commit "89653a232626b67400bf9a941f9b367da38d3815"))
1637     (package
1638       (name "sbcl-lisp-unit")
1639       (version (git-version "0.0.0" "1" commit))
1640       (source
1641        (origin
1642          (method git-fetch)
1643          (uri (git-reference
1644                (url "https://github.com/OdonataResearchLLC/lisp-unit")
1645                (commit commit)))
1646          (sha256
1647           (base32
1648            "0p6gdmgr7p383nvd66c9y9fp2bjk4jx1lpa5p09g43hr9y9pp9ry"))
1649          (file-name (git-file-name "lisp-unit" version))))
1650       (build-system asdf-build-system/sbcl)
1651       (synopsis "Common Lisp Test framework inspired by JUnit to be simple of use")
1652       (description
1653        "@command{lisp-unit} is a Common Lisp library that supports unit
1654 testing.  It is an extension of the library written by Chris Riesbeck.")
1655       (home-page "https://github.com/OdonataResearchLLC/lisp-unit")
1656       (license license:expat))))
1657
1658 (define-public cl-lisp-unit
1659   (sbcl-package->cl-source-package sbcl-lisp-unit))
1660
1661 (define-public ecl-lisp-unit
1662   (sbcl-package->ecl-package sbcl-lisp-unit))
1663
1664 (define-public sbcl-anaphora
1665   (package
1666     (name "sbcl-anaphora")
1667     (version "0.9.6")
1668     (source
1669      (origin
1670        (method git-fetch)
1671        (uri (git-reference
1672              (url "https://github.com/tokenrove/anaphora")
1673              (commit version)))
1674        (sha256
1675         (base32
1676          "19wfrk3asimznkli0x2rfy637hwpdgqyvwj3vhq9x7vjvyf5vv6x"))
1677        (file-name (git-file-name "anaphora" version))))
1678     (build-system asdf-build-system/sbcl)
1679     (native-inputs
1680      `(("rt" ,sbcl-rt)))
1681     (synopsis "The anaphoric macro collection from Hell")
1682     (description
1683      "Anaphora is the anaphoric macro collection from Hell: it includes many
1684 new fiends in addition to old friends like @command{aif} and
1685 @command{awhen}.")
1686     (home-page "https://github.com/tokenrove/anaphora")
1687     (license license:public-domain)))
1688
1689 (define-public cl-anaphora
1690   (sbcl-package->cl-source-package sbcl-anaphora))
1691
1692 (define-public ecl-anaphora
1693   (sbcl-package->ecl-package sbcl-anaphora))
1694
1695 (define-public sbcl-lift
1696   (let ((commit "7d49a66c62759535624037826891152223d4206c"))
1697     (package
1698       (name "sbcl-lift")
1699       (version (git-version "1.7.1" "1" commit))
1700       (source
1701        (origin
1702          (method git-fetch)
1703          (uri (git-reference
1704                (url "https://github.com/gwkkwg/lift")
1705                (commit commit)))
1706          (sha256
1707           (base32
1708            "127v5avpz1i4m0lkaxqrq8hrl69rdazqaxf6s8awf0nd7wj2g4dp"))
1709          (file-name (git-file-name "lift" version))
1710          (modules '((guix build utils)))
1711          (snippet
1712           ;; Don't keep the bundled website
1713           `(begin
1714              (delete-file-recursively "website")
1715              #t))))
1716       (build-system asdf-build-system/sbcl)
1717       (arguments
1718        ;; The tests require a debugger, but we run with the debugger disabled.
1719        '(#:tests? #f))
1720       (synopsis "LIsp Framework for Testing")
1721       (description
1722        "The LIsp Framework for Testing (LIFT) is a unit and system test tool for LISP.
1723 Though inspired by SUnit and JUnit, it's built with Lisp in mind.  In LIFT,
1724 testcases are organized into hierarchical testsuites each of which can have
1725 its own fixture.  When run, a testcase can succeed, fail, or error.  LIFT
1726 supports randomized testing, benchmarking, profiling, and reporting.")
1727       (home-page "https://github.com/gwkkwg/lift")
1728       (license license:expat))))
1729
1730 (define-public cl-lift
1731   (sbcl-package->cl-source-package sbcl-lift))
1732
1733 (define-public ecl-lift
1734   (sbcl-package->ecl-package sbcl-lift))
1735
1736 (define-public sbcl-let-plus
1737   (let ((commit "5f14af61d501ecead02ec6b5a5c810efc0c9fdbb"))
1738     (package
1739       (name "sbcl-let-plus")
1740       (version (git-version "0.0.0" "1" commit))
1741       (source
1742        (origin
1743          (method git-fetch)
1744          (uri (git-reference
1745                (url "https://github.com/sharplispers/let-plus")
1746                (commit commit)))
1747          (sha256
1748           (base32
1749            "0i050ca2iys9f5mb7dgqgqdxfnc3b0rnjdwv95sqd490vkiwrsaj"))
1750          (file-name (git-file-name "let-plus" version))))
1751       (build-system asdf-build-system/sbcl)
1752       (inputs
1753        `(("alexandria" ,sbcl-alexandria)
1754          ("anaphora" ,sbcl-anaphora)))
1755       (native-inputs
1756        `(("lift" ,sbcl-lift)))
1757       (synopsis "Destructuring extension of let*")
1758       (description
1759        "This library implements the let+ macro, which is a dectructuring
1760 extension of let*.  It features:
1761
1762 @itemize
1763 @item Clean, consistent syntax and small implementation (less than 300 LOC,
1764 not counting tests)
1765 @item Placeholder macros allow editor hints and syntax highlighting
1766 @item @command{&ign} for ignored values (in forms where that makes sense)
1767 @item Very easy to extend
1768 @end itemize\n")
1769       (home-page "https://github.com/sharplispers/let-plus")
1770       (license license:boost1.0))))
1771
1772 (define-public cl-let-plus
1773   (sbcl-package->cl-source-package sbcl-let-plus))
1774
1775 (define-public ecl-let-plus
1776   (sbcl-package->ecl-package sbcl-let-plus))
1777
1778 (define-public sbcl-cl-colors
1779   (let ((commit "827410584553f5c717eec6182343b7605f707f75"))
1780     (package
1781       (name "sbcl-cl-colors")
1782       (version (git-version "0.0.0" "1" commit))
1783       (source
1784        (origin
1785          (method git-fetch)
1786          (uri (git-reference
1787                (url "https://github.com/tpapp/cl-colors")
1788                (commit commit)))
1789          (sha256
1790           (base32
1791            "0l446lday4hybsm9bq3jli97fvv8jb1d33abg79vbylpwjmf3y9a"))
1792          (file-name (git-file-name "cl-colors" version))))
1793       (build-system asdf-build-system/sbcl)
1794       (inputs
1795        `(("alexandria" ,sbcl-alexandria)
1796          ("let-plus" ,sbcl-let-plus)))
1797       (synopsis "Simple color library for Common Lisp")
1798       (description
1799        "This is a very simple color library for Common Lisp, providing
1800
1801 @itemize
1802 @item Types for representing colors in HSV and RGB spaces.
1803 @item Simple conversion functions between the above types (and also
1804 hexadecimal representation for RGB).
1805 @item Some predefined colors (currently X11 color names – of course the
1806 library does not depend on X11).Because color in your terminal is nice.
1807 @end itemize
1808
1809 This library is no longer supported by its author.")
1810       (home-page "https://github.com/tpapp/cl-colors")
1811       (license license:boost1.0))))
1812
1813 (define-public cl-colors
1814   (sbcl-package->cl-source-package sbcl-cl-colors))
1815
1816 (define-public ecl-cl-colors
1817   (sbcl-package->ecl-package sbcl-cl-colors))
1818
1819 (define-public sbcl-cl-ansi-text
1820   (let ((commit "53badf7878f27f22f2d4a2a43e6df458e43acbe9"))
1821     (package
1822       (name "sbcl-cl-ansi-text")
1823       (version (git-version "1.0.0" "1" commit))
1824       (source
1825        (origin
1826          (method git-fetch)
1827          (uri (git-reference
1828                (url "https://github.com/pnathan/cl-ansi-text")
1829                (commit commit)))
1830          (sha256
1831           (base32
1832            "11i27n0dbz5lmygiw65zzr8lx0rac6b6yysqranphn31wls6ja3v"))
1833          (file-name (git-file-name "cl-ansi-text" version))))
1834       (build-system asdf-build-system/sbcl)
1835       (inputs
1836        `(("alexandria" ,sbcl-alexandria)
1837          ("cl-colors" ,sbcl-cl-colors)))
1838       (native-inputs
1839        `(("fiveam" ,sbcl-fiveam)))
1840       (synopsis "ANSI terminal color implementation for Common Lisp")
1841       (description
1842        "@command{cl-ansi-text} provides utilities which enable printing to an
1843 ANSI terminal with colored text.  It provides the macro @command{with-color}
1844 which causes everything printed in the body to be displayed with the provided
1845 color.  It further provides functions which will print the argument with the
1846 named color.")
1847       (home-page "https://github.com/pnathan/cl-ansi-text")
1848       (license license:llgpl))))
1849
1850 (define-public cl-ansi-text
1851   (sbcl-package->cl-source-package sbcl-cl-ansi-text))
1852
1853 (define-public ecl-cl-ansi-text
1854   (sbcl-package->ecl-package sbcl-cl-ansi-text))
1855
1856 (define-public sbcl-prove-asdf
1857   (let ((commit "4f9122bd393e63c5c70c1fba23070622317cfaa0"))
1858     (package
1859       (name "sbcl-prove-asdf")
1860       (version (git-version "1.0.0" "1" commit))
1861       (source
1862        (origin
1863          (method git-fetch)
1864          (uri (git-reference
1865                (url "https://github.com/fukamachi/prove")
1866                (commit commit)))
1867          (sha256
1868           (base32
1869            "07sbfw459z8bbjvx1qlmfa8qk2mvbjnnzi2mi0x72blaj8bkl4vc"))
1870          (file-name (git-file-name "prove" version))))
1871       (build-system asdf-build-system/sbcl)
1872       (arguments
1873        `(#:asd-file "prove-asdf.asd"))
1874       (synopsis "Test requirement for the Common Lisp 'prove' library")
1875       (description
1876        "Test requirement for the Common Lisp @command{prove} library.")
1877       (home-page "https://github.com/fukamachi/prove")
1878       (license license:expat))))
1879
1880 (define-public cl-prove-asdf
1881   (sbcl-package->cl-source-package sbcl-prove-asdf))
1882
1883 (define-public ecl-prove-asdf
1884   (sbcl-package->ecl-package sbcl-prove-asdf))
1885
1886 (define-public sbcl-prove
1887   (package
1888     (inherit sbcl-prove-asdf)
1889     (name "sbcl-prove")
1890     (inputs
1891      `(("alexandria" ,sbcl-alexandria)
1892        ("cl-ppcre" ,sbcl-cl-ppcre)
1893        ("cl-ansi-text" ,sbcl-cl-ansi-text)))
1894     (native-inputs
1895      `(("prove-asdf" ,sbcl-prove-asdf)))
1896     (arguments
1897      `(#:asd-file "prove.asd"))
1898     (synopsis "Yet another unit testing framework for Common Lisp")
1899     (description
1900      "This project was originally called @command{cl-test-more}.
1901 @command{prove} is yet another unit testing framework for Common Lisp.  The
1902 advantages of @command{prove} are:
1903
1904 @itemize
1905 @item Various simple functions for testing and informative error messages
1906 @item ASDF integration
1907 @item Extensible test reporters
1908 @item Colorizes the report if it's available (note for SLIME)
1909 @item Reports test durations
1910 @end itemize\n")))
1911
1912 (define-public cl-prove
1913   (sbcl-package->cl-source-package sbcl-prove))
1914
1915 (define-public ecl-prove
1916   (sbcl-package->ecl-package sbcl-prove))
1917
1918 (define-public sbcl-proc-parse
1919   (let ((commit "ac3636834d561bdc2686c956dbd82494537285fd"))
1920     (package
1921       (name "sbcl-proc-parse")
1922       (version (git-version "0.0.0" "1" commit))
1923       (source
1924        (origin
1925          (method git-fetch)
1926          (uri (git-reference
1927                (url "https://github.com/fukamachi/proc-parse")
1928                (commit commit)))
1929          (sha256
1930           (base32
1931            "06rnl0h4cx6xv2wj3jczmmcxqn2703inmmvg1s4npbghmijsybfh"))
1932          (file-name (git-file-name "proc-parse" version))))
1933       (build-system asdf-build-system/sbcl)
1934       (inputs
1935        `(("alexandria" ,sbcl-alexandria)
1936          ("babel" ,sbcl-babel)))
1937       (native-inputs
1938        `(("prove" ,sbcl-prove)
1939          ("prove-asdf" ,sbcl-prove-asdf)))
1940       (arguments
1941        ;; TODO: Tests don't find "proc-parse-test", why?
1942        `(#:tests? #f))
1943       (synopsis "Procedural vector parser")
1944       (description
1945        "This is a string/octets parser library for Common Lisp with speed and
1946 readability in mind.  Unlike other libraries, the code is not a
1947 pattern-matching-like, but a char-by-char procedural parser.")
1948       (home-page "https://github.com/fukamachi/proc-parse")
1949       (license license:bsd-2))))
1950
1951 (define-public cl-proc-parse
1952   (sbcl-package->cl-source-package sbcl-proc-parse))
1953
1954 (define-public ecl-proc-parse
1955   (sbcl-package->ecl-package sbcl-proc-parse))
1956
1957 (define-public sbcl-parse-float
1958   (let ((commit "2aae569f2a4b2eb3bfb5401a959425dcf151b09c"))
1959     (package
1960       (name "sbcl-parse-float")
1961       (version (git-version "0.0.0" "1" commit))
1962       (source
1963        (origin
1964          (method git-fetch)
1965          (uri (git-reference
1966                (url "https://github.com/soemraws/parse-float")
1967                (commit commit)))
1968          (sha256
1969           (base32
1970            "08xw8cchhmqcc0byng69m3f5a2izc9y2290jzz2k0qrbibp1fdk7"))
1971          (file-name (git-file-name "proc-parse" version))))
1972       (build-system asdf-build-system/sbcl)
1973       (inputs
1974        `(("alexandria" ,sbcl-alexandria)
1975          ("babel" ,sbcl-babel)))
1976       (native-inputs
1977        `(("prove" ,sbcl-prove)
1978          ("prove-asdf" ,sbcl-prove-asdf)))
1979       (arguments
1980        ;; TODO: Tests don't find "proc-parse-test", why?
1981        `(#:tests? #f))
1982       (synopsis "Parse a floating point value from a string in Common Lisp")
1983       (description
1984        "This package exports the following function to parse floating-point
1985 values from a string in Common Lisp.")
1986       (home-page "https://github.com/soemraws/parse-float")
1987       (license license:public-domain))))
1988
1989 (define-public cl-parse-float
1990   (sbcl-package->cl-source-package sbcl-parse-float))
1991
1992 (define-public ecl-parse-float
1993   (sbcl-package->ecl-package sbcl-parse-float))
1994
1995 (define-public sbcl-ascii-strings
1996   (let ((revision "1")
1997         (changeset "5048480a61243e6f1b02884012c8f25cdbee6d97"))
1998     (package
1999       (name "sbcl-ascii-strings")
2000       (version (string-append "0-" revision "." (string-take changeset 7)))
2001       (source
2002        (origin
2003          (method hg-fetch)
2004          (uri (hg-reference
2005                (url "https://bitbucket.org/vityok/cl-string-match/")
2006                (changeset changeset)))
2007          (sha256
2008           (base32
2009            "01wn5qx562w43ssy92xlfgv79w7p0nv0wbl76mpmba131n9ziq2y"))
2010          (file-name (git-file-name "cl-string-match" version))))
2011       (build-system asdf-build-system/sbcl)
2012       (inputs
2013        `(("alexandria" ,sbcl-alexandria)
2014          ("babel" ,sbcl-babel)))
2015       (arguments
2016        `(#:asd-file "ascii-strings.asd"))
2017       (synopsis "Operations on ASCII strings")
2018       (description
2019        "Operations on ASCII strings.  Essentially this can be any kind of
2020 single-byte encoded strings.")
2021       (home-page "https://bitbucket.org/vityok/cl-string-match/")
2022       (license license:bsd-3))))
2023
2024 (define-public cl-ascii-strings
2025   (sbcl-package->cl-source-package sbcl-ascii-strings))
2026
2027 (define-public ecl-ascii-strings
2028   (sbcl-package->ecl-package sbcl-ascii-strings))
2029
2030 (define-public sbcl-simple-scanf
2031   (package
2032     (inherit sbcl-ascii-strings)
2033     (name "sbcl-simple-scanf")
2034     (inputs
2035      `(("alexandria" ,sbcl-alexandria)
2036        ("iterate" ,sbcl-iterate)
2037        ("proc-parse" ,sbcl-proc-parse)
2038        ("parse-float" ,sbcl-parse-float)))
2039     (arguments
2040      `(#:asd-file "simple-scanf.asd"))
2041     (synopsis "Simple scanf-like functionality implementation")
2042     (description
2043      "A simple scanf-like functionality implementation.")))
2044
2045 (define-public cl-simple-scanf
2046   (sbcl-package->cl-source-package sbcl-simple-scanf))
2047
2048 (define-public ecl-simple-scanf
2049   (sbcl-package->ecl-package sbcl-simple-scanf))
2050
2051 (define-public sbcl-cl-string-match
2052   (package
2053     (inherit sbcl-ascii-strings)
2054     (name "sbcl-cl-string-match")
2055     (inputs
2056      `(("alexandria" ,sbcl-alexandria)
2057        ("ascii-strings" ,sbcl-ascii-strings)
2058        ("yacc" ,sbcl-cl-yacc)
2059        ("jpl-util" ,sbcl-jpl-util)
2060        ("jpl-queues" ,sbcl-jpl-queues)
2061        ("mgl-pax" ,sbcl-mgl-pax)
2062        ("iterate" ,sbcl-iterate)))
2063     ;; TODO: Tests are not evaluated properly.
2064     (native-inputs
2065      ;; For testing:
2066      `(("lisp-unit" ,sbcl-lisp-unit)
2067        ("simple-scanf" ,sbcl-simple-scanf)))
2068     (arguments
2069      `(#:tests? #f
2070        #:asd-file "cl-string-match.asd"))
2071     (synopsis "Portable, dependency-free set of utilities to manipulate strings in Common Lisp")
2072     (description
2073      "@command{cl-strings} is a small, portable, dependency-free set of
2074 utilities that make it even easier to manipulate text in Common Lisp.  It has
2075 100% test coverage and works at least on sbcl, ecl, ccl, abcl and clisp.")))
2076
2077 (define-public cl-string-match
2078   (sbcl-package->cl-source-package sbcl-cl-string-match))
2079
2080 (define-public ecl-cl-string-match
2081   (sbcl-package->ecl-package sbcl-cl-string-match))
2082
2083 (define-public sbcl-ptester
2084   (package
2085     (name "sbcl-ptester")
2086     (version "20160929")
2087     (source
2088      (origin
2089        (method url-fetch)
2090        (uri (string-append "http://beta.quicklisp.org/archive/ptester/"
2091                            (date->string (string->date version "~Y~m~d") "~Y-~m-~d")
2092                            "/ptester-"
2093                            version
2094                            "-git.tgz"))
2095        (sha256
2096         (base32
2097          "04rlq1zljhxc65pm31bah3sq3as24l0sdivz440s79qlnnyh13hz"))))
2098     (build-system asdf-build-system/sbcl)
2099     (home-page "http://quickdocs.org/ptester/")
2100     (synopsis "Portable test harness package")
2101     (description
2102      "@command{ptester} is a portable testing framework based on Franz's
2103 tester module.")
2104     (license license:lgpl3+)))
2105
2106 (define-public cl-ptester
2107   (sbcl-package->cl-source-package sbcl-ptester))
2108
2109 (define-public ecl-ptester
2110   (sbcl-package->ecl-package sbcl-ptester))
2111
2112 (define-public sbcl-puri
2113   (package
2114     (name "sbcl-puri")
2115     (version "20180228")
2116     (source
2117      (origin
2118        (method url-fetch)
2119        (uri (string-append "http://beta.quicklisp.org/archive/puri/"
2120                            (date->string (string->date version "~Y~m~d") "~Y-~m-~d")
2121                            "/puri-"
2122                            version
2123                            "-git.tgz"))
2124        (sha256
2125         (base32
2126          "1s4r5adrjy5asry45xbcbklxhdjydvf6n55z897nvyw33bigrnbz"))))
2127     (build-system asdf-build-system/sbcl)
2128     ;; REVIEW: Webiste down?
2129     (native-inputs
2130      `(("ptester" ,sbcl-ptester)))
2131     (home-page "http://files.kpe.io/puri/")
2132     (synopsis "Portable URI Library")
2133     (description
2134      "This is portable Universal Resource Identifier library for Common Lisp
2135 programs.  It parses URI according to the RFC 2396 specification")
2136     (license license:lgpl3+)))
2137
2138 (define-public cl-puri
2139   (sbcl-package->cl-source-package sbcl-puri))
2140
2141 (define-public ecl-puri
2142   (sbcl-package->ecl-package sbcl-puri))
2143
2144 (define-public sbcl-queues
2145   (let ((commit "47d4da65e9ea20953b74aeeab7e89a831b66bc94"))
2146     (package
2147       (name "sbcl-queues")
2148       (version (git-version "0.0.0" "1" commit))
2149       (source
2150        (origin
2151          (method git-fetch)
2152          (uri (git-reference
2153                (url "https://github.com/oconnore/queues")
2154                (commit commit)))
2155          (file-name (git-file-name "queues" version))
2156          (sha256
2157           (base32
2158            "0wdhfnzi4v6d97pggzj2aw55si94w4327br94jrmyvwf351wqjvv"))))
2159       (build-system asdf-build-system/sbcl)
2160       (home-page "https://github.com/oconnore/queues")
2161       (synopsis "Common Lisp queue library")
2162       (description
2163        "This is a simple queue library for Common Lisp with features such as
2164 non-consing thread safe queues and fibonacci priority queues.")
2165       (license license:expat))))
2166
2167 (define-public cl-queues
2168   (sbcl-package->cl-source-package sbcl-queues))
2169
2170 (define-public ecl-queues
2171   (sbcl-package->ecl-package sbcl-queues))
2172
2173 (define-public sbcl-queues.simple-queue
2174   (package
2175     (inherit sbcl-queues)
2176     (name "sbcl-queues.simple-queue")
2177     (inputs
2178      `(("sbcl-queues" ,sbcl-queues)))
2179     (arguments
2180      `(#:asd-file "queues.simple-queue.asd"))
2181     (synopsis "Simple queue implementation")
2182     (description
2183      "This is a simple queue library for Common Lisp with features such as
2184 non-consing thread safe queues and fibonacci priority queues.")
2185     (license license:expat)))
2186
2187 (define-public cl-queues.simple-queue
2188   (sbcl-package->cl-source-package sbcl-queues.simple-queue))
2189
2190 (define-public ecl-queues.simple-queue
2191   (sbcl-package->ecl-package sbcl-queues.simple-queue))
2192
2193 (define-public sbcl-queues.simple-cqueue
2194   (package
2195     (inherit sbcl-queues)
2196     (name "sbcl-queues.simple-cqueue")
2197     (inputs
2198      `(("sbcl-queues" ,sbcl-queues)
2199        ("sbcl-queues.simple-queue" ,sbcl-queues.simple-queue)
2200        ("bordeaux-threads" ,sbcl-bordeaux-threads)))
2201     (arguments
2202      `(#:asd-file "queues.simple-cqueue.asd"))
2203     (synopsis "Thread safe queue implementation")
2204     (description
2205      "This is a simple queue library for Common Lisp with features such as
2206 non-consing thread safe queues and fibonacci priority queues.")
2207     (license license:expat)))
2208
2209 (define-public cl-queues.simple-cqueue
2210   (sbcl-package->cl-source-package sbcl-queues.simple-cqueue))
2211
2212 (define-public ecl-queues.simple-cqueue
2213   (sbcl-package->ecl-package sbcl-queues.simple-cqueue))
2214
2215 (define-public sbcl-queues.priority-queue
2216   (package
2217     (inherit sbcl-queues)
2218     (name "sbcl-queues.priority-queue")
2219     (inputs
2220      `(("sbcl-queues" ,sbcl-queues)))
2221     (arguments
2222      `(#:asd-file "queues.priority-queue.asd"))
2223     (synopsis "Priority queue (Fibonacci) implementation")
2224     (description
2225      "This is a simple queue library for Common Lisp with features such as
2226 non-consing thread safe queues and fibonacci priority queues.")
2227     (license license:expat)))
2228
2229 (define-public cl-queues.priority-queue
2230   (sbcl-package->cl-source-package sbcl-queues.priority-queue))
2231
2232 (define-public ecl-queues.priority-queue
2233   (sbcl-package->ecl-package sbcl-queues.priority-queue))
2234
2235 (define-public sbcl-queues.priority-cqueue
2236   (package
2237     (inherit sbcl-queues)
2238     (name "sbcl-queues.priority-cqueue")
2239     (inputs
2240      `(("sbcl-queues" ,sbcl-queues)
2241        ("sbcl-queues.priority-queue" ,sbcl-queues.priority-queue)
2242        ("bordeaux-threads" ,sbcl-bordeaux-threads)))
2243     (arguments
2244      `(#:asd-file "queues.priority-cqueue.asd"))
2245     (synopsis "Thread safe fibonacci priority queue implementation")
2246     (description
2247      "This is a simple queue library for Common Lisp with features such as
2248 non-consing thread safe queues and fibonacci priority queues.")
2249     (license license:expat)))
2250
2251 (define-public cl-queues.priority-cqueue
2252   (sbcl-package->cl-source-package sbcl-queues.priority-cqueue))
2253
2254 (define-public ecl-queues.priority-cqueue
2255   (sbcl-package->ecl-package sbcl-queues.priority-cqueue))
2256
2257 (define sbcl-cffi-bootstrap
2258   (package
2259     (name "sbcl-cffi-bootstrap")
2260     (version "0.19.0")
2261     (source
2262      (origin
2263        (method git-fetch)
2264        (uri (git-reference
2265              (url "https://github.com/cffi/cffi.git")
2266              (commit (string-append "v" version))))
2267        (file-name (git-file-name "cffi-bootstrap" version))
2268        (sha256
2269         (base32 "09sfgc6r7ihmbkwfpvkq5fxc7h45cabpvgbvs47i5cvnmv3k72xy"))))
2270     (build-system asdf-build-system/sbcl)
2271     (inputs
2272      `(("libffi" ,libffi)
2273        ("alexandria" ,sbcl-alexandria)
2274        ("babel" ,sbcl-babel)
2275        ("trivial-features" ,sbcl-trivial-features)))
2276     (native-inputs
2277      `(("pkg-config" ,pkg-config)))
2278     (arguments
2279      '(#:phases
2280        (modify-phases %standard-phases
2281          (add-after 'unpack 'fix-paths
2282            (lambda* (#:key inputs #:allow-other-keys)
2283              (substitute* "libffi/libffi.lisp"
2284                (("libffi.so.6" all) (string-append
2285                                      (assoc-ref inputs "libffi")
2286                                      "/lib/" all)))
2287              (substitute* "toolchain/c-toolchain.lisp"
2288                (("\"cc\"") (format #f "~S" (which "gcc")))))))
2289        #:asd-system-name "cffi"
2290        #:tests? #f))
2291     (home-page "https://common-lisp.net/project/cffi/")
2292     (synopsis "Common Foreign Function Interface for Common Lisp")
2293     (description "The Common Foreign Function Interface (CFFI)
2294 purports to be a portable foreign function interface for Common Lisp.
2295 The CFFI library is composed of a Lisp-implementation-specific backend
2296 in the CFFI-SYS package, and a portable frontend in the CFFI
2297 package.")
2298     (license license:expat)))
2299
2300 (define-public sbcl-cffi-toolchain
2301   (package
2302     (inherit sbcl-cffi-bootstrap)
2303     (name "sbcl-cffi-toolchain")
2304     (inputs
2305      `(("libffi" ,libffi)
2306        ("sbcl-cffi" ,sbcl-cffi-bootstrap)))
2307     (arguments
2308      (substitute-keyword-arguments (package-arguments sbcl-cffi-bootstrap)
2309        ((#:asd-system-name _) #f)
2310        ((#:tests? _) #t)))))
2311
2312 (define-public sbcl-cffi-libffi
2313   (package
2314     (inherit sbcl-cffi-toolchain)
2315     (name "sbcl-cffi-libffi")
2316     (inputs
2317      `(("cffi" ,sbcl-cffi-bootstrap)
2318        ("cffi-grovel" ,sbcl-cffi-grovel)
2319        ("trivial-features" ,sbcl-trivial-features)
2320        ("libffi" ,libffi)))))
2321
2322 (define-public sbcl-cffi-grovel
2323   (package
2324     (inherit sbcl-cffi-toolchain)
2325     (name "sbcl-cffi-grovel")
2326     (inputs
2327      `(("libffi" ,libffi)
2328        ("cffi" ,sbcl-cffi-bootstrap)
2329        ("cffi-toolchain" ,sbcl-cffi-toolchain)
2330        ("alexandria" ,sbcl-alexandria)))
2331     (arguments
2332      (substitute-keyword-arguments (package-arguments sbcl-cffi-toolchain)
2333        ((#:phases phases)
2334         `(modify-phases ,phases
2335            (add-after 'build 'install-headers
2336              (lambda* (#:key outputs #:allow-other-keys)
2337                (install-file "grovel/common.h"
2338                              (string-append
2339                               (assoc-ref outputs "out")
2340                               "/include/grovel"))))))))))
2341
2342 (define-public sbcl-cffi
2343   (package
2344     (inherit sbcl-cffi-toolchain)
2345     (name "sbcl-cffi")
2346     (inputs (package-inputs sbcl-cffi-bootstrap))
2347     (native-inputs
2348      `(("cffi-grovel" ,sbcl-cffi-grovel)
2349        ("cffi-libffi" ,sbcl-cffi-libffi)
2350        ("rt" ,sbcl-rt)
2351        ("bordeaux-threads" ,sbcl-bordeaux-threads)
2352        ,@(package-native-inputs sbcl-cffi-bootstrap)))))
2353
2354 (define-public cl-cffi
2355   (sbcl-package->cl-source-package sbcl-cffi))
2356
2357 (define-public sbcl-cl-sqlite
2358   (let ((commit "c738e66d4266ef63a1debc4ef4a1b871a068c112"))
2359     (package
2360       (name "sbcl-cl-sqlite")
2361       (version (git-version "0.2" "1" commit))
2362       (source
2363        (origin
2364          (method git-fetch)
2365          (uri (git-reference
2366                (url "https://github.com/dmitryvk/cl-sqlite")
2367                (commit commit)))
2368          (file-name (git-file-name "cl-sqlite" version))
2369          (sha256
2370           (base32
2371            "1ng45k1hdb84sqjryrfx93g66bsbybmpy301wd0fdybnc5jzr36q"))))
2372       (build-system asdf-build-system/sbcl)
2373       (inputs
2374        `(("iterate" ,sbcl-iterate)
2375          ("cffi" ,sbcl-cffi)
2376          ("sqlite" ,sqlite)))
2377       (native-inputs
2378        `(("fiveam" ,sbcl-fiveam)
2379          ("bordeaux-threads" ,sbcl-bordeaux-threads)))
2380       (arguments
2381        `(#:tests? #f                    ; Upstream seems to have issues with tests: https://github.com/dmitryvk/cl-sqlite/issues/7
2382          #:asd-file "sqlite.asd"
2383          #:asd-system-name "sqlite"
2384          #:phases
2385          (modify-phases %standard-phases
2386            (add-after 'unpack 'fix-paths
2387              (lambda* (#:key inputs #:allow-other-keys)
2388                (substitute* "sqlite-ffi.lisp"
2389                  (("libsqlite3" all) (string-append
2390                                       (assoc-ref inputs "sqlite")"/lib/" all))))))))
2391       (home-page "https://common-lisp.net/project/cl-sqlite/")
2392       (synopsis "Common Lisp binding for SQLite")
2393       (description
2394        "The @command{cl-sqlite} package is an interface to the SQLite embedded
2395 relational database engine.")
2396       (license license:public-domain))))
2397
2398 (define-public cl-sqlite
2399   (sbcl-package->cl-source-package sbcl-cl-sqlite))
2400
2401 (define-public sbcl-parenscript
2402   (let ((commit "061d8e286c81c3f45c84fb2b11ee7d83f590a8f8"))
2403     (package
2404       (name "sbcl-parenscript")
2405       (version (git-version "2.6" "1" commit))
2406       (source
2407        (origin
2408          (method git-fetch)
2409          (uri (git-reference
2410                (url "https://gitlab.common-lisp.net/parenscript/parenscript")
2411                (commit commit)))
2412          (file-name (git-file-name "parenscript" version))
2413          (sha256
2414           (base32
2415            "1kbhgsjbikc73m5cwdp4d4fdafyqcr1b7b630qjrziql0nh6mi3k"))))
2416       (build-system asdf-build-system/sbcl)
2417       (inputs
2418        `(("cl-ppcre" ,sbcl-cl-ppcre)
2419          ("anaphora" ,sbcl-anaphora)
2420          ("named-readtables" ,sbcl-named-readtables)))
2421       (home-page "https://common-lisp.net/project/parenscript/")
2422       (synopsis "Translator from a subset of Common Lisp to JavaScript")
2423       (description
2424        "Parenscript is a translator from an extended subset of Common Lisp to
2425 JavaScript.  Parenscript code can run almost identically on both the
2426 browser (as JavaScript) and server (as Common Lisp).
2427
2428 Parenscript code is treated the same way as Common Lisp code, making the full
2429 power of Lisp macros available for JavaScript.  This provides a web
2430 development environment that is unmatched in its ability to reduce code
2431 duplication and provide advanced meta-programming facilities to web
2432 developers.
2433
2434 At the same time, Parenscript is different from almost all other \"language
2435 X\" to JavaScript translators in that it imposes almost no overhead:
2436
2437 @itemize
2438 @item No run-time dependencies: Any piece of Parenscript code is runnable
2439 as-is.  There are no JavaScript files to include.
2440 @item Native types: Parenscript works entirely with native JavaScript data
2441 types.  There are no new types introduced, and object prototypes are not
2442 touched.
2443 @item Native calling convention: Any JavaScript code can be called without the
2444 need for bindings.  Likewise, Parenscript can be used to make efficient,
2445 self-contained JavaScript libraries.
2446 @item Readable code: Parenscript generates concise, formatted, idiomatic
2447 JavaScript code.  Identifier names are preserved.  This enables seamless
2448 debugging in tools like Firebug.
2449 @item Efficiency: Parenscript introduces minimal overhead for advanced Common
2450 Lisp features.  The generated code is almost as fast as hand-written
2451 JavaScript.
2452 @end itemize\n")
2453       (license license:bsd-3))))
2454
2455 (define-public cl-parenscript
2456   (sbcl-package->cl-source-package sbcl-parenscript))
2457
2458 (define-public ecl-parenscript
2459   (sbcl-package->ecl-package sbcl-parenscript))
2460
2461 (define-public sbcl-cl-json
2462   (let ((commit "6dfebb9540bfc3cc33582d0c03c9ec27cb913e79"))
2463     (package
2464       (name "sbcl-cl-json")
2465       (version (git-version "0.5" "1" commit))
2466       (source
2467        (origin
2468          (method git-fetch)
2469          (uri (git-reference
2470                (url "https://github.com/hankhero/cl-json")
2471                (commit commit)))
2472          (file-name (git-file-name "cl-json" version))
2473          (sha256
2474           (base32
2475            "0fx3m3x3s5ji950yzpazz4s0img3l6b3d6l3jrfjv0lr702496lh"))))
2476       (build-system asdf-build-system/sbcl)
2477       (native-inputs
2478        `(("fiveam" ,sbcl-fiveam)))
2479       (home-page "https://github.com/hankhero/cl-json")
2480       (synopsis "JSON encoder and decoder for Common-Lisp")
2481       (description
2482        "@command{cl-json} provides an encoder of Lisp objects to JSON format
2483 and a corresponding decoder of JSON data to Lisp objects.  Both the encoder
2484 and the decoder are highly customizable; at the same time, the default
2485 settings ensure a very simple mode of operation, similar to that provided by
2486 @command{yason} or @command{st-json}.")
2487       (license license:expat))))
2488
2489 (define-public cl-json
2490   (sbcl-package->cl-source-package sbcl-cl-json))
2491
2492 (define-public ecl-cl-json
2493   (sbcl-package->ecl-package sbcl-cl-json))
2494
2495 (define-public sbcl-unix-opts
2496   (package
2497     (name "sbcl-unix-opts")
2498     (version "0.1.7")
2499     (source
2500      (origin
2501        (method git-fetch)
2502        (uri (git-reference
2503              (url "https://github.com/libre-man/unix-opts")
2504              (commit version)))
2505        (file-name (git-file-name "unix-opts" version))
2506        (sha256
2507         (base32
2508          "08djdi1ard09fijb7w9bdmhmwd98b1hzmcnjw9fqjiqa0g3b44rr"))))
2509     (build-system asdf-build-system/sbcl)
2510     (home-page "https://github.com/hankhero/cl-json")
2511     (synopsis "Unix-style command line options parser")
2512     (description
2513      "This is a minimalistic parser of command line options.  The main
2514 advantage of the library is the ability to concisely define command line
2515 options once and then use this definition for parsing and extraction of
2516 command line arguments, as well as printing description of command line
2517 options (you get --help for free).  This way you don't need to repeat
2518 yourself.  Also, @command{unix-opts} doesn't depend on anything and allows to
2519 precisely control behavior of the parser via Common Lisp restarts.")
2520     (license license:expat)))
2521
2522 (define-public cl-unix-opts
2523   (sbcl-package->cl-source-package sbcl-unix-opts))
2524
2525 (define-public ecl-unix-opts
2526   (sbcl-package->ecl-package sbcl-unix-opts))
2527
2528 (define-public sbcl-trivial-garbage
2529   (package
2530     (name "sbcl-trivial-garbage")
2531     (version "0.21")
2532     (source
2533      (origin
2534        (method git-fetch)
2535        (uri (git-reference
2536              (url "https://github.com/trivial-garbage/trivial-garbage.git")
2537              (commit (string-append "v" version))))
2538        (file-name (git-file-name "trivial-garbage" version))
2539        (sha256
2540         (base32 "0122jicfg7pca1wxw8zak1n92h5friqy60988ns0ysksj3fphw9n"))))
2541     (build-system asdf-build-system/sbcl)
2542     (native-inputs
2543      `(("rt" ,sbcl-rt)))
2544     (home-page "https://common-lisp.net/project/trivial-garbage/")
2545     (synopsis "Portable GC-related APIs for Common Lisp")
2546     (description "@command{trivial-garbage} provides a portable API to
2547 finalizers, weak hash-tables and weak pointers on all major implementations of
2548 the Common Lisp programming language.")
2549     (license license:public-domain)))
2550
2551 (define-public cl-trivial-garbage
2552   (sbcl-package->cl-source-package sbcl-trivial-garbage))
2553
2554 (define-public ecl-trivial-garbage
2555   (sbcl-package->ecl-package sbcl-trivial-garbage))
2556
2557 (define-public sbcl-closer-mop
2558   (let ((commit "fac29ce90e3a46e1fc6cf182190e193526fa9dbc"))
2559     (package
2560       (name "sbcl-closer-mop")
2561       (version (git-version  "1.0.0" "1" commit))
2562       (source
2563        (origin
2564          (method git-fetch)
2565          (uri (git-reference
2566                (url "https://github.com/pcostanza/closer-mop")
2567                (commit commit)))
2568          (sha256
2569           (base32 "0hvh77y869h8fg9di5snyg85fxq6fdh9gj1igmx1g6j6j5x915dl"))
2570          (file-name (git-file-name "closer-mop" version ))))
2571       (build-system asdf-build-system/sbcl)
2572       (home-page "https://github.com/pcostanza/closer-mop")
2573       (synopsis "Rectifies absent or incorrect CLOS MOP features")
2574       (description "Closer to MOP is a compatibility layer that rectifies many
2575 of the absent or incorrect CLOS MOP features across a broad range of Common
2576 Lisp implementations.")
2577       (license license:expat))))
2578
2579 (define-public cl-closer-mop
2580   (sbcl-package->cl-source-package sbcl-closer-mop))
2581
2582 (define-public ecl-closer-mop
2583   (sbcl-package->ecl-package sbcl-closer-mop))
2584
2585 (define sbcl-cl-cffi-gtk-boot0
2586   (let ((commit "29443c5aaca975709df8025c4649366d882033cb"))
2587     (package
2588       (name "sbcl-cl-cffi-gtk-boot0")
2589       (version (git-version "0.11.2" "1" commit))
2590       (source
2591        (origin
2592          (method git-fetch)
2593          (uri (git-reference
2594                (url "https://github.com/Ferada/cl-cffi-gtk/")
2595                (commit commit)))
2596          (file-name (git-file-name "cl-cffi-gtk" version))
2597          (sha256
2598           (base32
2599            "0f6s92sf8xyzh1yksqx8bsy1sv0zmy0c13j3b8bavaba5hlxpxah"))))
2600       (build-system asdf-build-system/sbcl)
2601       (inputs
2602        `(("iterate" ,sbcl-iterate)
2603          ("cffi" ,sbcl-cffi)
2604          ("trivial-features" ,sbcl-trivial-features)))
2605       (home-page "https://github.com/Ferada/cl-cffi-gtk/")
2606       (synopsis "Common Lisp binding for GTK+3")
2607       (description
2608        "@command{cl-cffi-gtk} is a Lisp binding to GTK+ 3 (GIMP Toolkit) which
2609 is a library for creating graphical user interfaces.")
2610       (license license:lgpl3))))
2611
2612 (define-public sbcl-cl-cffi-gtk-glib
2613   (package
2614     (inherit sbcl-cl-cffi-gtk-boot0)
2615     (name "sbcl-cl-cffi-gtk-glib")
2616     (inputs
2617      `(("glib" ,glib)
2618        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2619     (arguments
2620      `(#:asd-file "glib/cl-cffi-gtk-glib.asd"
2621        #:phases
2622        (modify-phases %standard-phases
2623          (add-after 'unpack 'fix-paths
2624            (lambda* (#:key inputs #:allow-other-keys)
2625              (substitute* "glib/glib.init.lisp"
2626                (("libglib|libgthread" all) (string-append
2627                                             (assoc-ref inputs "glib") "/lib/" all))))))))))
2628
2629 (define-public sbcl-cl-cffi-gtk-gobject
2630   (package
2631     (inherit sbcl-cl-cffi-gtk-boot0)
2632     (name "sbcl-cl-cffi-gtk-gobject")
2633     (inputs
2634      `(("glib" ,glib)
2635        ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
2636        ("trivial-garbage" ,sbcl-trivial-garbage)
2637        ("bordeaux-threads" ,sbcl-bordeaux-threads)
2638        ("closer-mop" ,sbcl-closer-mop)
2639        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2640     (arguments
2641      `(#:asd-file "gobject/cl-cffi-gtk-gobject.asd"
2642        #:phases
2643        (modify-phases %standard-phases
2644          (add-after 'unpack 'fix-paths
2645            (lambda* (#:key inputs #:allow-other-keys)
2646              (substitute* "gobject/gobject.init.lisp"
2647                (("libgobject" all) (string-append
2648                                     (assoc-ref inputs "glib") "/lib/" all))))))))))
2649
2650 (define-public sbcl-cl-cffi-gtk-gio
2651   (package
2652     (inherit sbcl-cl-cffi-gtk-boot0)
2653     (name "sbcl-cl-cffi-gtk-gio")
2654     (inputs
2655      `(("glib" ,glib)
2656        ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
2657        ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
2658        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2659     (arguments
2660      `(#:asd-file "gio/cl-cffi-gtk-gio.asd"
2661        #:phases
2662        (modify-phases %standard-phases
2663          (add-after 'unpack 'fix-paths
2664            (lambda* (#:key inputs #:allow-other-keys)
2665              (substitute* "gio/gio.init.lisp"
2666                (("libgio" all)
2667                 (string-append
2668                  (assoc-ref inputs "glib") "/lib/" all))))))))))
2669
2670 (define-public sbcl-cl-cffi-gtk-cairo
2671   (package
2672     (inherit sbcl-cl-cffi-gtk-boot0)
2673     (name "sbcl-cl-cffi-gtk-cairo")
2674     (inputs
2675      `(("cairo" ,cairo)
2676        ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
2677        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2678     (arguments
2679      `(#:asd-file "cairo/cl-cffi-gtk-cairo.asd"
2680        #:phases
2681        (modify-phases %standard-phases
2682          (add-after 'unpack 'fix-paths
2683            (lambda* (#:key inputs #:allow-other-keys)
2684              (substitute* "cairo/cairo.init.lisp"
2685                (("libcairo" all)
2686                 (string-append
2687                  (assoc-ref inputs "cairo") "/lib/" all))))))))))
2688
2689 (define-public sbcl-cl-cffi-gtk-pango
2690   (package
2691     (inherit sbcl-cl-cffi-gtk-boot0)
2692     (name "sbcl-cl-cffi-gtk-pango")
2693     (inputs
2694      `(("pango" ,pango)
2695        ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
2696        ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
2697        ("cl-cffi-gtk-cairo" ,sbcl-cl-cffi-gtk-cairo)
2698        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2699     (arguments
2700      `(#:asd-file "pango/cl-cffi-gtk-pango.asd"
2701        #:phases
2702        (modify-phases %standard-phases
2703          (add-after 'unpack 'fix-paths
2704            (lambda* (#:key inputs #:allow-other-keys)
2705              (substitute* "pango/pango.init.lisp"
2706                (("libpango" all)
2707                 (string-append
2708                  (assoc-ref inputs "pango") "/lib/" all))))))))))
2709
2710 (define-public sbcl-cl-cffi-gtk-gdk-pixbuf
2711   (package
2712     (inherit sbcl-cl-cffi-gtk-boot0)
2713     (name "sbcl-cl-cffi-gtk-gdk-pixbuf")
2714     (inputs
2715      `(("gdk-pixbuf" ,gdk-pixbuf)
2716        ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
2717        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2718     (arguments
2719      `(#:asd-file "gdk-pixbuf/cl-cffi-gtk-gdk-pixbuf.asd"
2720        #:phases
2721        (modify-phases %standard-phases
2722          (add-after 'unpack 'fix-paths
2723            (lambda* (#:key inputs #:allow-other-keys)
2724              (substitute* "gdk-pixbuf/gdk-pixbuf.init.lisp"
2725                (("libgdk_pixbuf" all)
2726                 (string-append
2727                  (assoc-ref inputs "gdk-pixbuf") "/lib/" all))))))))))
2728
2729 (define-public sbcl-cl-cffi-gtk-gdk
2730   (package
2731     (inherit sbcl-cl-cffi-gtk-boot0)
2732     (name "sbcl-cl-cffi-gtk-gdk")
2733     (inputs
2734      `(("gtk" ,gtk+)
2735        ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
2736        ("cl-cffi-gtk-gio" ,sbcl-cl-cffi-gtk-gio)
2737        ("cl-cffi-gtk-gdk-pixbuf" ,sbcl-cl-cffi-gtk-gdk-pixbuf)
2738        ("cl-cffi-gtk-cairo" ,sbcl-cl-cffi-gtk-cairo)
2739        ("cl-cffi-gtk-pango" ,sbcl-cl-cffi-gtk-pango)
2740        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2741     (arguments
2742      `(#:asd-file "gdk/cl-cffi-gtk-gdk.asd"
2743        #:phases
2744        (modify-phases %standard-phases
2745          (add-after 'unpack 'fix-paths
2746            (lambda* (#:key inputs #:allow-other-keys)
2747              (substitute* "gdk/gdk.init.lisp"
2748                (("libgdk" all)
2749                 (string-append
2750                  (assoc-ref inputs "gtk") "/lib/" all)))
2751              (substitute* "gdk/gdk.package.lisp"
2752                (("libgtk" all)
2753                 (string-append
2754                  (assoc-ref inputs "gtk") "/lib/" all))))))))))
2755
2756 (define-public sbcl-cl-cffi-gtk
2757   (package
2758     (inherit sbcl-cl-cffi-gtk-boot0)
2759     (name "sbcl-cl-cffi-gtk")
2760     (inputs
2761      `(("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
2762        ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
2763        ("cl-cffi-gtk-gio" ,sbcl-cl-cffi-gtk-gio)
2764        ("cl-cffi-gtk-gdk" ,sbcl-cl-cffi-gtk-gdk)
2765        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2766     (native-inputs
2767      `(("fiveam" ,sbcl-fiveam)))
2768     (arguments
2769      `(#:asd-file "gtk/cl-cffi-gtk.asd"
2770        #:test-asd-file "test/cl-cffi-gtk-test.asd"
2771        ;; TODO: Tests fail with memory fault.
2772        ;; See https://github.com/Ferada/cl-cffi-gtk/issues/24.
2773        #:tests? #f))))
2774
2775 (define-public cl-cffi-gtk
2776   (sbcl-package->cl-source-package sbcl-cl-cffi-gtk))
2777
2778 (define-public sbcl-cl-webkit
2779   (let ((commit "cd2a9008e0c152e54755e8a7f07b050fe36bab31"))
2780     (package
2781       (name "sbcl-cl-webkit")
2782       (version (git-version "2.4" "1" commit))
2783       (source
2784        (origin
2785          (method git-fetch)
2786          (uri (git-reference
2787                (url "https://github.com/jmercouris/cl-webkit")
2788                (commit commit)))
2789          (file-name (git-file-name "cl-webkit" version))
2790          (sha256
2791           (base32
2792            "0f5lyn9i7xrn3g1bddga377mcbawkbxydijpg389q4n04gqj0vwf"))))
2793       (build-system asdf-build-system/sbcl)
2794       (inputs
2795        `(("cffi" ,sbcl-cffi)
2796          ("cl-cffi-gtk" ,sbcl-cl-cffi-gtk)
2797          ("webkitgtk" ,webkitgtk)))
2798       (arguments
2799        `(#:asd-file "webkit2/cl-webkit2.asd"
2800          #:asd-system-name "cl-webkit2"
2801          #:phases
2802          (modify-phases %standard-phases
2803            (add-after 'unpack 'fix-paths
2804              (lambda* (#:key inputs #:allow-other-keys)
2805                (substitute* "webkit2/webkit2.init.lisp"
2806                  (("libwebkit2gtk" all)
2807                   (string-append
2808                    (assoc-ref inputs "webkitgtk") "/lib/" all))))))))
2809       (home-page "https://github.com/jmercouris/cl-webkit")
2810       (synopsis "Binding to WebKitGTK+ for Common Lisp")
2811       (description
2812        "@command{cl-webkit} is a binding to WebKitGTK+ for Common Lisp,
2813 currently targeting WebKit version 2.  The WebKitGTK+ library adds web
2814 browsing capabilities to an application, leveraging the full power of the
2815 WebKit browsing engine.")
2816       (license license:expat))))
2817
2818 (define-public cl-webkit
2819   (sbcl-package->cl-source-package sbcl-cl-webkit))
2820
2821 (define-public sbcl-lparallel
2822   (package
2823     (name "sbcl-lparallel")
2824     (version "2.8.4")
2825     (source
2826      (origin
2827        (method git-fetch)
2828        (uri (git-reference
2829              (url "https://github.com/lmj/lparallel/")
2830              (commit (string-append "lparallel-" version))))
2831        (file-name (git-file-name "lparallel" version))
2832        (sha256
2833         (base32
2834          "0g0aylrbbrqsz0ahmwhvnk4cmc2931fllbpcfgzsprwnqqd7vwq9"))))
2835     (build-system asdf-build-system/sbcl)
2836     (inputs
2837      `(("alexandria" ,sbcl-alexandria)
2838        ("bordeaux-threads" ,sbcl-bordeaux-threads)
2839        ("trivial-garbage" ,sbcl-trivial-garbage)))
2840     (home-page "https://lparallel.org/")
2841     (synopsis "Parallelism for Common Lisp")
2842     (description
2843      "@command{lparallel} is a library for parallel programming in Common
2844 Lisp, featuring:
2845
2846 @itemize
2847 @item a simple model of task submission with receiving queue,
2848 @item constructs for expressing fine-grained parallelism,
2849 @item asynchronous condition handling across thread boundaries,
2850 @item parallel versions of map, reduce, sort, remove, and many others,
2851 @item promises, futures, and delayed evaluation constructs,
2852 @item computation trees for parallelizing interconnected tasks,
2853 @item bounded and unbounded FIFO queues,
2854 @item high and low priority tasks,
2855 @item task killing by category,
2856 @item integrated timeouts.
2857 @end itemize\n")
2858     (license license:expat)))
2859
2860 (define-public cl-lparallel
2861   (sbcl-package->cl-source-package sbcl-lparallel))
2862
2863 (define-public ecl-lparallel
2864   (sbcl-package->ecl-package sbcl-lparallel))
2865
2866 (define-public sbcl-cl-markup
2867   (let ((commit "e0eb7debf4bdff98d1f49d0f811321a6a637b390"))
2868     (package
2869       (name "sbcl-cl-markup")
2870       (version (git-version "0.1" "1" commit))
2871       (source
2872        (origin
2873          (method git-fetch)
2874          (uri (git-reference
2875                (url "https://github.com/arielnetworks/cl-markup/")
2876                (commit commit)))
2877          (file-name (git-file-name "cl-markup" version))
2878          (sha256
2879           (base32
2880            "10l6k45971dl13fkdmva7zc6i453lmq9j4xax2ci6pjzlc6xjhp7"))))
2881       (build-system asdf-build-system/sbcl)
2882       (home-page "https://github.com/arielnetworks/cl-markup/")
2883       (synopsis "Markup generation library for Common Lisp")
2884       (description
2885        "A modern markup generation library for Common Lisp that features:
2886
2887 @itemize
2888 @item Fast (even faster through compiling the code)
2889 @item Safety
2890 @item Support for multiple document types (markup, xml, html, html5, xhtml)
2891 @item Output with doctype
2892 @item Direct output to stream
2893 @end itemize\n")
2894       (license license:lgpl3+))))
2895
2896 (define-public cl-markup
2897   (sbcl-package->cl-source-package sbcl-cl-markup))
2898
2899 (define-public ecl-cl-markup
2900   (sbcl-package->ecl-package sbcl-cl-markup))
2901
2902 (define-public sbcl-cl-css
2903   (let ((commit "8fe654c8f0cf95b300718101cce4feb517f78e2f"))
2904     (package
2905       (name "sbcl-cl-css")
2906       (version (git-version "0.1" "1" commit))
2907       (source
2908        (origin
2909          (method git-fetch)
2910          (uri (git-reference
2911                (url "https://github.com/inaimathi/cl-css/")
2912                (commit commit)))
2913          (file-name (git-file-name "cl-css" version))
2914          (sha256
2915           (base32
2916            "1lc42zi2sw11fl2589sc19nr5sd2p0wy7wgvgwaggxa5f3ajhsmd"))))
2917       (build-system asdf-build-system/sbcl)
2918       (home-page "https://github.com/inaimathi/cl-css/")
2919       (synopsis "Non-validating, inline CSS generator for Common Lisp")
2920       (description
2921        "This is a dead-simple, non validating, inline CSS generator for Common
2922 Lisp.  Its goals are axiomatic syntax, simple implementation to support
2923 portability, and boilerplate reduction in CSS.")
2924       (license license:expat))))
2925
2926 (define-public cl-css
2927   (sbcl-package->cl-source-package sbcl-cl-css))
2928
2929 (define-public ecl-cl-css
2930   (sbcl-package->ecl-package sbcl-cl-css))
2931
2932 (define-public sbcl-portable-threads
2933   (let ((commit "c0e61a1faeb0583c80fd3f20b16cc4c555226920"))
2934     (package
2935       (name "sbcl-portable-threads")
2936       (version (git-version "2.3" "1" commit))
2937       (source
2938        (origin
2939          (method git-fetch)
2940          (uri (git-reference
2941                (url "https://github.com/binghe/portable-threads/")
2942                (commit commit)))
2943          (file-name (git-file-name "portable-threads" version))
2944          (sha256
2945           (base32
2946            "03fmxyarc0xf4kavwkfa0a2spkyfrz6hbgbi9y4q7ny5aykdyfaq"))))
2947       (build-system asdf-build-system/sbcl)
2948       (arguments
2949        `(;; Tests seem broken.
2950          #:tests? #f))
2951       (home-page "https://github.com/binghe/portable-threads")
2952       (synopsis "Portable threads (and scheduled and periodic functions) API for Common Lisp")
2953       (description
2954        "Portable Threads (and Scheduled and Periodic Functions) API for Common
2955 Lisp (from GBBopen project).")
2956       (license license:asl2.0))))
2957
2958 (define-public cl-portable-threads
2959   (sbcl-package->cl-source-package sbcl-portable-threads))
2960
2961 (define-public ecl-portable-threada
2962   (sbcl-package->ecl-package sbcl-portable-threads))
2963
2964 (define-public sbcl-usocket-boot0
2965   ;; usocket's test rely on usocket-server which depends on usocket itself.
2966   ;; We break this cyclic dependency with -boot0 that packages usocket.
2967   (let ((commit "86e7efbfe50101931edf4b67cdcfa7e221ecfde9"))
2968     (package
2969       (name "sbcl-usocket-boot0")
2970       (version (git-version "0.7.1" "1" commit))
2971       (source
2972        (origin
2973          (method git-fetch)
2974          (uri (git-reference
2975                (url "https://github.com/usocket/usocket/")
2976                (commit commit)))
2977          (file-name (git-file-name "usocket" version))
2978          (sha256
2979           (base32
2980            "1lk6ipakrib7kdgzw44hrgmls9akp5pz4h35yynw0k5zwmmq6374"))))
2981       (build-system asdf-build-system/sbcl)
2982       (inputs
2983        `(("split-sequence" ,sbcl-split-sequence)))
2984       (arguments
2985        `(#:tests? #f
2986          #:asd-system-name "usocket"))
2987       (home-page "https://common-lisp.net/project/usocket/")
2988       (synopsis "Universal socket library for Common Lisp (server side)")
2989       (description
2990        "This library strives to provide a portable TCP/IP and UDP/IP socket
2991 interface for as many Common Lisp implementations as possible, while keeping
2992 the abstraction and portability layer as thin as possible.")
2993       (license license:expat))))
2994
2995 (define-public sbcl-usocket-server
2996   (package
2997     (inherit sbcl-usocket-boot0)
2998     (name "sbcl-usocket-server")
2999     (inputs
3000      `(("usocket" ,sbcl-usocket-boot0)
3001        ("portable-threads" ,sbcl-portable-threads)))
3002     (arguments
3003      '(#:asd-system-name "usocket-server"))
3004     (synopsis "Universal socket library for Common Lisp (server side)")))
3005
3006 (define-public cl-usocket-server
3007   (sbcl-package->cl-source-package sbcl-usocket-server))
3008
3009 (define-public ecl-socket-server
3010   (sbcl-package->ecl-package sbcl-usocket-server))
3011
3012 (define-public sbcl-usocket
3013   (package
3014     (inherit sbcl-usocket-boot0)
3015     (name "sbcl-usocket")
3016     (arguments
3017      ;; FIXME: Tests need network access?
3018      `(#:tests? #f))
3019     (native-inputs
3020      ;; Testing only.
3021      `(("usocket-server" ,sbcl-usocket-server)
3022        ("rt" ,sbcl-rt)))))
3023
3024 (define-public cl-usocket
3025   (sbcl-package->cl-source-package sbcl-usocket))
3026
3027 (define-public ecl-socket
3028   (sbcl-package->ecl-package sbcl-usocket))
3029
3030 (define-public sbcl-s-xml
3031   (package
3032     (name "sbcl-s-xml")
3033     (version "3")
3034     (source
3035      (origin
3036        (method url-fetch)
3037        (uri "https://common-lisp.net/project/s-xml/s-xml.tgz")
3038        (sha256
3039         (base32
3040          "061qcr0dzshsa38s5ma4ay924cwak2nq9gy59dw6v9p0qb58nzjf"))))
3041     (build-system asdf-build-system/sbcl)
3042     (home-page "https://common-lisp.net/project/s-xml/")
3043     (synopsis "Simple XML parser implemented in Common Lisp")
3044     (description
3045      "S-XML is a simple XML parser implemented in Common Lisp.  This XML
3046 parser implementation has the following features:
3047
3048 @itemize
3049 @item It works (handling many common XML usages).
3050 @item It is very small (the core is about 700 lines of code, including
3051 comments and whitespace).
3052 @item It has a core API that is simple, efficient and pure functional, much
3053 like that from SSAX (see also http://ssax.sourceforge.net).
3054 @item It supports different DOM models: an XSML-based one, an LXML-based one
3055 and a classic xml-element struct based one.
3056 @item It is reasonably time and space efficient (internally avoiding garbage
3057 generatation as much as possible).
3058 @item It does support CDATA.
3059 @item It should support the same character sets as your Common Lisp
3060 implementation.
3061 @item It does support XML name spaces.
3062 @end itemize
3063
3064 This XML parser implementation has the following limitations:
3065
3066 @itemize
3067 @item It does not support any special tags (like processing instructions).
3068 @item It is not validating, even skips DTD's all together.
3069 @end itemize\n")
3070     (license license:lgpl3+)))
3071
3072 (define-public cl-s-xml
3073   (sbcl-package->cl-source-package sbcl-s-xml))
3074
3075 (define-public ecl-s-xml
3076   (sbcl-package->ecl-package sbcl-s-xml))
3077
3078 (define-public sbcl-s-xml-rpc
3079   (package
3080     (name "sbcl-s-xml-rpc")
3081     (version "7")
3082     (source
3083      (origin
3084        (method url-fetch)
3085        (uri "https://common-lisp.net/project/s-xml-rpc/s-xml-rpc.tgz")
3086        (sha256
3087         (base32
3088          "02z7k163d51v0pzk8mn1xb6h5s6x64gjqkslhwm3a5x26k2gfs11"))))
3089     (build-system asdf-build-system/sbcl)
3090     (inputs
3091      `(("s-xml" ,sbcl-s-xml)))
3092     (home-page "https://common-lisp.net/project/s-xml-rpc/")
3093     (synopsis "Implementation of XML-RPC in Common Lisp for both client and server")
3094     (description
3095      "S-XML-RPC is an implementation of XML-RPC in Common Lisp for both
3096 client and server.")
3097     (license license:lgpl3+)))
3098
3099 (define-public cl-s-xml-rpc
3100   (sbcl-package->cl-source-package sbcl-s-xml-rpc))
3101
3102 (define-public ecl-s-xml-rpc
3103   (sbcl-package->ecl-package sbcl-s-xml-rpc))
3104
3105 (define-public sbcl-trivial-clipboard
3106   (let ((commit "5af3415d1484e6d69a1b5c178f24680d9fd01796"))
3107     (package
3108       (name "sbcl-trivial-clipboard")
3109       (version (git-version "0.0.0.0" "2" commit))
3110       (source
3111        (origin
3112          (method git-fetch)
3113          (uri (git-reference
3114                (url "https://github.com/snmsts/trivial-clipboard")
3115                (commit commit)))
3116          (file-name (git-file-name "trivial-clipboard" version))
3117          (sha256
3118           (base32
3119            "1gb515z5yq6h5548pb1fwhmb0hhq1ssyb78pvxh4alq799xipxs9"))))
3120       (build-system asdf-build-system/sbcl)
3121       (inputs
3122        `(("xclip" ,xclip)))
3123       (native-inputs
3124        `(("fiveam" ,sbcl-fiveam)))
3125       (arguments
3126        `(#:phases
3127          (modify-phases %standard-phases
3128            (add-after 'unpack 'fix-paths
3129              (lambda* (#:key inputs #:allow-other-keys)
3130                (substitute* "src/text.lisp"
3131                  (("\\(executable-find \"xclip\"\\)")
3132                   (string-append "(executable-find \""
3133                                  (assoc-ref inputs "xclip")
3134                                  "/bin/xclip\")"))))))))
3135       (home-page "https://github.com/snmsts/trivial-clipboard")
3136       (synopsis "Access system clipboard in Common Lisp")
3137       (description
3138        "@command{trivial-clipboard} gives access to the system clipboard.")
3139       (license license:expat))))
3140
3141 (define-public cl-trivial-clipboard
3142   (sbcl-package->cl-source-package sbcl-trivial-clipboard))
3143
3144 (define-public ecl-trivial-clipboard
3145   (sbcl-package->ecl-package sbcl-trivial-clipboard))
3146
3147 (define-public sbcl-trivial-backtrace
3148   (let ((commit "ca81c011b86424a381a7563cea3b924f24e6fbeb")
3149         (revision "1"))
3150     (package
3151      (name "sbcl-trivial-backtrace")
3152      (version (git-version "0.0.0" revision commit))
3153      (source
3154       (origin
3155        (method git-fetch)
3156        (uri (git-reference
3157              (url "https://github.com/gwkkwg/trivial-backtrace.git")
3158              (commit commit)))
3159        (file-name (git-file-name "trivial-backtrace" version))
3160        (sha256
3161         (base32 "10p41p43skj6cimdg8skjy7372s8v2xpkg8djjy0l8rm45i654k1"))))
3162      (build-system asdf-build-system/sbcl)
3163      (inputs
3164       `(("sbcl-lift" ,sbcl-lift)))
3165      (home-page "https://common-lisp.net/project/trivial-backtrace/")
3166      (synopsis "Portable simple API to work with backtraces in Common Lisp")
3167      (description
3168       "On of the many things that didn't quite get into the Common Lisp
3169 standard was how to get a Lisp to output its call stack when something has
3170 gone wrong.  As such, each Lisp has developed its own notion of what to
3171 display, how to display it, and what sort of arguments can be used to
3172 customize it.  @code{trivial-backtrace} is a simple solution to generating a
3173 backtrace portably.")
3174      (license license:expat))))
3175
3176 (define-public cl-trivial-backtrace
3177   (sbcl-package->cl-source-package sbcl-trivial-backtrace))
3178
3179 (define-public sbcl-rfc2388
3180   (let ((commit "591bcf7e77f2c222c43953a80f8c297751dc0c4e")
3181         (revision "1"))
3182     (package
3183      (name "sbcl-rfc2388")
3184      (version (git-version "0.0.0" revision commit))
3185      (source
3186       (origin
3187        (method git-fetch)
3188        (uri (git-reference
3189              (url "https://github.com/jdz/rfc2388.git")
3190              (commit commit)))
3191        (file-name (git-file-name "rfc2388" version))
3192        (sha256
3193         (base32 "0phh5n3clhl9ji8jaxrajidn22d3f0aq87mlbfkkxlnx2pnw694k"))))
3194      (build-system asdf-build-system/sbcl)
3195      (home-page "https://github.com/jdz/rfc2388/")
3196      (synopsis "An implementation of RFC 2388 in Common Lisp")
3197      (description
3198       "This package contains an implementation of RFC 2388, which is used to
3199 process form data posted with HTTP POST method using enctype
3200 \"multipart/form-data\".")
3201      (license license:bsd-2))))
3202
3203 (define-public cl-rfc2388
3204   (sbcl-package->cl-source-package sbcl-rfc2388))
3205
3206 (define-public sbcl-md5
3207   (package
3208     (name "sbcl-md5")
3209     (version "2.0.4")
3210     (source
3211      (origin
3212        (method url-fetch)
3213        (uri (string-append
3214              "https://github.com/pmai/md5/archive/release-" version ".tar.gz"))
3215        (sha256
3216         (base32 "19yl9n0pjdz5gw4qi711lka97xcd9f81ylg434hk7jwn9f2s6w11"))))
3217     (build-system asdf-build-system/sbcl)
3218     (home-page "https://github.com/pmai/md5")
3219     (synopsis
3220      "Common Lisp implementation of the MD5 Message-Digest Algorithm (RFC 1321)")
3221     (description
3222      "This package implements The MD5 Message-Digest Algorithm, as defined in
3223 RFC 1321 by R. Rivest, published April 1992.")
3224     (license license:public-domain)))
3225
3226 (define-public cl-md5
3227   (sbcl-package->cl-source-package sbcl-md5))
3228
3229 (define-public sbcl-cl+ssl
3230   (let ((commit "141ae91416bc40f1618dc07e48429b84388aa599")
3231         (revision "1"))
3232     (package
3233       (name "sbcl-cl+ssl")
3234       (version (git-version "0.0.0" revision commit))
3235       (source
3236        (origin
3237          (method git-fetch)
3238          (uri (git-reference
3239                (url "https://github.com/cl-plus-ssl/cl-plus-ssl.git")
3240                (commit commit)))
3241          (file-name (git-file-name "cl+ssl" version))
3242          (sha256
3243           (base32 "1s0hg1h9sf8q89v0yrxmzg5f5sng29rgx3n21r9h9yql8351myan"))))
3244       (build-system asdf-build-system/sbcl)
3245       (arguments
3246        '(#:phases
3247          (modify-phases %standard-phases
3248            (add-after 'unpack 'fix-paths
3249              (lambda* (#:key inputs #:allow-other-keys)
3250                (substitute* "src/reload.lisp"
3251                  (("libssl.so" all)
3252                   (string-append
3253                    (assoc-ref inputs "openssl") "/lib/" all))))))))
3254       (inputs
3255        `(("openssl" ,openssl)
3256          ("sbcl-cffi" ,sbcl-cffi)
3257          ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)
3258          ("sbcl-flexi-streams" ,sbcl-flexi-streams)
3259          ("sbcl-bordeaux-threads" ,sbcl-bordeaux-threads)
3260          ("sbcl-trivial-garbage" ,sbcl-trivial-garbage)
3261          ("sbcl-alexandria" ,sbcl-alexandria)
3262          ("sbcl-trivial-features" ,sbcl-trivial-features)))
3263       (home-page "http://common-lisp.net/project/cl-plus-ssl/")
3264       (synopsis "Common Lisp bindings to OpenSSL")
3265       (description
3266        "This library is a fork of SSL-CMUCL.  The original SSL-CMUCL source
3267 code was written by Eric Marsden and includes contributions by Jochen Schmidt.
3268 Development into CL+SSL was done by David Lichteblau.")
3269       (license license:expat))))
3270
3271 (define-public cl-cl+ssl
3272   (sbcl-package->cl-source-package sbcl-cl+ssl))
3273
3274 (define-public sbcl-kmrcl
3275   (let ((version "1.109.0")
3276         (commit "5260068b2eb735af6796740c2db4955afac21636")
3277         (revision "1"))
3278     (package
3279       (name "sbcl-kmrcl")
3280       (version (git-version version revision commit))
3281       (source
3282        (origin
3283          (method git-fetch)
3284          (uri (git-reference
3285                (url "http://git.kpe.io/kmrcl.git/")
3286                (commit commit)))
3287          (file-name (git-file-name name version))
3288          (sha256
3289           (base32 "1va7xjgzfv674bpsli674i7zj3f7wg5kxic41kz18r6hh4n52dfv"))))
3290       (build-system asdf-build-system/sbcl)
3291       (arguments
3292        ;; Tests fail with: :FORCE and :FORCE-NOT arguments not allowed in a
3293        ;; nested call to ASDF/OPERATE:OPERATE unless identically to toplevel
3294        '(#:tests? #f))
3295       (inputs
3296        `(("sbcl-rt" ,sbcl-rt)))
3297       (home-page "http://files.kpe.io/kmrcl/")
3298       (synopsis "General utilities for Common Lisp programs")
3299       (description
3300        "KMRCL is a collection of utilities used by a number of Kevin
3301 Rosenberg's CL packages.")
3302       (license license:llgpl))))
3303
3304 (define-public cl-kmrcl
3305   (sbcl-package->cl-source-package sbcl-kmrcl))
3306
3307 (define-public sbcl-cl-base64
3308   (let ((version "3.3.3"))
3309     (package
3310       (name "sbcl-cl-base64")
3311       (version version)
3312       (source
3313        (origin
3314          (method git-fetch)
3315          (uri (git-reference
3316                (url "http://git.kpe.io/cl-base64.git")
3317                (commit (string-append "v" version))))
3318          (file-name (git-file-name "cl-base64" version))
3319          (sha256
3320           (base32 "1dw6j7n6gsd2qa0p0rbsjxj00acxx3i9ca1qkgl0liy8lpnwkypl"))))
3321       (build-system asdf-build-system/sbcl)
3322       (arguments
3323        ;; Tests fail with: :FORCE and :FORCE-NOT arguments not allowed
3324        ;; in a nested call to ASDF/OPERATE:OPERATE unless identically
3325        ;; to toplevel
3326        '(#:tests? #f))
3327       (inputs
3328        `(("sbcl-ptester" ,sbcl-ptester)
3329          ("sbcl-kmrcl" ,sbcl-kmrcl)))
3330       (home-page "http://files.kpe.io/cl-base64/")
3331       (synopsis
3332        "Common Lisp package to encode and decode base64 with URI support")
3333       (description
3334        "This package provides highly optimized base64 encoding and decoding.
3335 Besides conversion to and from strings, integer conversions are supported.
3336 Encoding with Uniform Resource Identifiers is supported by using a modified
3337 encoding table that uses only URI-compatible characters.")
3338       (license license:bsd-3))))
3339
3340 (define-public cl-base64
3341   (sbcl-package->cl-source-package sbcl-cl-base64))
3342
3343 (define-public sbcl-chunga
3344   (package
3345     (name "sbcl-chunga")
3346     (version "1.1.7")
3347     (source
3348      (origin
3349        (method git-fetch)
3350        (uri (git-reference
3351               (url "https://github.com/edicl/chunga.git")
3352               (commit (string-append "v" version))))
3353        (file-name (git-file-name name version))
3354        (sha256
3355         (base32 "0jzn3nyb3f22gm983rfk99smqs3mhb9ivjmasvhq9qla5cl9pyhd"))))
3356     (build-system asdf-build-system/sbcl)
3357     (inputs
3358      `(("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)))
3359     (home-page "https://edicl.github.io/chunga/")
3360     (synopsis "Portable chunked streams for Common Lisp")
3361     (description
3362      "Chunga implements streams capable of chunked encoding on demand as
3363 defined in RFC 2616.")
3364     (license license:bsd-2)))
3365
3366 (define-public cl-chunga
3367   (sbcl-package->cl-source-package sbcl-chunga))
3368
3369 (define-public sbcl-cl-who
3370   (let ((version "1.1.4")
3371         (commit "2c08caa4bafba720409af9171feeba3f32e86d32")
3372         (revision "1"))
3373     (package
3374       (name "sbcl-cl-who")
3375       (version (git-version version revision commit))
3376       (source
3377        (origin
3378          (method git-fetch)
3379          (uri (git-reference
3380                (url "https://github.com/edicl/cl-who.git")
3381                (commit commit)))
3382          (file-name (git-file-name name version))
3383          (sha256
3384           (base32
3385            "0yjb6sr3yazm288m318kqvj9xk8rm9n1lpimgf65ymqv0i5agxsb"))))
3386       (build-system asdf-build-system/sbcl)
3387       (native-inputs
3388        `(("sbcl-flexi-streams" ,sbcl-flexi-streams)))
3389       (home-page "https://edicl.github.io/cl-who/")
3390       (synopsis "Yet another Lisp markup language")
3391       (description
3392        "There are plenty of Lisp Markup Languages out there - every Lisp
3393 programmer seems to write at least one during his career - and CL-WHO (where
3394 WHO means \"with-html-output\" for want of a better acronym) is probably just
3395 as good or bad as the next one.")
3396       (license license:bsd-2))))
3397
3398 (define-public cl-cl-who
3399   (sbcl-package->cl-source-package sbcl-cl-who))
3400
3401 (define-public sbcl-chipz
3402   (let ((version "0.8")
3403         (commit "75dfbc660a5a28161c57f115adf74c8a926bfc4d")
3404         (revision "1"))
3405     (package
3406       (name "sbcl-chipz")
3407       (version (git-version version revision commit))
3408       (source
3409        (origin
3410          (method git-fetch)
3411          (uri (git-reference
3412                (url "https://github.com/froydnj/chipz.git")
3413                (commit commit)))
3414          (file-name (git-file-name name version))
3415          (sha256
3416           (base32
3417            "0plx4rs39zbs4gjk77h4a2q11zpy75fh9v8hnxrvsf8fnakajhwg"))))
3418       (build-system asdf-build-system/sbcl)
3419       (native-inputs
3420        `(("sbcl-flexi-streams" ,sbcl-flexi-streams)))
3421       (home-page "http://method-combination.net/lisp/chipz/")
3422       (synopsis
3423        "Common Lisp library for decompressing deflate, zlib, gzip, and bzip2
3424 data")
3425       (description
3426        "DEFLATE data, defined in RFC1951, forms the core of popular
3427 compression formats such as zlib (RFC 1950) and gzip (RFC 1952).  As such,
3428 Chipz also provides for decompressing data in those formats as well.  BZIP2 is
3429 the format used by the popular compression tool bzip2.")
3430       ;; The author describes it as "MIT-like"
3431       (license license:expat))))
3432
3433 (define-public cl-chipz
3434   (sbcl-package->cl-source-package sbcl-chipz))
3435
3436 (define-public sbcl-drakma
3437   (let ((version "2.0.4")
3438         (commit "7647c0ae842ff2058624e53979c7f297760c97a7")
3439         (revision "1"))
3440     (package
3441       (name "sbcl-drakma")
3442       (version (git-version version revision commit))
3443       (source
3444        (origin
3445          (method git-fetch)
3446          (uri (git-reference
3447                (url "https://github.com/edicl/drakma.git")
3448                (commit commit)))
3449          (file-name (git-file-name name version))
3450          (sha256
3451           (base32
3452            "1c4i9wakhj5pxfyyykxshdmv3180sbkrx6fcyynikmc0jd0rh84r"))))
3453       (build-system asdf-build-system/sbcl)
3454       (inputs
3455        `(("sbcl-puri" ,sbcl-puri)
3456          ("sbcl-cl-base64" ,sbcl-cl-base64)
3457          ("sbcl-chunga" ,sbcl-chunga)
3458          ("sbcl-flexi-streams" ,sbcl-flexi-streams)
3459          ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
3460          ("sbcl-chipz" ,sbcl-chipz)
3461          ("sbcl-usocket" ,sbcl-usocket)
3462          ("sbcl-cl+ssl" ,sbcl-cl+ssl)))
3463       (native-inputs
3464        `(("sbcl-fiveam" ,sbcl-fiveam)))
3465       (home-page "https://edicl.github.io/drakma/")
3466       (synopsis "HTTP client written in Common Lisp")
3467       (description
3468        "Drakma is a full-featured HTTP client implemented in Common Lisp.  It
3469 knows how to handle HTTP/1.1 chunking, persistent connections, re-usable
3470 sockets, SSL, continuable uploads, file uploads, cookies, and more.")
3471       (license license:bsd-2))))
3472
3473 (define-public cl-drakma
3474   (sbcl-package->cl-source-package sbcl-drakma))
3475
3476 (define-public sbcl-hunchentoot
3477   (package
3478     (name "sbcl-hunchentoot")
3479     (version "1.2.38")
3480     (source
3481      (origin
3482        (method git-fetch)
3483        (uri (git-reference
3484              (url "https://github.com/edicl/hunchentoot.git")
3485              (commit (string-append "v" version))))
3486        (file-name (git-file-name "hunchentoot" version))
3487        (sha256
3488         (base32 "1anpcad7w045m4rsjs1f3xdhjwx5cppq1h0vlb3q7dz81fi3i6yq"))))
3489     (build-system asdf-build-system/sbcl)
3490     (native-inputs
3491      `(("sbcl-cl-who" ,sbcl-cl-who)
3492        ("sbcl-drakma" ,sbcl-drakma)))
3493     (inputs
3494      `(("sbcl-chunga" ,sbcl-chunga)
3495        ("sbcl-cl-base64" ,sbcl-cl-base64)
3496        ("sbcl-cl-fad" ,sbcl-cl-fad)
3497        ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
3498        ("sbcl-flexi-streams" ,sbcl-flexi-streams)
3499        ("sbcl-cl+ssl" ,sbcl-cl+ssl)
3500        ("sbcl-md5" ,sbcl-md5)
3501        ("sbcl-rfc2388" ,sbcl-rfc2388)
3502        ("sbcl-trivial-backtrace" ,sbcl-trivial-backtrace)
3503        ("sbcl-usocket" ,sbcl-usocket)))
3504     (home-page "https://edicl.github.io/hunchentoot/")
3505     (synopsis "Web server written in Common Lisp")
3506     (description
3507      "Hunchentoot is a web server written in Common Lisp and at the same
3508 time a toolkit for building dynamic websites.  As a stand-alone web server,
3509 Hunchentoot is capable of HTTP/1.1 chunking (both directions), persistent
3510 connections (keep-alive), and SSL.")
3511     (license license:bsd-2)))
3512
3513 (define-public cl-hunchentoot
3514   (sbcl-package->cl-source-package sbcl-hunchentoot))
3515
3516 (define-public sbcl-trivial-types
3517   (package
3518     (name "sbcl-trivial-types")
3519     (version "0.0.1")
3520     (source
3521      (origin
3522        (method git-fetch)
3523        (uri (git-reference
3524              (url "https://github.com/m2ym/trivial-types.git")
3525              (commit "ee869f2b7504d8aa9a74403641a5b42b16f47d88")))
3526        (file-name (git-file-name name version))
3527        (sha256
3528         (base32 "1s4cp9bdlbn8447q7w7f1wkgwrbvfzp20mgs307l5pxvdslin341"))))
3529     (build-system asdf-build-system/sbcl)
3530     (home-page "https://github.com/m2ym/trivial-types")
3531     (synopsis "Trivial type definitions for Common Lisp")
3532     (description
3533      "TRIVIAL-TYPES provides missing but important type definitions such as
3534 PROPER-LIST, ASSOCIATION-LIST, PROPERTY-LIST and TUPLE.")
3535     (license license:llgpl)))
3536
3537 (define-public cl-trivial-types
3538   (sbcl-package->cl-source-package sbcl-trivial-types))
3539
3540 (define-public sbcl-cl-syntax
3541   (package
3542     (name "sbcl-cl-syntax")
3543     (version "0.0.3")
3544     (source
3545      (origin
3546        (method git-fetch)
3547        (uri (git-reference
3548              (url "https://github.com/m2ym/cl-syntax.git")
3549              (commit "03f0c329bbd55b8622c37161e6278366525e2ccc")))
3550        (file-name (git-file-name "cl-syntax" version))
3551        (sha256
3552         (base32 "17ran8xp77asagl31xv8w819wafh6whwfc9p6dgx22ca537gyl4y"))))
3553     (build-system asdf-build-system/sbcl)
3554     (arguments
3555      '(#:asd-file "cl-syntax.asd"
3556        #:asd-system-name "cl-syntax"))
3557     (inputs `(("sbcl-trivial-types" ,sbcl-trivial-types)
3558               ("sbcl-named-readtables" ,sbcl-named-readtables)))
3559     (home-page "https://github.com/m2ym/cl-syntax")
3560     (synopsis "Reader Syntax Coventions for Common Lisp and SLIME")
3561     (description
3562      "CL-SYNTAX provides Reader Syntax Coventions for Common Lisp and SLIME.")
3563     (license license:llgpl)))
3564
3565 (define-public cl-syntax
3566   (sbcl-package->cl-source-package sbcl-cl-syntax))
3567
3568 (define-public sbcl-cl-annot
3569   (let ((commit "c99e69c15d935eabc671b483349a406e0da9518d")
3570         (revision "1"))
3571     (package
3572       (name "sbcl-cl-annot")
3573       (version (git-version "0.0.0" revision commit))
3574       (source
3575        (origin
3576          (method git-fetch)
3577          (uri (git-reference
3578                (url "https://github.com/m2ym/cl-annot.git")
3579                (commit commit)))
3580          (file-name (git-file-name name version))
3581          (sha256
3582           (base32 "1wq1gs9jjd5m6iwrv06c2d7i5dvqsfjcljgbspfbc93cg5xahk4n"))))
3583       (build-system asdf-build-system/sbcl)
3584     (arguments
3585      '(#:asd-file "cl-annot.asd"
3586        #:asd-system-name "cl-annot"))
3587       (inputs
3588        `(("sbcl-alexandria" ,sbcl-alexandria)))
3589       (home-page "https://github.com/m2ym/cl-annot")
3590       (synopsis "Python-like Annotation Syntax for Common Lisp.")
3591       (description
3592        "@code{cl-annot} is an general annotation library for Common Lisp.")
3593       (license license:llgpl))))
3594
3595 (define-public cl-annot
3596   (sbcl-package->cl-source-package sbcl-cl-annot))
3597
3598 (define-public sbcl-cl-syntax-annot
3599   (package
3600     (name "sbcl-cl-syntax-annot")
3601     (version "0.0.3")
3602     (source
3603      (origin
3604        (method git-fetch)
3605        (uri (git-reference
3606              (url "https://github.com/m2ym/cl-syntax.git")
3607              (commit "03f0c329bbd55b8622c37161e6278366525e2ccc")))
3608        (file-name (git-file-name name version))
3609        (sha256
3610         (base32 "17ran8xp77asagl31xv8w819wafh6whwfc9p6dgx22ca537gyl4y"))))
3611     (build-system asdf-build-system/sbcl)
3612     (arguments
3613      '(#:asd-file "cl-syntax-annot.asd"
3614        #:asd-system-name "cl-syntax-annot"))
3615     (inputs
3616      `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
3617        ("sbcl-cl-annot" ,sbcl-cl-annot)))
3618     (home-page "https://github.com/m2ym/cl-syntax")
3619     (synopsis "Reader Syntax Coventions for Common Lisp and SLIME")
3620     (description
3621      "CL-SYNTAX provides Reader Syntax Coventions for Common Lisp and
3622 SLIME.")
3623     (license license:llgpl)))
3624
3625 (define-public cl-syntax-annot
3626   (sbcl-package->cl-source-package sbcl-cl-syntax-annot))
3627
3628 (define-public sbcl-cl-utilities
3629   (let ((commit "dce2d2f6387091ea90357a130fa6d13a6776884b")
3630         (revision "1"))
3631     (package
3632       (name "sbcl-cl-utilities")
3633       (version (git-version "0.0.0" revision commit))
3634       (source
3635        (origin
3636          (method url-fetch)
3637          (uri
3638           (string-append
3639            "https://gitlab.common-lisp.net/cl-utilities/cl-utilities/-/"
3640            "archive/" commit "/cl-utilities-" commit ".tar.gz"))
3641          (sha256
3642           (base32 "1r46v730yf96nk2vb24qmagv9x96xvd08abqwhf02ghgydv1a7z2"))))
3643       (build-system asdf-build-system/sbcl)
3644       (arguments
3645        '(#:asd-file "cl-utilities.asd"
3646          #:asd-system-name "cl-utilities"
3647          #:phases
3648          (modify-phases %standard-phases
3649            (add-after 'unpack 'fix-paths
3650              (lambda* (#:key inputs #:allow-other-keys)
3651                (substitute* "rotate-byte.lisp"
3652                  (("in-package :cl-utilities)" all)
3653                   "in-package :cl-utilities)\n\n#+sbcl\n(require :sb-rotate-byte)")))))))
3654       (home-page "http://common-lisp.net/project/cl-utilities")
3655       (synopsis "A collection of semi-standard utilities")
3656       (description
3657        "On Cliki.net <http://www.cliki.net/Common%20Lisp%20Utilities>, there
3658 is a collection of Common Lisp Utilities, things that everybody writes since
3659 they're not part of the official standard.  There are some very useful things
3660 there; the only problems are that they aren't implemented as well as you'd
3661 like (some aren't implemented at all) and they aren't conveniently packaged
3662 and maintained.  It takes quite a bit of work to carefully implement utilities
3663 for common use, commented and documented, with error checking placed
3664 everywhere some dumb user might make a mistake.")
3665       (license license:public-domain))))
3666
3667 (define-public cl-utilities
3668   (sbcl-package->cl-source-package sbcl-cl-utilities))
3669
3670 (define-public sbcl-map-set
3671   (let ((commit "7b4b545b68b8")
3672         (revision "1"))
3673     (package
3674       (name "sbcl-map-set")
3675       (version (git-version "0.0.0" revision commit))
3676       (source
3677        (origin
3678          (method url-fetch)
3679          (uri (string-append
3680                "https://bitbucket.org/tarballs_are_good/map-set/get/"
3681                commit ".tar.gz"))
3682          (sha256
3683           (base32 "1sx5j5qdsy5fklspfammwb16kjrhkggdavm922a9q86jm5l0b239"))))
3684       (build-system asdf-build-system/sbcl)
3685       (home-page "https://bitbucket.org/tarballs_are_good/map-set")
3686       (synopsis "Set-like data structure")
3687       (description
3688        "Implementation of a set-like data structure with constant time
3689 addition, removal, and random selection.")
3690       (license license:bsd-3))))
3691
3692 (define-public cl-map-set
3693   (sbcl-package->cl-source-package sbcl-map-set))
3694
3695 (define-public sbcl-quri
3696   (let ((commit "76b75103f21ead092c9f715512fa82441ef61185")
3697         (revision "1"))
3698     (package
3699       (name "sbcl-quri")
3700       (version (git-version "0.1.0" revision commit))
3701       (source
3702        (origin
3703          (method git-fetch)
3704          (uri (git-reference
3705                (url "https://github.com/fukamachi/quri.git")
3706                (commit commit)))
3707          (file-name (git-file-name name version))
3708          (sha256
3709           (base32 "1ccbxsgzdibmzq33mmbmmz9vwl6l03xh6nbpsh1hkdvdcl7q0a60"))))
3710       (build-system asdf-build-system/sbcl)
3711       (arguments
3712        ;; Tests fail with: Component QURI-ASD::QURI-TEST not found,
3713        ;; required by #<SYSTEM "quri">. Why?
3714        '(#:tests? #f))
3715       (native-inputs `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
3716                        ("sbcl-prove" ,sbcl-prove)))
3717       (inputs `(("sbcl-babel" ,sbcl-babel)
3718                 ("sbcl-split-sequence" ,sbcl-split-sequence)
3719                 ("sbcl-cl-utilities" ,sbcl-cl-utilities)
3720                 ("sbcl-alexandria" ,sbcl-alexandria)))
3721       (home-page "https://github.com/fukamachi/quri")
3722       (synopsis "Yet another URI library for Common Lisp")
3723       (description
3724        "QURI (pronounced \"Q-ree\") is yet another URI library for Common
3725 Lisp. It is intended to be a replacement of PURI.")
3726       (license license:bsd-3))))
3727
3728 (define-public cl-quri
3729   (sbcl-package->cl-source-package sbcl-quri))
3730
3731 (define-public sbcl-myway
3732   (let ((commit "286230082a11f879c18b93f17ca571c5f676bfb7")
3733         (revision "1"))
3734     (package
3735      (name "sbcl-myway")
3736      (version (git-version "0.1.0" revision commit))
3737      (source
3738       (origin
3739        (method git-fetch)
3740        (uri (git-reference
3741              (url "https://github.com/fukamachi/myway.git")
3742              (commit commit)))
3743        (file-name (git-file-name "myway" version))
3744        (sha256
3745         (base32 "0briia9bk3lbr0frnx39d1qg6i38dm4j6z9w3yga3d40k6df4a90"))))
3746      (build-system asdf-build-system/sbcl)
3747      (arguments
3748       ;; Tests fail with: Component MYWAY-ASD::MYWAY-TEST not found, required
3749       ;; by #<SYSTEM "myway">. Why?
3750       '(#:tests? #f))
3751      (native-inputs
3752       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
3753         ("sbcl-prove" ,sbcl-prove)))
3754      (inputs
3755       `(("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
3756         ("sbcl-quri" ,sbcl-quri)
3757         ("sbcl-map-set" ,sbcl-map-set)))
3758      (home-page "https://github.com/fukamachi/myway")
3759      (synopsis "Sinatra-compatible URL routing library for Common Lisp")
3760      (description "My Way is a Sinatra-compatible URL routing library.")
3761      (license license:llgpl))))
3762
3763 (define-public cl-myway
3764   (sbcl-package->cl-source-package sbcl-myway))
3765
3766 (define-public sbcl-xsubseq
3767   (let ((commit "5ce430b3da5cda3a73b9cf5cee4df2843034422b")
3768         (revision "1"))
3769     (package
3770      (name "sbcl-xsubseq")
3771      (version (git-version "0.0.1" revision commit))
3772      (source
3773       (origin
3774        (method git-fetch)
3775        (uri (git-reference
3776              (url "https://github.com/fukamachi/xsubseq")
3777              (commit commit)))
3778        (file-name (git-file-name name version))
3779        (sha256
3780         (base32 "1xz79q0p2mclf3sqjiwf6izdpb6xrsr350bv4mlmdlm6rg5r99px"))))
3781      (build-system asdf-build-system/sbcl)
3782      (arguments
3783       ;; Tests fail with: Component XSUBSEQ-ASD::XSUBSEQ-TEST not found,
3784       ;; required by #<SYSTEM "xsubseq">. Why?
3785       '(#:tests? #f))
3786      (native-inputs
3787       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
3788         ("sbcl-prove" ,sbcl-prove)))
3789      (home-page "https://github.com/fukamachi/xsubseq")
3790      (synopsis "Efficient way to use \"subseq\"s in Common Lisp")
3791      (description
3792       "XSubseq provides functions to be able to handle \"subseq\"s more
3793 effieiently.")
3794      (license license:bsd-2))))
3795
3796 (define-public cl-xsubseq
3797   (sbcl-package->cl-source-package sbcl-xsubseq))
3798
3799 (define-public sbcl-smart-buffer
3800   (let ((commit "09b9a9a0b3abaa37abe9a730f5aac2643dca4e62")
3801         (revision "1"))
3802     (package
3803       (name "sbcl-smart-buffer")
3804       (version (git-version "0.0.1" revision commit))
3805       (source
3806        (origin
3807          (method git-fetch)
3808          (uri (git-reference
3809                (url "https://github.com/fukamachi/smart-buffer")
3810                (commit commit)))
3811          (file-name (git-file-name name version))
3812          (sha256
3813           (base32 "0qz1zzxx0wm5ff7gpgsq550a59p0qj594zfmm2rglj97dahj54l7"))))
3814       (build-system asdf-build-system/sbcl)
3815       (arguments
3816        ;; Tests fail with: Component SMART-BUFFER-ASD::SMART-BUFFER-TEST not
3817        ;; found, required by #<SYSTEM "smart-buffer">. Why?
3818        `(#:tests? #f))
3819       (native-inputs
3820        `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
3821          ("sbcl-prove" ,sbcl-prove)))
3822       (inputs
3823        `(("sbcl-xsubseq" ,sbcl-xsubseq)
3824          ("sbcl-flexi-streams" ,sbcl-flexi-streams)))
3825       (home-page "https://github.com/fukamachi/smart-buffer")
3826       (synopsis "Smart octets buffer")
3827       (description
3828        "Smart-buffer provides an output buffer which changes the destination
3829 depending on content size.")
3830       (license license:bsd-3))))
3831
3832 (define-public cl-smart-buffer
3833   (sbcl-package->cl-source-package sbcl-smart-buffer))
3834
3835 (define-public sbcl-fast-http
3836   (let ((commit "f9e7597191bae380503e20724fd493a24d024935")
3837         (revision "1"))
3838     (package
3839       (name "sbcl-fast-http")
3840       (version (git-version "0.2.0" revision commit))
3841       (source
3842        (origin
3843          (method git-fetch)
3844          (uri (git-reference
3845                (url "https://github.com/fukamachi/fast-http")
3846                (commit commit)))
3847          (file-name (git-file-name name version))
3848          (sha256
3849           (base32 "0qdmwv2zm0sizxdb8nnclgwl0nfjcbjaimbakavikijw7lr9b4jp"))))
3850       (build-system asdf-build-system/sbcl)
3851       (arguments
3852        ;; Tests fail with: Component FAST-HTTP-ASD::FAST-HTTP-TEST not found,
3853        ;; required by #<SYSTEM "fast-http">. Why?
3854        `(#:tests? #f))
3855       (native-inputs
3856        `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
3857          ("sbcl-prove" ,sbcl-prove)))
3858       (inputs
3859        `(("sbcl-alexandria" ,sbcl-alexandria)
3860          ("sbcl-proc-parse" ,sbcl-proc-parse)
3861          ("sbcl-xsubseq" ,sbcl-xsubseq)
3862          ("sbcl-smart-buffer" ,sbcl-smart-buffer)
3863          ("sbcl-cl-utilities" ,sbcl-cl-utilities)))
3864       (home-page "https://github.com/fukamachi/fast-http")
3865       (synopsis "HTTP request/response parser for Common Lisp")
3866       (description
3867        "@code{fast-http} is a HTTP request/response protocol parser for Common
3868 Lisp.")
3869       ;; Author specified the MIT license
3870       (license license:expat))))
3871
3872 (define-public cl-fast-http
3873   (sbcl-package->cl-source-package sbcl-fast-http))
3874
3875 (define-public sbcl-static-vectors
3876   (let ((commit "0681eac1f49370cde03e64b077251e8abf47d702")
3877         (revision "1"))
3878     (package
3879      (name "sbcl-static-vectors")
3880      (version (git-version "1.8.3" revision commit))
3881      (source
3882       (origin
3883        (method git-fetch)
3884        (uri (git-reference
3885              (url "https://github.com/sionescu/static-vectors.git")
3886              (commit commit)))
3887        (file-name (git-file-name name version))
3888        (sha256
3889         (base32 "138nlsq14hv8785ycjm6jw3i6ablhq8vcwys7q09y80arcgrg6r3"))))
3890      (native-inputs
3891       `(("sbcl-fiveam" ,sbcl-fiveam)))
3892      (inputs
3893       `(("sbcl-cffi-grovel" ,sbcl-cffi-grovel)
3894         ("sbcl-cffi" ,sbcl-cffi)))
3895      (build-system asdf-build-system/sbcl)
3896      (home-page "http://common-lisp.net/projects/iolib/")
3897      (synopsis "Allocate SIMPLE-ARRAYs in static memory")
3898      (description
3899       "With @code{static-vectors}, you can create vectors allocated in static
3900 memory.")
3901      (license license:expat))))
3902
3903 (define-public cl-static-vectors
3904   (sbcl-package->cl-source-package sbcl-static-vectors))
3905
3906 (define-public sbcl-marshal
3907   (let ((commit "eff1b15f2b0af2f26f71ad6a4dd5c4beab9299ec")
3908         (revision "1"))
3909     (package
3910      (name "sbcl-marshal")
3911      (version (git-version "1.3.0" revision commit))
3912      (source
3913       (origin
3914        (method git-fetch)
3915        (uri (git-reference
3916              (url "https://github.com/wlbr/cl-marshal.git")
3917              (commit commit)))
3918        (file-name (git-file-name name version))
3919        (sha256
3920         (base32 "08qs6fhk38xpkkjkpcj92mxx0lgy4ygrbbzrmnivdx281syr0gwh"))))
3921      (build-system asdf-build-system/sbcl)
3922      (home-page "https://github.com/wlbr/cl-marshal")
3923      (synopsis "Simple (de)serialization of Lisp datastructures")
3924      (description
3925       "Simple and fast marshalling of Lisp datastructures.  Convert any object
3926 into a string representation, put it on a stream an revive it from there.
3927 Only minimal changes required to make your CLOS objects serializable.")
3928      (license license:expat))))
3929
3930 (define-public cl-marshal
3931   (sbcl-package->cl-source-package sbcl-marshal))
3932
3933 (define-public sbcl-checkl
3934   (let ((commit "80328800d047fef9b6e32dfe6bdc98396aee3cc9")
3935         (revision "1"))
3936     (package
3937       (name "sbcl-checkl")
3938       (version (git-version "0.0.0" revision commit))
3939       (source
3940        (origin
3941          (method git-fetch)
3942          (uri (git-reference
3943                (url "https://github.com/rpav/CheckL.git")
3944                (commit commit)))
3945          (file-name (git-file-name name version))
3946          (sha256
3947           (base32 "0bpisihx1gay44xmyr1dmhlwh00j0zzi04rp9fy35i95l2r4xdlx"))))
3948       (build-system asdf-build-system/sbcl)
3949       (arguments
3950        ;; Error while trying to load definition for system checkl-test from
3951        ;; pathname [...]/checkl-test.asd: The function CHECKL:DEFINE-TEST-OP
3952        ;; is undefined.
3953        '(#:tests? #f))
3954       (native-inputs
3955        `(("sbcl-fiveam" ,sbcl-fiveam)))
3956       (inputs
3957        `(("sbcl-marshal" ,sbcl-marshal)))
3958       (home-page "https://github.com/rpav/CheckL/")
3959       (synopsis "Dynamic testing for Common Lisp")
3960       (description
3961        "CheckL lets you write tests dynamically, it checks resulting values
3962 against the last run.")
3963       ;; The author specifies both LLGPL and "BSD", but the "BSD" license
3964       ;; isn't specified anywhere, so I don't know which kind.  LLGPL is the
3965       ;; stronger of the two and so I think only listing this should suffice.
3966       (license license:llgpl))))
3967
3968 (define-public cl-checkl
3969   (sbcl-package->cl-source-package sbcl-checkl))
3970
3971 (define-public sbcl-fast-io
3972   (let ((commit "dc3a71db7e9b756a88781ae9c342fe9d4bbab51c")
3973         (revision "1"))
3974     (package
3975      (name "sbcl-fast-io")
3976      (version (git-version "1.0.0" revision commit))
3977      (source
3978       (origin
3979        (method git-fetch)
3980        (uri (git-reference
3981              (url "https://github.com/rpav/fast-io.git")
3982              (commit commit)))
3983        (file-name (git-file-name name version))
3984        (sha256
3985         (base32 "1jsp6xvi26ln6fdy5j5zi05xvan8jsqdhisv552dy6xg6ws8i1yq"))))
3986      (build-system asdf-build-system/sbcl)
3987      (arguments
3988       ;; Error while trying to load definition for system fast-io-test from
3989       ;; pathname [...]/fast-io-test.asd: The function CHECKL:DEFINE-TEST-OP
3990       ;; is undefined.
3991       '(#:tests? #f))
3992      (native-inputs
3993       `(("sbcl-fiveam" ,sbcl-fiveam)
3994         ("sbcl-checkl" ,sbcl-checkl)))
3995      (inputs
3996       `(("sbcl-alexandria" ,sbcl-alexandria)
3997         ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)
3998         ("sbcl-static-vectors" ,sbcl-static-vectors)))
3999      (home-page "https://github.com/rpav/fast-io")
4000      (synopsis "Fast octet-vector/stream I/O for Common Lisp")
4001      (description
4002       "Fast-io is about improving performance to octet-vectors and octet
4003 streams (though primarily the former, while wrapping the latter).")
4004      ;; Author specifies this as NewBSD which is an alias
4005      (license license:bsd-3))))
4006
4007 (define-public cl-fast-io
4008   (sbcl-package->cl-source-package sbcl-fast-io))
4009
4010 (define-public sbcl-jonathan
4011   (let ((commit "1f448b4f7ac8265e56e1c02b32ce383e65316300")
4012         (revision "1"))
4013     (package
4014      (name "sbcl-jonathan")
4015      (version (git-version "0.1.0" revision commit))
4016      (source
4017       (origin
4018        (method git-fetch)
4019        (uri (git-reference
4020              (url "https://github.com/Rudolph-Miller/jonathan.git")
4021              (commit commit)))
4022        (file-name (git-file-name name version))
4023        (sha256
4024         (base32 "14x4iwz3mbag5jzzzr4sb6ai0m9r4q4kyypbq32jmsk2dx1hi807"))))
4025      (build-system asdf-build-system/sbcl)
4026      (arguments
4027       ;; Tests fail with: Component JONATHAN-ASD::JONATHAN-TEST not found,
4028       ;; required by #<SYSTEM "jonathan">. Why?
4029       `(#:tests? #f))
4030      (native-inputs
4031       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4032         ("sbcl-prove" ,sbcl-prove)))
4033      (inputs
4034       `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
4035         ("sbcl-cl-syntax-annot" ,sbcl-cl-syntax-annot)
4036         ("sbcl-fast-io" ,sbcl-fast-io)
4037         ("sbcl-proc-parse" ,sbcl-proc-parse)
4038         ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)))
4039      (home-page "http://rudolph-miller.github.io/jonathan/overview.html")
4040      (synopsis "JSON encoder and decoder")
4041      (description
4042       "High performance JSON encoder and decoder.  Currently support: SBCL,
4043 CCL.")
4044      ;; Author specifies the MIT license
4045      (license license:expat))))
4046
4047 (define-public cl-jonathan
4048   (sbcl-package->cl-source-package sbcl-jonathan))
4049
4050 (define-public sbcl-http-body
4051   (let ((commit "dd01dc4f5842e3d29728552e5163acce8386eb73")
4052         (revision "1"))
4053     (package
4054      (name "sbcl-http-body")
4055      (version (git-version "0.1.0" revision commit))
4056      (source
4057       (origin
4058        (method git-fetch)
4059        (uri (git-reference
4060              (url "https://github.com/fukamachi/http-body")
4061              (commit commit)))
4062        (file-name (git-file-name name version))
4063        (sha256
4064         (base32 "1jd06snjvxcprhapgfq8sx0y5lrldkvhf206ix6d5a23dd6zcmr0"))))
4065      (build-system asdf-build-system/sbcl)
4066      (arguments
4067       ;; Tests fail with: Component HTTP-BODY-ASD::HTTP-BODY-TEST not
4068       ;; found, required by #<SYSTEM "http-body">. Why?
4069       `(#:tests? #f))
4070      (native-inputs
4071       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4072         ("sbcl-prove" ,sbcl-prove)))
4073      (inputs
4074       `(("sbcl-fast-http" ,sbcl-fast-http)
4075         ("sbcl-jonathan" ,sbcl-jonathan)
4076         ("sbcl-quri" ,sbcl-quri)))
4077      (home-page "https://github.com/fukamachi/http-body")
4078      (synopsis "HTTP POST data parser")
4079      (description
4080       "HTTP-Body parses HTTP POST data and returns POST parameters.  It
4081 supports application/x-www-form-urlencoded, application/json, and
4082 multipart/form-data.")
4083      (license license:bsd-2))))
4084
4085 (define-public cl-http-body
4086   (sbcl-package->cl-source-package sbcl-http-body))
4087
4088 (define-public sbcl-circular-streams
4089   (let ((commit "e770bade1919c5e8533dd2078c93c3d3bbeb38df")
4090         (revision "1"))
4091     (package
4092      (name "sbcl-circular-streams")
4093      (version (git-version "0.1.0" revision commit))
4094      (source
4095       (origin
4096        (method git-fetch)
4097        (uri (git-reference
4098              (url "https://github.com/fukamachi/circular-streams")
4099              (commit commit)))
4100        (file-name (git-file-name name version))
4101        (sha256
4102         (base32 "1wpw6d5cciyqcf92f7mvihak52pd5s47kk4qq6f0r2z2as68p5rs"))))
4103      (build-system asdf-build-system/sbcl)
4104      (arguments
4105       ;; The tests depend on cl-test-more which is now prove. Prove
4106       ;; tests aren't working for some reason.
4107       `(#:tests? #f))
4108      (inputs
4109       `(("sbcl-fast-io" ,sbcl-fast-io)
4110         ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)))
4111      (home-page "https://github.com/fukamachi/circular-streams")
4112      (synopsis "Circularly readable streams for Common Lisp")
4113      (description
4114       "Circular-Streams allows you to read streams circularly by wrapping real
4115 streams. Once you reach end-of-file of a stream, it's file position will be
4116 reset to 0 and you're able to read it again.")
4117      (license license:llgpl))))
4118
4119 (define-public cl-circular-streams
4120   (sbcl-package->cl-source-package sbcl-circular-streams))
4121
4122 (define-public sbcl-lack-request
4123   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4124         (revision "1"))
4125     (package
4126      (name "sbcl-lack-request")
4127      (version (git-version "0.1.0" revision commit))
4128      (source
4129       (origin
4130        (method git-fetch)
4131        (uri (git-reference
4132              (url "https://github.com/fukamachi/lack.git")
4133              (commit commit)))
4134        (file-name (git-file-name "lack-request" version))
4135        (sha256
4136         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4137      (build-system asdf-build-system/sbcl)
4138      (arguments
4139       '(#:asd-file "lack-request.asd"
4140         #:asd-system-name "lack-request"
4141         #:test-asd-file "t-lack-request.asd"
4142         ;; XXX: Component :CLACK-TEST not found
4143         #:tests? #f))
4144      (native-inputs
4145       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4146         ("sbcl-prove" ,sbcl-prove)))
4147      (inputs
4148       `(("sbcl-quri" ,sbcl-quri)
4149         ("sbcl-http-body" ,sbcl-http-body)
4150         ("sbcl-circular-streams" ,sbcl-circular-streams)))
4151      (home-page "https://github.com/fukamachi/lack")
4152      (synopsis "Lack, the core of Clack")
4153      (description
4154       "Lack is a Common Lisp library which allows web applications to be
4155 constructed of modular components.  It was originally a part of Clack, however
4156 it's going to be rewritten as an individual project since Clack v2 with
4157 performance and simplicity in mind.")
4158      (license license:llgpl))))
4159
4160 (define-public cl-lack-request
4161   (sbcl-package->cl-source-package sbcl-lack-request))
4162
4163 (define-public sbcl-local-time
4164   (let ((commit "beac054eef428552b63d4ae7820c32ffef9a3015")
4165         (revision "1"))
4166     (package
4167      (name "sbcl-local-time")
4168      (version (git-version "1.0.6" revision commit))
4169      (source
4170       (origin
4171        (method git-fetch)
4172        (uri (git-reference
4173              (url "https://github.com/dlowe-net/local-time.git")
4174              (commit commit)))
4175        (file-name (git-file-name name version))
4176        (sha256
4177         (base32 "0xhkmgxh41dg2wwlsp0h2l41jp144xn4gpxhh0lna6kh0560w2cc"))))
4178      (build-system asdf-build-system/sbcl)
4179      (arguments
4180       ;; TODO: Component :STEFIL not found, required by #<SYSTEM
4181       ;; "local-time/test">
4182       '(#:tests? #f))
4183      (native-inputs
4184       `(("stefil" ,sbcl-hu.dwim.stefil)))
4185      (inputs
4186       `(("sbcl-cl-fad" ,sbcl-cl-fad)))
4187      (home-page "https://common-lisp.net/project/local-time/")
4188      (synopsis "Time manipulation library for Common Lisp")
4189      (description
4190       "The LOCAL-TIME library is a Common Lisp library for the manipulation of
4191 dates and times.  It is based almost entirely upon Erik Naggum's paper \"The
4192 Long Painful History of Time\".")
4193      (license license:expat))))
4194
4195 (define-public cl-local-time
4196   (sbcl-package->cl-source-package sbcl-local-time))
4197
4198 (define-public sbcl-lack-response
4199   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4200         (revision "1"))
4201     (package
4202      (name "sbcl-lack-response")
4203      (version (git-version "0.1.0" revision commit))
4204      (source
4205       (origin
4206        (method git-fetch)
4207        (uri (git-reference
4208              (url "https://github.com/fukamachi/lack.git")
4209              (commit commit)))
4210        (file-name (git-file-name name version))
4211        (sha256
4212         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4213      (build-system asdf-build-system/sbcl)
4214      (arguments
4215       '(#:asd-file "lack-response.asd"
4216         #:asd-system-name "lack-response"
4217         ;; XXX: no tests for lack-response.
4218         #:tests? #f))
4219      (native-inputs
4220       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4221         ("sbcl-prove" ,sbcl-prove)))
4222      (inputs
4223       `(("sbcl-quri" ,sbcl-quri)
4224         ("sbcl-http-body" ,sbcl-http-body)
4225         ("sbcl-circular-streams" ,sbcl-circular-streams)
4226         ("sbcl-local-time" ,sbcl-local-time)))
4227      (home-page "https://github.com/fukamachi/lack")
4228      (synopsis "Lack, the core of Clack")
4229      (description
4230       "Lack is a Common Lisp library which allows web applications to be
4231 constructed of modular components.  It was originally a part of Clack, however
4232 it's going to be rewritten as an individual project since Clack v2 with
4233 performance and simplicity in mind.")
4234      (license license:llgpl))))
4235
4236 (define-public cl-lack-response
4237   (sbcl-package->cl-source-package sbcl-lack-response))
4238
4239 (define-public sbcl-lack-component
4240   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4241         (revision "1"))
4242     (package
4243      (name "sbcl-lack-component")
4244      (version (git-version "0.0.0" revision commit))
4245      (source
4246       (origin
4247        (method git-fetch)
4248        (uri (git-reference
4249              (url "https://github.com/fukamachi/lack.git")
4250              (commit commit)))
4251        (file-name (git-file-name "lack-component" version))
4252        (sha256
4253         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4254      (build-system asdf-build-system/sbcl)
4255      (arguments
4256       '(#:asd-file "lack-component.asd"
4257         #:asd-system-name "lack-component"
4258         #:test-asd-file "t-lack-component.asd"
4259         ;; XXX: Component :LACK-TEST not found
4260         #:tests? #f))
4261      (native-inputs
4262       `(("prove-asdf" ,sbcl-prove-asdf)))
4263      (home-page "https://github.com/fukamachi/lack")
4264      (synopsis "Lack, the core of Clack")
4265      (description
4266       "Lack is a Common Lisp library which allows web applications to be
4267 constructed of modular components.  It was originally a part of Clack, however
4268 it's going to be rewritten as an individual project since Clack v2 with
4269 performance and simplicity in mind.")
4270      (license license:llgpl))))
4271
4272 (define-public cl-lack-component
4273   (sbcl-package->cl-source-package sbcl-lack-component))
4274
4275 (define-public sbcl-lack-util
4276   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4277         (revision "1"))
4278     (package
4279      (name "sbcl-lack-util")
4280      (version (git-version "0.1.0" revision commit))
4281      (source
4282       (origin
4283        (method git-fetch)
4284        (uri (git-reference
4285              (url "https://github.com/fukamachi/lack.git")
4286              (commit commit)))
4287        (file-name (git-file-name "lack-util" version))
4288        (sha256
4289         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4290      (build-system asdf-build-system/sbcl)
4291      (arguments
4292       '(#:asd-file "lack-util.asd"
4293         #:asd-system-name "lack-util"
4294         #:test-asd-file "t-lack-util.asd"
4295         ;; XXX: Component :LACK-TEST not found
4296         #:tests? #f))
4297      (native-inputs
4298       `(("prove-asdf" ,sbcl-prove-asdf)))
4299      (inputs
4300       `(("sbcl-ironclad" ,sbcl-ironclad)))
4301      (home-page "https://github.com/fukamachi/lack")
4302      (synopsis "Lack, the core of Clack")
4303      (description
4304       "Lack is a Common Lisp library which allows web applications to be
4305 constructed of modular components.  It was originally a part of Clack, however
4306 it's going to be rewritten as an individual project since Clack v2 with
4307 performance and simplicity in mind.")
4308      (license license:llgpl))))
4309
4310 (define-public cl-lack-util
4311   (sbcl-package->cl-source-package sbcl-lack-util))
4312
4313 (define-public sbcl-lack-middleware-backtrace
4314   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4315         (revision "1"))
4316     (package
4317      (name "sbcl-lack-middleware-backtrace")
4318      (version (git-version "0.1.0" revision commit))
4319      (source
4320       (origin
4321        (method git-fetch)
4322        (uri (git-reference
4323              (url "https://github.com/fukamachi/lack.git")
4324              (commit commit)))
4325        (file-name (git-file-name "lack-middleware-backtrace" version))
4326        (sha256
4327         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4328      (build-system asdf-build-system/sbcl)
4329      (arguments
4330       '(#:asd-file "lack-middleware-backtrace.asd"
4331         #:asd-system-name "lack-middleware-backtrace"
4332         #:test-asd-file "t-lack-middleware-backtrace.asd"
4333         ;; XXX: Component :LACK not found
4334         #:tests? #f))
4335      (native-inputs
4336       `(("prove-asdf" ,sbcl-prove-asdf)))
4337      (home-page "https://github.com/fukamachi/lack")
4338      (synopsis "Lack, the core of Clack")
4339      (description
4340       "Lack is a Common Lisp library which allows web applications to be
4341 constructed of modular components.  It was originally a part of Clack, however
4342 it's going to be rewritten as an individual project since Clack v2 with
4343 performance and simplicity in mind.")
4344      (license license:llgpl))))
4345
4346 (define-public cl-lack-middleware-backtrace
4347   (sbcl-package->cl-source-package sbcl-lack-middleware-backtrace))
4348
4349 (define-public sbcl-trivial-mimes
4350   (let ((commit "303f8ac0aa6ca0bc139aa3c34822e623c3723fab")
4351         (revision "1"))
4352     (package
4353       (name "sbcl-trivial-mimes")
4354       (version (git-version "1.1.0" revision commit))
4355       (source
4356        (origin
4357          (method git-fetch)
4358          (uri (git-reference
4359                (url "https://github.com/Shinmera/trivial-mimes.git")
4360                (commit commit)))
4361          (file-name (git-file-name name version))
4362          (sha256
4363           (base32 "17jxgl47r695bvsb7wi3n2ws5rp1zzgvw0zii8cy5ggw4b4ayv6m"))))
4364       (build-system asdf-build-system/sbcl)
4365       (arguments
4366        '(#:phases
4367          (modify-phases %standard-phases
4368            (add-after
4369                'unpack 'fix-paths
4370              (lambda* (#:key inputs #:allow-other-keys)
4371                (let ((anchor "#p\"/etc/mime.types\""))
4372                  (substitute* "mime-types.lisp"
4373                    ((anchor all)
4374                     (string-append
4375                      anchor "\n"
4376                      "(asdf:system-relative-pathname :trivial-mimes "
4377                      "\"../../share/common-lisp/" (%lisp-type)
4378                      "-source/trivial-mimes/mime.types\")")))))))))
4379       (native-inputs
4380        `(("stefil" ,sbcl-hu.dwim.stefil)))
4381       (inputs
4382        `(("sbcl-cl-fad" ,sbcl-cl-fad)))
4383       (home-page "http://shinmera.github.io/trivial-mimes/")
4384       (synopsis "Tiny Common Lisp library to detect mime types in files")
4385       (description
4386        "This is a teensy library that provides some functions to determine the
4387 mime-type of a file.")
4388       (license license:artistic2.0))))
4389
4390 (define-public cl-trivial-mimes
4391   (sbcl-package->cl-source-package sbcl-trivial-mimes))
4392
4393 (define-public ecl-trivial-mimes
4394   (sbcl-package->ecl-package sbcl-trivial-mimes))
4395
4396 (define-public sbcl-lack-middleware-static
4397   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4398         (revision "1"))
4399     (package
4400      (name "sbcl-lack-middleware-static")
4401      (version (git-version "0.1.0" revision commit))
4402      (source
4403       (origin
4404        (method git-fetch)
4405        (uri (git-reference
4406              (url "https://github.com/fukamachi/lack.git")
4407              (commit commit)))
4408        (file-name (git-file-name "lack-middleware-static" version))
4409        (sha256
4410         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4411      (build-system asdf-build-system/sbcl)
4412      (arguments
4413       '(#:asd-file "lack-middleware-static.asd"
4414         #:asd-system-name "lack-middleware-static"
4415         #:test-asd-file "t-lack-middleware-static.asd"
4416         ;; XXX: Component :LACK not found
4417         #:tests? #f))
4418      (native-inputs
4419       `(("prove-asdf" ,sbcl-prove-asdf)))
4420      (inputs
4421       `(("sbcl-ironclad" ,sbcl-ironclad)
4422         ("sbcl-trivial-mimes" ,sbcl-trivial-mimes)
4423         ("sbcl-local-time" ,sbcl-local-time)))
4424      (home-page "https://github.com/fukamachi/lack")
4425      (synopsis "Lack, the core of Clack")
4426      (description
4427       "Lack is a Common Lisp library which allows web applications to be
4428 constructed of modular components.  It was originally a part of Clack, however
4429 it's going to be rewritten as an individual project since Clack v2 with
4430 performance and simplicity in mind.")
4431      (license license:llgpl))))
4432
4433 (define-public cl-lack-middleware-static
4434   (sbcl-package->cl-source-package sbcl-lack-middleware-static))
4435
4436 (define-public sbcl-lack
4437   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4438         (revision "1"))
4439     (package
4440      (name "sbcl-lack")
4441      (version (git-version "0.1.0" revision commit))
4442      (source
4443       (origin
4444        (method git-fetch)
4445        (uri (git-reference
4446              (url "https://github.com/fukamachi/lack.git")
4447              (commit commit)))
4448        (file-name (git-file-name "lack" version))
4449        (sha256
4450         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4451      (build-system asdf-build-system/sbcl)
4452      (arguments
4453       '(#:test-asd-file "t-lack.asd"
4454         ;; XXX: Component :CLACK not found
4455         #:tests? #f))
4456      (native-inputs
4457       `(("prove-asdf" ,sbcl-prove-asdf)))
4458      (inputs
4459       `(("sbcl-lack-component" ,sbcl-lack-component)
4460         ("sbcl-lack-util" ,sbcl-lack-util)))
4461      (home-page "https://github.com/fukamachi/lack")
4462      (synopsis "Lack, the core of Clack")
4463      (description
4464       "Lack is a Common Lisp library which allows web applications to be
4465 constructed of modular components.  It was originally a part of Clack, however
4466 it's going to be rewritten as an individual project since Clack v2 with
4467 performance and simplicity in mind.")
4468      (license license:llgpl))))
4469
4470 (define-public cl-lack
4471   (sbcl-package->cl-source-package sbcl-lack))
4472
4473 (define-public sbcl-ningle
4474   (let ((commit "50bd4f09b5a03a7249bd4d78265d6451563b25ad")
4475         (revision "1"))
4476     (package
4477       (name "sbcl-ningle")
4478       (version (git-version "0.3.0" revision commit))
4479       (source
4480        (origin
4481          (method git-fetch)
4482          (uri (git-reference
4483                (url "https://github.com/fukamachi/ningle.git")
4484                (commit commit)))
4485          (file-name (git-file-name name version))
4486          (sha256
4487           (base32 "1bsl8cnxhacb8p92z9n89vhk1ikmij5zavk0m2zvmj7iqm79jzgw"))))
4488       (build-system asdf-build-system/sbcl)
4489       (arguments
4490        ;; TODO: pull in clack-test
4491        '(#:tests? #f
4492          #:phases
4493          (modify-phases %standard-phases
4494            (delete 'cleanup-files)
4495            (delete 'cleanup)
4496            (add-before 'cleanup 'combine-fasls
4497              (lambda* (#:key outputs #:allow-other-keys)
4498                (let* ((out (assoc-ref outputs "out"))
4499                       (lib (string-append out "/lib/sbcl"))
4500                       (ningle-path (string-append lib "/ningle"))
4501                       (fasl-files (find-files out "\\.fasl$")))
4502                  (mkdir-p ningle-path)
4503                  (let ((fasl-path (lambda (name)
4504                                     (string-append ningle-path
4505                                                    "/"
4506                                                    (basename name)
4507                                                    "--system.fasl"))))
4508                    (for-each (lambda (file)
4509                                (rename-file file
4510                                             (fasl-path
4511                                              (basename file ".fasl"))))
4512                              fasl-files))
4513                  fasl-files)
4514                #t)))))
4515       (native-inputs
4516        `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4517          ("sbcl-prove" ,sbcl-prove)))
4518       (inputs
4519        `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
4520          ("sbcl-cl-syntax-annot" ,sbcl-cl-syntax-annot)
4521          ("sbcl-myway" ,sbcl-myway)
4522          ("sbcl-lack-request" ,sbcl-lack-request)
4523          ("sbcl-lack-response" ,sbcl-lack-response)
4524          ("sbcl-lack-component" ,sbcl-lack-component)
4525          ("sbcl-alexandria" ,sbcl-alexandria)
4526          ("sbcl-babel" ,sbcl-babel)))
4527       (home-page "http://8arrow.org/ningle/")
4528       (synopsis "Super micro framework for Common Lisp")
4529       (description
4530        "Ningle is a lightweight web application framework for Common Lisp.")
4531       (license license:llgpl))))
4532
4533 (define-public cl-ningle
4534   (sbcl-package->cl-source-package sbcl-ningle))
4535
4536 (define-public sbcl-clack
4537   (let ((commit "e3e032843bb1220ab96263c411aa7f2feb4746e0")
4538         (revision "1"))
4539     (package
4540      (name "sbcl-clack")
4541      (version (git-version "2.0.0" revision commit))
4542      (source
4543       (origin
4544        (method git-fetch)
4545        (uri (git-reference
4546              (url "https://github.com/fukamachi/clack.git")
4547              (commit commit)))
4548        (file-name (git-file-name name version))
4549        (sha256
4550         (base32 "1ymzs6qyrwhlj6cgqsnpyn6g5cbp7a3s1vgxwna20y2q7y4iacy0"))))
4551      (build-system asdf-build-system/sbcl)
4552      (inputs
4553       `(("sbcl-lack" ,sbcl-lack)
4554         ("sbcl-lack-middleware-backtrace" ,sbcl-lack-middleware-backtrace)
4555         ("sbcl-bordeaux-threads" ,sbcl-bordeaux-threads)))
4556      (home-page "https://github.com/fukamachi/clack")
4557      (synopsis "Web Application Environment for Common Lisp")
4558      (description
4559       "Clack is a web application environment for Common Lisp inspired by
4560 Python's WSGI and Ruby's Rack.")
4561      (license license:llgpl))))
4562
4563 (define-public cl-clack
4564   (sbcl-package->cl-source-package sbcl-clack))
4565
4566 (define-public sbcl-log4cl
4567   (let ((commit "611e094458504b938d49de904eab141285328c7c")
4568         (revision "1"))
4569     (package
4570       (name "sbcl-log4cl")
4571       (build-system asdf-build-system/sbcl)
4572       (version "1.1.2")
4573       (source
4574        (origin
4575          (method git-fetch)
4576          (uri (git-reference
4577                (url "https://github.com/sharplispers/log4cl")
4578                (commit commit)))
4579          (file-name (git-file-name name version))
4580          (sha256
4581           (base32
4582            "08jly0s0g26b56hhpfizxsb4j0yvbh946sd205gr42dkzv8l7dsc"))))
4583       ;; FIXME: tests require stefil, sbcl-hu.dwim.stefil wont work
4584       (arguments
4585        `(#:tests? #f))
4586       (inputs `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
4587       (synopsis "Common Lisp logging framework, modeled after Log4J")
4588       (home-page "https://github.com/7max/log4cl")
4589       (description "This is a Common Lisp logging framework that can log at
4590 various levels and mix text with expressions.")
4591       (license license:asl2.0))))
4592
4593 (define-public cl-log4cl
4594   (sbcl-package->cl-source-package sbcl-log4cl))
4595
4596 (define-public ecl-log4cl
4597   (sbcl-package->ecl-package sbcl-log4cl))
4598
4599 (define-public sbcl-find-port
4600   (let ((commit "00c96a25af93a0f8681d34ec548861f2d7485478")
4601         (revision "1"))
4602     (package
4603       (name "sbcl-find-port")
4604       (build-system asdf-build-system/sbcl)
4605       (version "0.1")
4606       (home-page "https://github.com/eudoxia0/find-port")
4607       (source
4608        (origin
4609          (method git-fetch)
4610          (uri (git-reference
4611                (url home-page)
4612                (commit commit)))
4613          (file-name (git-file-name name version))
4614          (sha256
4615           (base32
4616            "0d6dzbb45jh0rx90wgs6v020k2xa87mvzas3mvfzvivjvqqlpryq"))))
4617       (native-inputs
4618        `(("fiveam" ,sbcl-fiveam)))
4619       (inputs
4620        `(("sbcl-usocket" ,sbcl-usocket)))
4621       (synopsis "Find open ports programmatically in Common Lisp")
4622       (description "This is a small Common Lisp library that finds an open
4623 port within a range.")
4624       (license license:expat))))
4625
4626 (define-public cl-find-port
4627   (sbcl-package->cl-source-package sbcl-find-port))
4628
4629 (define-public ecl-find-port
4630   (sbcl-package->ecl-package sbcl-find-port))
4631
4632 (define-public sbcl-clunit
4633   (let ((commit "6f6d72873f0e1207f037470105969384f8380628")
4634         (revision "1"))
4635     (package
4636       (name "sbcl-clunit")
4637       (version (git-version "0.2.3" revision commit))
4638       (source
4639        (origin
4640          (method git-fetch)
4641          (uri (git-reference
4642                (url "https://github.com/tgutu/clunit.git")
4643                (commit commit)))
4644          (file-name (git-file-name name version))
4645          (sha256
4646           (base32
4647            "1idf2xnqzlhi8rbrqmzpmb3i1l6pbdzhhajkmhwbp6qjkmxa4h85"))))
4648       (build-system asdf-build-system/sbcl)
4649       (synopsis "CLUnit is a Common Lisp unit testing framework")
4650       (description
4651        "CLUnit is a Common Lisp unit testing framework.  It is designed
4652 to be easy to use so that you can quickly start testing.  CLUnit
4653 provides a rich set of features aimed at improving your unit testing
4654 experience.")
4655       (home-page "http://tgutu.github.io/clunit/")
4656       ;; MIT License
4657       (license license:expat))))
4658
4659 (define-public cl-clunit
4660   (sbcl-package->cl-source-package sbcl-clunit))
4661
4662 (define-public ecl-clunit
4663   (sbcl-package->ecl-package sbcl-clunit))
4664
4665 (define-public sbcl-py4cl
4666   (let ((commit "4c8a2b0814fd311f978964f825ce012290f60136")
4667         (revision "1"))
4668     (package
4669       (name "sbcl-py4cl")
4670       (version (git-version "0.0.0" revision commit))
4671       (source
4672        (origin
4673          (method git-fetch)
4674          (uri (git-reference
4675                (url "https://github.com/bendudson/py4cl.git")
4676                (commit commit)))
4677          (file-name (git-file-name name version))
4678          (sha256
4679           (base32
4680            "15mk7qdqjkj56gdnbyrdyz6r7m1h26ldvn6ch96pmvg5vmr1m45r"))
4681          (modules '((guix build utils)))))
4682       (build-system asdf-build-system/sbcl)
4683       (native-inputs
4684        `(("sbcl-clunit" ,sbcl-clunit)))
4685       (inputs
4686        `(("sbcl-trivial-garbage" ,sbcl-trivial-garbage)))
4687       (propagated-inputs
4688        ;; This package doesn't do anything without python available
4689        `(("python" ,python)
4690          ;; For multi-dimensional array support
4691          ("python-numpy" ,python-numpy)))
4692       (arguments
4693        '(#:phases
4694          (modify-phases %standard-phases
4695            (add-after 'unpack 'replace-*base-directory*-var
4696              (lambda* (#:key outputs #:allow-other-keys)
4697                ;; In the ASD, the author makes an attempt to
4698                ;; programatically determine the location of the
4699                ;; source-code so lisp can call into "py4cl.py". We can
4700                ;; hard-code this since we know where this file will
4701                ;; reside.
4702                (substitute* "src/callpython.lisp"
4703                  (("py4cl/config:\\*base-directory\\*")
4704                   (string-append
4705                    "\""
4706                    (assoc-ref outputs "out")
4707                    "/share/common-lisp/sbcl-source/py4cl/"
4708                    "\""))))))))
4709       (synopsis "Call python from Common Lisp")
4710       (description
4711        "Py4CL is a bridge between Common Lisp and Python, which enables Common
4712 Lisp to interact with Python code.  It uses streams to communicate with a
4713 separate python process, the approach taken by cl4py.  This is different to
4714 the CFFI approach used by burgled-batteries, but has the same goal.")
4715       (home-page "https://github.com/bendudson/py4cl")
4716       ;; MIT License
4717       (license license:expat))))
4718
4719 (define-public cl-py4cl
4720   (sbcl-package->cl-source-package sbcl-py4cl))
4721
4722 (define-public ecl-py4cl
4723   (sbcl-package->ecl-package sbcl-py4cl))
4724
4725 (define-public sbcl-parse-declarations
4726   (package
4727     (name "sbcl-parse-declarations")
4728     (version "1.0.0")
4729     (source
4730      (origin
4731        (method url-fetch)
4732        (uri (string-append
4733              "http://beta.quicklisp.org/archive/parse-declarations/"
4734              "2010-10-06/parse-declarations-20101006-darcs.tgz"))
4735        (sha256
4736         (base32
4737          "0r85b0jfacd28kr65kw9c13dx4i6id1dpmby68zjy63mqbnyawrd"))))
4738     (build-system asdf-build-system/sbcl)
4739     (arguments
4740      `(#:asd-file "parse-declarations-1.0.asd"
4741        #:asd-system-name "parse-declarations-1.0"))
4742     (home-page "https://common-lisp.net/project/parse-declarations/")
4743     (synopsis "Parse, filter, and build declarations")
4744     (description
4745      "Parse-Declarations is a Common Lisp library to help writing
4746 macros which establish bindings.  To be semantically correct, such
4747 macros must take user declarations into account, as these may affect
4748 the bindings they establish.  Yet the ANSI standard of Common Lisp does
4749 not provide any operators to work with declarations in a convenient,
4750 high-level way.  This library provides such operators.")
4751     ;; MIT License
4752     (license license:expat)))
4753
4754 (define-public cl-parse-declarations
4755   (sbcl-package->cl-source-package sbcl-parse-declarations))
4756
4757 (define-public ecl-parse-declarations
4758   (sbcl-package->ecl-package sbcl-parse-declarations))
4759
4760 (define-public sbcl-cl-quickcheck
4761   (let ((commit "807b2792a30c883a2fbecea8e7db355b50ba662f")
4762         (revision "1"))
4763     (package
4764       (name "sbcl-cl-quickcheck")
4765       (version (git-version "0.0.4" revision commit))
4766       (source
4767        (origin
4768          (method git-fetch)
4769          (uri (git-reference
4770                (url "https://github.com/mcandre/cl-quickcheck.git")
4771                (commit commit)))
4772          (file-name (git-file-name name version))
4773          (sha256
4774           (base32
4775            "165lhypq5xkcys6hvzb3jq7ywnmqvzaflda29qk2cbs3ggas4767"))))
4776       (build-system asdf-build-system/sbcl)
4777       (synopsis
4778        "Common Lisp port of the QuickCheck unit test framework")
4779       (description
4780        "Common Lisp port of the QuickCheck unit test framework")
4781       (home-page "https://github.com/mcandre/cl-quickcheck")
4782       ;; MIT
4783       (license license:expat))))
4784
4785 (define-public cl-cl-quickcheck
4786   (sbcl-package->cl-source-package sbcl-cl-quickcheck))
4787
4788 (define-public ecl-cl-quickcheck
4789   (sbcl-package->ecl-package sbcl-cl-quickcheck))
4790
4791 (define-public sbcl-burgled-batteries3
4792   (let ((commit "9c0f6667e1a71ddf77e21793a0bea524710fef6e")
4793         (revision "1"))
4794     (package
4795       (name "sbcl-burgled-batteries3")
4796       (version (git-version "0.0.0" revision commit))
4797       (source
4798        (origin
4799          (method git-fetch)
4800          (uri (git-reference
4801                (url "https://github.com/snmsts/burgled-batteries3.git")
4802                (commit commit)))
4803          (file-name (git-file-name name version))
4804          (sha256
4805           (base32
4806            "0b726kz2xxcg5l930gz035rsdvhxrzmp05iwfwympnb4z4ammicb"))))
4807       (build-system asdf-build-system/sbcl)
4808       (arguments
4809        '(#:tests? #f
4810          #:phases
4811          (modify-phases %standard-phases
4812            (add-after 'unpack 'set-*cpython-include-dir*-var
4813              (lambda* (#:key inputs #:allow-other-keys)
4814                (substitute* "grovel-include-dir.lisp"
4815                  (("\\(defparameter \\*cpython-include-dir\\* \\(detect-python\\)\\)")
4816                   (string-append
4817                    "(defparameter *cpython-include-dir* \""
4818                    (assoc-ref inputs "python")
4819                    "/include/python3.7m"
4820                    "\")")))
4821                (substitute* "ffi-interface.lisp"
4822                  (("\\*cpython-lib\\*")
4823                   (format #f "'(\"~a/lib/libpython3.so\")"
4824                           (assoc-ref inputs "python"))))
4825                #t)))))
4826       (native-inputs
4827        `(("python" ,python)
4828          ("sbcl-cl-fad" ,sbcl-cl-fad)
4829          ("sbcl-lift" ,sbcl-lift)
4830          ("sbcl-cl-quickcheck" ,sbcl-cl-quickcheck)))
4831       (inputs
4832        `(("sbcl-cffi" ,sbcl-cffi)
4833          ("sbcl-cffi-grovel" ,sbcl-cffi-grovel)
4834          ("sbcl-alexandria" , sbcl-alexandria)
4835          ("sbcl-parse-declarations-1.0" ,sbcl-parse-declarations)
4836          ("sbcl-trivial-garbage" ,sbcl-trivial-garbage)))
4837       (synopsis "Bridge between Python and Lisp (FFI bindings, etc.)")
4838       (description
4839        "This package provides a shim between Python3 (specifically, the
4840 CPython implementation of Python) and Common Lisp.")
4841       (home-page "https://github.com/snmsts/burgled-batteries3")
4842       ;; MIT
4843       (license license:expat))))
4844
4845 (define-public cl-burgled-batteries3
4846   (sbcl-package->cl-source-package sbcl-burgled-batteries3))
4847
4848 (define-public ecl-burgled-batteries3
4849   (sbcl-package->ecl-package sbcl-burgled-batteries3))
4850
4851 (define-public sbcl-metabang-bind
4852   (let ((commit "c93b7f7e1c18c954c2283efd6a7fdab36746ab5e")
4853         (revision "1"))
4854     (package
4855       (name "sbcl-metabang-bind")
4856       (version (git-version "0.8.0" revision commit))
4857       (source
4858        (origin
4859          (method git-fetch)
4860          (uri (git-reference
4861                (url "https://github.com/gwkkwg/metabang-bind.git")
4862                (commit commit)))
4863          (file-name (git-file-name name version))
4864          (sha256
4865           (base32
4866            "0hd0kr91795v77akpbcyqiss9p0p7ypa9dznrllincnmgvsxlmf0"))))
4867       (build-system asdf-build-system/sbcl)
4868       (native-inputs
4869        `(("sbcl-lift" ,sbcl-lift)))
4870       (synopsis "Macro that generalizes @code{multiple-value-bind} etc.")
4871       (description
4872        "Bind extends the idea of of let and destructing to provide a uniform
4873 syntax for all your accessor needs.  It combines @code{let},
4874 @code{destructuring-bind}, @code{with-slots}, @code{with-accessors}, structure
4875 editing, property or association-lists, and @code{multiple-value-bind} and a
4876 whole lot more into a single form.")
4877       (home-page "https://common-lisp.net/project/metabang-bind/")
4878       ;; MIT License
4879       (license license:expat))))
4880
4881 (define-public cl-metabang-bind
4882   (sbcl-package->cl-source-package sbcl-metabang-bind))
4883
4884 (define-public ecl-metabang-bind
4885   (sbcl-package->ecl-package sbcl-metabang-bind))
4886
4887 (define-public sbcl-fare-utils
4888   (let ((commit "66e9c6f1499140bc00ccc22febf2aa528cbb5724")
4889         (revision "1"))
4890     (package
4891       (name "sbcl-fare-utils")
4892       (version (git-version "1.0.0.5" revision commit))
4893       (source
4894        (origin
4895          (method git-fetch)
4896          (uri
4897           (git-reference
4898            (url
4899             "https://gitlab.common-lisp.net/frideau/fare-utils.git")
4900            (commit commit)))
4901          (file-name (git-file-name name version))
4902          (sha256
4903           (base32
4904            "01wsr1aap3jdzhn4hrqjbhsjx6qci9dbd3gh4gayv1p49rbg8aqr"))))
4905       (build-system asdf-build-system/sbcl)
4906       (arguments
4907        `(#:test-asd-file "test/fare-utils-test.asd"))
4908       (native-inputs
4909        `(("sbcl-hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
4910       (synopsis "Collection of utilities and data structures")
4911       (description
4912        "fare-utils is a small collection of utilities.  It contains a lot of
4913 basic everyday functions and macros.")
4914       (home-page "https://gitlab.common-lisp.net/frideau/fare-utils")
4915       ;; MIT License
4916       (license license:expat))))
4917
4918 (define-public cl-fare-utils
4919   (sbcl-package->cl-source-package sbcl-fare-utils))
4920
4921 (define-public ecl-fare-utils
4922   (sbcl-package->ecl-package sbcl-fare-utils))
4923
4924 (define-public sbcl-trivial-utf-8
4925   (let ((commit "4d427cfbb1c452436a0efb71c3205c9da67f718f")
4926         (revision "1"))
4927     (package
4928       (name "sbcl-trivial-utf-8")
4929       (version (git-version "0.0.0" revision commit))
4930       (source
4931        (origin
4932          (method git-fetch)
4933          (uri
4934           (git-reference
4935            (url (string-append "https://gitlab.common-lisp.net/"
4936                                "trivial-utf-8/trivial-utf-8.git"))
4937            (commit commit)))
4938          (file-name (git-file-name name version))
4939          (sha256
4940           (base32
4941            "1jz27gz8gvqdmvp3k9bxschs6d5b3qgk94qp2bj6nv1d0jc3m1l1"))))
4942       (arguments
4943        ;; Guix incorrectly assumes the "8" is part of the version
4944        ;; number and lobs it off.
4945        `(#:asd-file "trivial-utf-8.asd"
4946          #:asd-system-name "trivial-utf-8"))
4947       (build-system asdf-build-system/sbcl)
4948       (synopsis "UTF-8 input/output library")
4949       (description
4950        "The Babel library solves a similar problem while understanding more
4951 encodings.  Trivial UTF-8 was written before Babel existed, but for new
4952 projects you might be better off going with Babel.  The one plus that Trivial
4953 UTF-8 has is that it doesn't depend on any other libraries.")
4954       (home-page "https://common-lisp.net/project/trivial-utf-8/")
4955       (license license:bsd-3))))
4956
4957 (define-public cl-trivial-utf-8
4958   (sbcl-package->cl-source-package sbcl-trivial-utf-8))
4959
4960 (define-public ecl-trivial-utf-8
4961   (sbcl-package->ecl-package sbcl-trivial-utf-8))
4962
4963 (define-public sbcl-idna
4964   (package
4965     (name "sbcl-idna")
4966     (build-system asdf-build-system/sbcl)
4967     (version "0.2.2")
4968     (home-page "https://github.com/antifuchs/idna")
4969     (source
4970      (origin
4971        (method git-fetch)
4972        (uri (git-reference
4973              (url home-page)
4974              (commit version)))
4975        (file-name (git-file-name name version))
4976        (sha256
4977         (base32
4978          "00nbr3mffxhlq14gg9d16pa6691s4qh35inyw76v906s77khm5a2"))))
4979     (inputs
4980      `(("split-sequence" ,sbcl-split-sequence)))
4981     (synopsis "IDNA string encoding and decoding routines for Common Lisp")
4982     (description "This Common Lisp library provides string encoding and
4983 decoding routines for IDNA, the International Domain Names in Applications.")
4984     (license license:expat)))
4985
4986 (define-public cl-idna
4987   (sbcl-package->cl-source-package sbcl-idna))
4988
4989 (define-public ecl-idna
4990   (sbcl-package->ecl-package sbcl-idna))
4991
4992 (define-public sbcl-swap-bytes
4993   (package
4994     (name "sbcl-swap-bytes")
4995     (build-system asdf-build-system/sbcl)
4996     (version "1.1")
4997     (home-page "https://github.com/sionescu/swap-bytes")
4998     (source
4999      (origin
5000        (method git-fetch)
5001        (uri (git-reference
5002              (url home-page)
5003              (commit (string-append "v" version))))
5004        (file-name (git-file-name name version))
5005        (sha256
5006         (base32
5007          "1qysbv0jngdfkv53y874qjhcxc4qi8ixaqq6j8bzxh5z0931wv55"))))
5008     (inputs
5009      `(("trivial-features" ,sbcl-trivial-features)))
5010     (native-inputs
5011      `(("fiveam" ,sbcl-fiveam)))
5012     (arguments
5013      ;; TODO: Tests fail, why?
5014      `(#:tests? #f))
5015     (synopsis "Efficient endianness conversion for Common Lisp")
5016     (description "This Common Lisp library provides optimized byte-swapping
5017 primitives.  The library can change endianness of unsigned integers of length
5018 1/2/4/8.  Very useful in implementing various network protocols and file
5019 formats.")
5020     (license license:expat)))
5021
5022 (define-public cl-swap-bytes
5023   (sbcl-package->cl-source-package sbcl-swap-bytes))
5024
5025 (define-public ecl-swap-bytes
5026   (sbcl-package->ecl-package sbcl-swap-bytes))
5027
5028 (define-public sbcl-iolib.asdf
5029   ;; Latest release is from June 2017.
5030   (let ((commit "81e20614c0d27f9605bf9766214e236fd31b99b4")
5031         (revision "1"))
5032     (package
5033       (name "sbcl-iolib.asdf")
5034       (build-system asdf-build-system/sbcl)
5035       (version "0.8.3")
5036       (home-page "https://github.com/sionescu/iolib")
5037       (source
5038        (origin
5039          (method git-fetch)
5040          (uri (git-reference
5041                (url home-page)
5042                (commit commit)))
5043          (file-name (git-file-name name version))
5044          (sha256
5045           (base32
5046            "1j81r0wm7nfbwl991f26s4npcy7kybzybd3m47rbxy31h0cfcmdm"))))
5047       (inputs
5048        `(("alexandria" ,sbcl-alexandria)))
5049       (arguments
5050        '(#:asd-file "iolib.asdf.asd"))
5051       (synopsis "ASDF component classes for IOLib, a Common Lisp I/O library")
5052       (description "IOlib is to be a better and more modern I/O library than
5053 the standard Common Lisp library.  It contains a socket library, a DNS
5054 resolver, an I/O multiplexer(which supports @code{select(2)}, @code{epoll(4)}
5055 and @code{kqueue(2)}), a pathname library and file-system utilities.")
5056       (license license:expat))))
5057
5058 (define-public sbcl-iolib.conf
5059   (package
5060     (inherit sbcl-iolib.asdf)
5061     (name "sbcl-iolib.conf")
5062     (inputs
5063      `(("iolib.asdf" ,sbcl-iolib.asdf)))
5064     (arguments
5065      '(#:asd-file "iolib.conf.asd"))
5066     (synopsis "Compile-time configuration for IOLib, a Common Lisp I/O library")))
5067
5068 (define-public sbcl-iolib.common-lisp
5069   (package
5070     (inherit sbcl-iolib.asdf)
5071     (name "sbcl-iolib.common-lisp")
5072     (inputs
5073      `(("iolib.asdf" ,sbcl-iolib.asdf)
5074        ("iolib.conf" ,sbcl-iolib.conf)))
5075     (arguments
5076      '(#:asd-file "iolib.common-lisp.asd"))
5077     (synopsis "Slightly modified Common Lisp for IOLib, a Common Lisp I/O library")))
5078
5079 (define-public sbcl-iolib.base
5080   (package
5081     (inherit sbcl-iolib.asdf)
5082     (name "sbcl-iolib.base")
5083     (inputs
5084      `(("iolib.asdf" ,sbcl-iolib.asdf)
5085        ("iolib.conf" ,sbcl-iolib.conf)
5086        ("iolib.common-lisp" ,sbcl-iolib.common-lisp)
5087        ("split-sequence" ,sbcl-split-sequence)))
5088     (arguments
5089      '(#:asd-file "iolib.base.asd"))
5090     (synopsis "Base package for IOLib, a Common Lisp I/O library")))
5091
5092 (define-public sbcl-iolib.grovel
5093   (package
5094     (inherit sbcl-iolib.asdf)
5095     (name "sbcl-iolib.grovel")
5096     (inputs
5097      `(("iolib.asdf" ,sbcl-iolib.asdf)
5098        ("iolib.conf" ,sbcl-iolib.conf)
5099        ("iolib.base", sbcl-iolib.base)
5100        ("cffi", sbcl-cffi)))
5101     (arguments
5102      '(#:asd-file "iolib.grovel.asd"
5103        #:phases
5104        (modify-phases %standard-phases
5105          (add-after 'install 'install-header
5106            (lambda* (#:key outputs #:allow-other-keys)
5107              ;; This header is required by sbcl-iolib.
5108              (install-file "src/grovel/grovel-common.h"
5109                            (string-append (assoc-ref outputs "out")
5110                                           "/lib/sbcl"))
5111              #t)))))
5112     (synopsis "CFFI Groveller for IOLib, a Common Lisp I/O library")))
5113
5114 (define-public sbcl-iolib
5115   (package
5116     (inherit sbcl-iolib.asdf)
5117     (name "sbcl-iolib")
5118     (inputs
5119      `(("iolib.asdf" ,sbcl-iolib.asdf)
5120        ("iolib.conf" ,sbcl-iolib.conf)
5121        ("iolib.grovel" ,sbcl-iolib.grovel)
5122        ("iolib.base" ,sbcl-iolib.base)
5123        ("bordeaux-threads" ,sbcl-bordeaux-threads)
5124        ("idna" ,sbcl-idna)
5125        ("swap-bytes" ,sbcl-swap-bytes)
5126        ("libfixposix" ,libfixposix)
5127        ("cffi" ,sbcl-cffi)))
5128     (native-inputs
5129      `(("fiveam" ,sbcl-fiveam)))
5130     (arguments
5131      '(#:asd-file "iolib.asd"
5132        #:asd-system-name "iolib"
5133        #:test-asd-file "iolib.tests.asd"
5134        #:phases
5135        (modify-phases %standard-phases
5136          (add-after 'unpack 'fix-paths
5137            (lambda* (#:key inputs #:allow-other-keys)
5138              (substitute* "src/syscalls/ffi-functions-unix.lisp"
5139                (("\\(:default \"libfixposix\"\\)")
5140                 (string-append
5141                  "(:default \""
5142                  (assoc-ref inputs "libfixposix") "/lib/libfixposix\")")))
5143              ;; Socket tests need Internet access, disable them.
5144              (substitute* "iolib.tests.asd"
5145                (("\\(:file \"sockets\" :depends-on \\(\"pkgdcl\" \"defsuites\"\\)\\)")
5146                 "")))))))
5147     (synopsis "Common Lisp I/O library")))
5148
5149 (define-public cl-iolib
5150   (sbcl-package->cl-source-package sbcl-iolib))
5151
5152 (define sbcl-iolib+multiplex
5153   (package
5154     (inherit sbcl-iolib)
5155     (name "sbcl-iolib+multiplex")
5156     (arguments
5157      (substitute-keyword-arguments (package-arguments sbcl-iolib)
5158        ((#:asd-system-name _) "iolib/multiplex")))))
5159
5160 (define sbcl-iolib+syscalls
5161   (package
5162     (inherit sbcl-iolib)
5163     (name "sbcl-iolib+syscalls")
5164     (arguments
5165      (substitute-keyword-arguments (package-arguments sbcl-iolib)
5166        ((#:asd-system-name _) "iolib/syscalls")))))
5167
5168 (define sbcl-iolib+streams
5169   (package
5170     (inherit sbcl-iolib)
5171     (name "sbcl-iolib+streams")
5172     (arguments
5173      (substitute-keyword-arguments (package-arguments sbcl-iolib)
5174        ((#:asd-system-name _) "iolib/streams")))))
5175
5176 (define sbcl-iolib+sockets
5177   (package
5178     (inherit sbcl-iolib)
5179     (name "sbcl-iolib+sockets")
5180     (arguments
5181      (substitute-keyword-arguments (package-arguments sbcl-iolib)
5182        ((#:asd-system-name _) "iolib/sockets")))))
5183
5184 (define-public sbcl-ieee-floats
5185   (let ((commit "566b51a005e81ff618554b9b2f0b795d3b29398d")
5186         (revision "1"))
5187     (package
5188       (name "sbcl-ieee-floats")
5189       (build-system asdf-build-system/sbcl)
5190       (version (git-version "20170924" revision commit))
5191       (home-page "https://github.com/marijnh/ieee-floats/")
5192       (source
5193        (origin
5194          (method git-fetch)
5195          (uri (git-reference
5196                (url home-page)
5197                (commit commit)))
5198          (file-name (git-file-name name version))
5199          (sha256
5200           (base32
5201            "1xyj49j9x3lc84cv3dhbf9ja34ywjk1c46dklx425fxw9mkwm83m"))))
5202       (native-inputs
5203        `(("fiveam" ,sbcl-fiveam)))
5204       (synopsis "IEEE 754 binary representation for floats in Common Lisp")
5205       (description "This is a Common Lisp library that allows to convert
5206 floating point values to IEEE 754 binary representation.")
5207       (license license:bsd-3))))
5208
5209 (define-public cl-ieee-floats
5210   (sbcl-package->cl-source-package sbcl-ieee-floats))
5211
5212 (define sbcl-closure-common
5213   (let ((commit "e3c5f5f454b72b01b89115e581c3c52a7e201e5c")
5214         (revision "1"))
5215     (package
5216       (name "sbcl-closure-common")
5217       (build-system asdf-build-system/sbcl)
5218       (version (git-version "20101006" revision commit))
5219       (home-page "https://common-lisp.net/project/cxml/")
5220       (source
5221        (origin
5222          (method git-fetch)
5223          (uri (git-reference
5224                (url "https://github.com/sharplispers/closure-common")
5225                (commit commit)))
5226          (file-name (git-file-name name version))
5227          (sha256
5228           (base32
5229            "0k5r2qxn122pxi301ijir3nayi9sg4d7yiy276l36qmzwhp4mg5n"))))
5230       (inputs
5231        `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)
5232          ("babel" ,sbcl-babel)))
5233       (synopsis "Support Common Lisp library for CXML")
5234       (description "Closure-common is an internal helper library.  The name
5235 Closure is a reference to the web browser it was originally written for.")
5236       ;; TODO: License?
5237       (license #f))))
5238
5239 (define-public sbcl-cxml+xml
5240   (let ((commit "00b22bf4c4cf11c993d5866fae284f95ab18e6bf")
5241         (revision "1"))
5242     (package
5243       (name "sbcl-cxml+xml")
5244       (build-system asdf-build-system/sbcl)
5245       (version (git-version "0.0.0" revision commit))
5246       (home-page "https://common-lisp.net/project/cxml/")
5247       (source
5248        (origin
5249          (method git-fetch)
5250          (uri (git-reference
5251                (url "https://github.com/sharplispers/cxml")
5252                (commit commit)))
5253          (file-name (git-file-name name version))
5254          (sha256
5255           (base32
5256            "13kif7rf3gqdycsk9zq0d7y0g9y81krkl0z87k0p2fkbjfgrph37"))))
5257       (inputs
5258        `(("closure-common" ,sbcl-closure-common)
5259          ("puri" ,sbcl-puri)
5260          ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
5261       (arguments
5262        `(#:asd-file "cxml.asd"
5263          #:asd-system-name "cxml/xml"))
5264       (synopsis "Common Lisp XML parser")
5265       (description "CXML implements a namespace-aware, validating XML 1.0
5266 parser as well as the DOM Level 2 Core interfaces.  Two parser interfaces are
5267 offered, one SAX-like, the other similar to StAX.")
5268       (license license:llgpl))))
5269
5270 (define sbcl-cxml+dom
5271   (package
5272     (inherit sbcl-cxml+xml)
5273     (name "sbcl-cxml+dom")
5274     (inputs
5275      `(("closure-common" ,sbcl-closure-common)
5276        ("puri" ,sbcl-puri)
5277        ("cxml+xml" ,sbcl-cxml+xml)))
5278     (arguments
5279      `(#:asd-file "cxml.asd"
5280        #:asd-system-name "cxml/dom"))))
5281
5282 (define sbcl-cxml+klacks
5283   (package
5284     (inherit sbcl-cxml+xml)
5285     (name "sbcl-cxml+klacks")
5286     (inputs
5287      `(("closure-common" ,sbcl-closure-common)
5288        ("puri" ,sbcl-puri)
5289        ("cxml+xml" ,sbcl-cxml+xml)))
5290     (arguments
5291      `(#:asd-file "cxml.asd"
5292        #:asd-system-name "cxml/klacks"))))
5293
5294 (define sbcl-cxml+test
5295   (package
5296     (inherit sbcl-cxml+xml)
5297     (name "sbcl-cxml+test")
5298     (inputs
5299      `(("closure-common" ,sbcl-closure-common)
5300        ("puri" ,sbcl-puri)
5301        ("cxml+xml" ,sbcl-cxml+xml)))
5302     (arguments
5303      `(#:asd-file "cxml.asd"
5304        #:asd-system-name "cxml/test"))))
5305
5306 (define-public sbcl-cxml
5307   (package
5308     (inherit sbcl-cxml+xml)
5309     (name "sbcl-cxml")
5310     (inputs
5311      `(("closure-common" ,sbcl-closure-common)
5312        ("puri" ,sbcl-puri)
5313        ("trivial-gray-streams" ,sbcl-trivial-gray-streams)
5314        ("cxml+dom" ,sbcl-cxml+dom)
5315        ("cxml+klacks" ,sbcl-cxml+klacks)
5316        ("cxml+test" ,sbcl-cxml+test)))
5317     (arguments
5318      `(#:asd-file "cxml.asd"
5319        #:asd-system-name "cxml"
5320        #:phases
5321        (modify-phases %standard-phases
5322          (add-after 'build 'install-dtd
5323            (lambda* (#:key outputs #:allow-other-keys)
5324              (install-file "catalog.dtd"
5325                            (string-append
5326                             (assoc-ref outputs "out")
5327                             "/lib/" (%lisp-type)))))
5328          (add-after 'create-asd 'remove-component
5329            ;; XXX: The original .asd has no components, but our build system
5330            ;; creates an entry nonetheless.  We need to remove it for the
5331            ;; generated .asd to load properly.  See trivia.trivial for a
5332            ;; similar problem.
5333            (lambda* (#:key outputs #:allow-other-keys)
5334              (let* ((out (assoc-ref outputs "out"))
5335                     (asd (string-append out "/lib/sbcl/cxml.asd")))
5336                (substitute* asd
5337                  (("  :components
5338 ")
5339                   ""))
5340                (substitute* asd
5341                  ((" *\\(\\(:compiled-file \"cxml--system\"\\)\\)")
5342                   ""))))))))))
5343
5344 (define-public cl-cxml
5345   (sbcl-package->cl-source-package sbcl-cxml))
5346
5347 (define-public sbcl-cl-reexport
5348   (let ((commit "312f3661bbe187b5f28536cd7ec2956e91366c3b")
5349         (revision "1"))
5350     (package
5351       (name "sbcl-cl-reexport")
5352       (build-system asdf-build-system/sbcl)
5353       (version (git-version "0.1" revision commit))
5354       (home-page "https://github.com/takagi/cl-reexport")
5355       (source
5356        (origin
5357          (method git-fetch)
5358          (uri (git-reference
5359                (url home-page)
5360                (commit commit)))
5361          (file-name (git-file-name name version))
5362          (sha256
5363           (base32
5364            "1cwpn1m3wrl0fl9plznn7p464db646gnfc8zkyk97dyxski2aq0x"))))
5365       (inputs
5366        `(("alexandria" ,sbcl-alexandria)))
5367       (arguments
5368        ;; TODO: Tests fail because cl-test-more is missing, but I can't find it online.
5369        `(#:tests? #f))
5370       (synopsis "HTTP cookie manager for Common Lisp")
5371       (description "cl-cookie is a Common Lisp library featuring parsing of
5372 cookie headers, cookie creation, cookie jar creation and more.")
5373       (license license:llgpl))))
5374
5375 (define-public cl-reexport
5376   (sbcl-package->cl-source-package sbcl-cl-reexport))
5377
5378 (define-public sbcl-cl-cookie
5379   (let ((commit "cea55aed8b9ad25fafd13defbcb9fe8f41b29546")
5380         (revision "1"))
5381     (package
5382       (name "sbcl-cl-cookie")
5383       (build-system asdf-build-system/sbcl)
5384       (version (git-version "0.9.10" revision commit))
5385       (home-page "https://github.com/fukamachi/cl-cookie")
5386       (source
5387        (origin
5388          (method git-fetch)
5389          (uri (git-reference
5390                (url home-page)
5391                (commit commit)))
5392          (file-name (git-file-name name version))
5393          (sha256
5394           (base32
5395            "090g7z75h98zvc1ldx0vh4jn4086dhjm2w30jcwkq553qmyxwl8h"))))
5396       (inputs
5397        `(("proc-parse" ,sbcl-proc-parse)
5398          ("alexandria" ,sbcl-alexandria)
5399          ("quri" ,sbcl-quri)
5400          ("cl-ppcre" ,sbcl-cl-ppcre)
5401          ("local-time" ,sbcl-local-time)))
5402       (native-inputs
5403        `(("prove-asdf" ,sbcl-prove-asdf)
5404          ("prove" ,sbcl-prove)))
5405       (arguments
5406        ;; TODO: Tests fail because cl-cookie depends on cl-cookie-test.
5407        `(#:tests? #f))
5408       (synopsis "HTTP cookie manager for Common Lisp")
5409       (description "cl-cookie is a Common Lisp library featuring parsing of
5410 cookie headers, cookie creation, cookie jar creation and more.")
5411       (license license:bsd-2))))
5412
5413 (define-public cl-cookie
5414   (sbcl-package->cl-source-package sbcl-cl-cookie))
5415
5416 (define-public sbcl-dexador
5417   (let ((commit "a2714d126cc94bc7a9a6e1e3c08de455b3a66378")
5418         (revision "1"))
5419     (package
5420       (name "sbcl-dexador")
5421       (build-system asdf-build-system/sbcl)
5422       (version (git-version "0.9.10" revision commit))
5423       (home-page "https://github.com/fukamachi/dexador")
5424       (source
5425        (origin
5426          (method git-fetch)
5427          (uri (git-reference
5428                (url home-page)
5429                (commit commit)))
5430          (file-name (git-file-name name version))
5431          (sha256
5432           (base32
5433            "0nbqgn4v3l2z6m1k1bdxfnqpfrk84nxdmz7csz11zzcfs4flkv79"))))
5434       (inputs
5435        `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)
5436          ("babel" ,sbcl-babel)
5437          ("usocket" ,sbcl-usocket)
5438          ("fast-http" ,sbcl-fast-http)
5439          ("quri" ,sbcl-quri)
5440          ("fast-io" ,sbcl-fast-io)
5441          ("chunga" ,sbcl-chunga)
5442          ("cl-ppcre" ,sbcl-cl-ppcre)
5443          ("cl-cookie" ,sbcl-cl-cookie)
5444          ("trivial-mimes" ,sbcl-trivial-mimes)
5445          ("chipz" ,sbcl-chipz)
5446          ("cl-base64" ,sbcl-cl-base64)
5447          ("cl-reexport" ,sbcl-cl-reexport)
5448          ("cl+ssl" ,sbcl-cl+ssl)
5449          ("bordeaux-threads" ,sbcl-bordeaux-threads)
5450          ("alexandria" ,sbcl-alexandria)))
5451       (native-inputs
5452        `(("prove" ,sbcl-prove)
5453          ("prove-asdf" ,sbcl-prove-asdf)
5454          ("lack-request" ,sbcl-lack-request)
5455          ("clack" ,sbcl-clack)
5456          ("babel" ,sbcl-babel)
5457          ("alexandria" ,sbcl-alexandria)
5458          ("cl-ppcre" ,sbcl-cl-ppcre)
5459          ("local-time" ,sbcl-local-time)))
5460       (arguments
5461        ;; TODO: Circular dependency: tests depend on clack-test which depends on dexador.
5462        `(#:tests? #f
5463          #:phases
5464          (modify-phases %standard-phases
5465            (add-after 'unpack 'fix-permissions
5466              (lambda _ (make-file-writable "t/data/test.gz") #t)))))
5467       (synopsis "Yet another HTTP client for Common Lisp")
5468       (description "Dexador is yet another HTTP client for Common Lisp with
5469 neat APIs and connection-pooling.  It is meant to supersede Drakma.")
5470       (license license:expat))))
5471
5472 (define-public cl-dexador
5473   (package
5474     (inherit (sbcl-package->cl-source-package sbcl-dexador))
5475     (arguments
5476      `(#:phases
5477        ;; asdf-build-system/source has its own phases and does not inherit
5478        ;; from asdf-build-system/sbcl phases.
5479        (modify-phases %standard-phases/source
5480          (add-after 'unpack 'fix-permissions
5481            (lambda _ (make-file-writable "t/data/test.gz") #t)))))))
5482
5483 (define-public ecl-dexador
5484   (sbcl-package->ecl-package sbcl-dexador))
5485
5486 (define-public sbcl-lisp-namespace
5487   (let ((commit "28107cafe34e4c1c67490fde60c7f92dc610b2e0")
5488         (revision "1"))
5489     (package
5490       (name "sbcl-lisp-namespace")
5491       (build-system asdf-build-system/sbcl)
5492       (version (git-version "0.1" revision commit))
5493       (home-page "https://github.com/guicho271828/lisp-namespace")
5494       (source
5495        (origin
5496          (method git-fetch)
5497          (uri (git-reference
5498                (url home-page)
5499                (commit commit)))
5500          (file-name (git-file-name name version))
5501          (sha256
5502           (base32
5503            "1jw2wykp06z2afb9nm1lgfzll5cjlj36pnknjx614057zkkxq4iy"))))
5504       (inputs
5505        `(("alexandria" ,sbcl-alexandria)))
5506       (native-inputs
5507        `(("fiveam" ,sbcl-fiveam)))
5508       (arguments
5509        `(#:test-asd-file "lisp-namespace.test.asd"
5510         ;; XXX: Component LISP-NAMESPACE-ASD::LISP-NAMESPACE.TEST not found
5511          #:tests? #f))
5512       (synopsis "LISP-N, or extensible namespaces in Common Lisp")
5513       (description "Common Lisp already has major 2 namespaces, function
5514 namespace and value namespace (or variable namespace), but there are actually
5515 more — e.g., class namespace.
5516 This library offers macros to deal with symbols from any namespace.")
5517       (license license:llgpl))))
5518
5519 (define-public cl-lisp-namespace
5520   (sbcl-package->cl-source-package sbcl-lisp-namespace))
5521
5522 (define-public sbcl-trivial-cltl2
5523   (let ((commit "8eec8407df833e8f27df8a388bc10913f16d9e83")
5524         (revision "1"))
5525     (package
5526       (name "sbcl-trivial-cltl2")
5527       (build-system asdf-build-system/sbcl)
5528       (version (git-version "0.1.1" revision commit))
5529       (home-page "https://github.com/Zulu-Inuoe/trivial-cltl2")
5530       (source
5531        (origin
5532          (method git-fetch)
5533          (uri (git-reference
5534                (url home-page)
5535                (commit commit)))
5536          (file-name (git-file-name name version))
5537          (sha256
5538           (base32
5539            "1dyyxz17vqv8hlfwq287gl8xxbvcnq798ajb7p5jdjz91wqf4bgk"))))
5540       (synopsis "Simple CLtL2 compatibility layer for Common Lisp")
5541       (description "This library is a portable compatibility layer around
5542 \"Common Lisp the Language, 2nd
5543 Edition\" (@url{https://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node102.html})
5544 and it exports symbols from implementation-specific packages.")
5545       (license license:llgpl))))
5546
5547 (define-public cl-trivial-cltl2
5548   (sbcl-package->cl-source-package sbcl-trivial-cltl2))
5549
5550 (define-public sbcl-introspect-environment
5551   (let ((commit "fff42f8f8fd0d99db5ad6c5812e53de7d660020b")
5552         (revision "1"))
5553     (package
5554       (name "sbcl-introspect-environment")
5555       (build-system asdf-build-system/sbcl)
5556       (version (git-version "0.1" revision commit))
5557       (home-page "https://github.com/Bike/introspect-environment")
5558       (source
5559        (origin
5560          (method git-fetch)
5561          (uri (git-reference
5562                (url home-page)
5563                (commit commit)))
5564          (file-name (git-file-name name version))
5565          (sha256
5566           (base32
5567            "1i305n0wfmpac63ni4i3vixnnkl8daw5ncxy0k3dv92krgx6qzhp"))))
5568       (native-inputs
5569        `(("fiveam" ,sbcl-fiveam)))
5570       (synopsis "Common Lisp environment introspection portability layer")
5571       (description "This library is a small interface to portable but
5572 nonstandard introspection of Common Lisp environments.  It is intended to
5573 allow a bit more compile-time introspection of environments in Common Lisp.
5574
5575 Quite a bit of information is available at the time a macro or compiler-macro
5576 runs; inlining info, type declarations, that sort of thing.  This information
5577 is all standard - any Common Lisp program can @code{(declare (integer x))} and
5578 such.
5579
5580 This info ought to be accessible through the standard @code{&environment}
5581 parameters, but it is not.  Several implementations keep the information for
5582 their own purposes but do not make it available to user programs, because
5583 there is no standard mechanism to do so.
5584
5585 This library uses implementation-specific hooks to make information available
5586 to users.  This is currently supported on SBCL, CCL, and CMUCL.  Other
5587 implementations have implementations of the functions that do as much as they
5588 can and/or provide reasonable defaults.")
5589       (license license:wtfpl2))))
5590
5591 (define-public cl-introspect-environment
5592   (sbcl-package->cl-source-package sbcl-introspect-environment))
5593
5594 (define-public sbcl-type-i
5595   (let ((commit "dea233f45f94064105ec09f0767de338f67dcbe2")
5596         (revision "1"))
5597     (package
5598       (name "sbcl-type-i")
5599       (build-system asdf-build-system/sbcl)
5600       (version (git-version "0.1" revision commit))
5601       (home-page "https://github.com/guicho271828/type-i")
5602       (source
5603        (origin
5604          (method git-fetch)
5605          (uri (git-reference
5606                (url home-page)
5607                (commit commit)))
5608          (file-name (git-file-name name version))
5609          (sha256
5610           (base32
5611            "039g5pbrhh65s0bhr9314gmd2nwc2y5lp2377c5qrc2lxky89qs3"))))
5612       (inputs
5613        `(("alexandria" ,sbcl-alexandria)
5614          ("introspect-environment" ,sbcl-introspect-environment)
5615          ("trivia.trivial" ,sbcl-trivia.trivial)))
5616       (native-inputs
5617        `(("fiveam" ,sbcl-fiveam)))
5618       (arguments
5619        `(#:test-asd-file "type-i.test.asd"))
5620       (synopsis "Type inference utility on unary predicates for Common Lisp")
5621       (description "This library tries to provide a way to detect what kind of
5622 type the given predicate is trying to check.  This is different from inferring
5623 the return type of a function.")
5624       (license license:llgpl))))
5625
5626 (define-public cl-type-i
5627   (sbcl-package->cl-source-package sbcl-type-i))
5628
5629 (define-public sbcl-optima
5630   (let ((commit "373b245b928c1a5cce91a6cb5bfe5dd77eb36195")
5631         (revision "1"))
5632     (package
5633       (name "sbcl-optima")
5634       (build-system asdf-build-system/sbcl)
5635       (version (git-version "1.0" revision commit))
5636       (home-page "https://github.com/m2ym/optima")
5637       (source
5638        (origin
5639          (method git-fetch)
5640          (uri (git-reference
5641                (url home-page)
5642                (commit commit)))
5643          (file-name (git-file-name name version))
5644          (sha256
5645           (base32
5646            "1yw4ymq7ms89342kkvb3aqxgv0w38m9kd8ikdqxxzyybnkjhndal"))))
5647       (inputs
5648        `(("alexandria" ,sbcl-alexandria)
5649          ("closer-mop" ,sbcl-closer-mop)))
5650       (native-inputs
5651        `(("eos" ,sbcl-eos)))
5652       (arguments
5653        ;; XXX: Circular dependencies: tests depend on optima.ppcre which depends on optima.
5654        `(#:tests? #f
5655          #:test-asd-file "optima.test.asd"))
5656       (synopsis "Optimized pattern matching library for Common Lisp")
5657       (description "Optima is a fast pattern matching library which uses
5658 optimizing techniques widely used in the functional programming world.")
5659       (license license:expat))))
5660
5661 (define-public cl-optima
5662   (sbcl-package->cl-source-package sbcl-optima))
5663
5664 (define-public sbcl-fare-quasiquote
5665   (package
5666     (name "sbcl-fare-quasiquote")
5667     (build-system asdf-build-system/sbcl)
5668     (version "20171130")
5669     (home-page "http://common-lisp.net/project/fare-quasiquote")
5670     (source
5671      (origin
5672        (method url-fetch)
5673        (uri (string-append "http://beta.quicklisp.org/archive/fare-quasiquote/"
5674                            (date->string (string->date version "~Y~m~d") "~Y-~m-~d")
5675                            "/fare-quasiquote-"
5676                            version
5677                            "-git.tgz"))
5678        (sha256
5679         (base32
5680          "00brmh7ndsi0c97nibi8cy10j3l4gmkyrfrr5jr5lzkfb7ngyfqa"))))
5681     (inputs
5682      `(("fare-utils" ,sbcl-fare-utils)))
5683     (arguments
5684      ;; XXX: Circular dependencies: Tests depend on subsystems, which depend on the main systems.
5685      `(#:tests? #f
5686        #:phases
5687        (modify-phases %standard-phases
5688          ;; XXX: Require 1.0.0 version of fare-utils, and we package some
5689          ;; commits after 1.0.0.5, but ASDF fails to read the
5690          ;; "-REVISION-COMMIT" part generated by Guix.
5691          (add-after 'unpack 'patch-requirement
5692            (lambda _
5693              (substitute* "fare-quasiquote.asd"
5694                (("\\(:version \"fare-utils\" \"1.0.0\"\\)") "\"fare-utils\"")))))))
5695     (synopsis "Pattern-matching friendly implementation of quasiquote for Common Lisp")
5696     (description "The main purpose of this n+2nd reimplementation of
5697 quasiquote is enable matching of quasiquoted patterns, using Optima or
5698 Trivia.")
5699     (license license:expat)))
5700
5701 (define-public cl-fare-quasiquote
5702   (sbcl-package->cl-source-package sbcl-fare-quasiquote))
5703
5704 (define-public sbcl-fare-quasiquote-optima
5705   (package
5706     (inherit sbcl-fare-quasiquote)
5707     (name "sbcl-fare-quasiquote-optima")
5708     (inputs
5709      `(("optima" ,sbcl-optima)
5710        ("fare-quasiquote" ,sbcl-fare-quasiquote)))
5711     (arguments
5712      '(#:phases
5713        (modify-phases %standard-phases
5714          (add-after 'unpack 'patch-requirement
5715            (lambda _
5716              (substitute* "fare-quasiquote-optima.asd"
5717                (("\\(:version \"optima\" \"1\\.0\"\\)")
5718                 "\"optima\""))
5719              #t)))))))
5720
5721 (define-public cl-fare-quasiquote-optima
5722   (sbcl-package->cl-source-package sbcl-fare-quasiquote-optima))
5723
5724 (define-public sbcl-fare-quasiquote-readtable
5725   (package
5726     (inherit sbcl-fare-quasiquote)
5727     (name "sbcl-fare-quasiquote-readtable")
5728     (inputs
5729      `(("fare-quasiquote" ,sbcl-fare-quasiquote)
5730        ("named-readtables" ,sbcl-named-readtables)))
5731     (description "The main purpose of this n+2nd reimplementation of
5732 quasiquote is enable matching of quasiquoted patterns, using Optima or
5733 Trivia.
5734
5735 This package uses fare-quasiquote with named-readtable.")))
5736
5737 (define-public cl-fare-quasiquote-readtable
5738   (sbcl-package->cl-source-package sbcl-fare-quasiquote-readtable))
5739
5740 ;; TODO: Add support for component-less system in asdf-build-system/sbcl.
5741 (define-public cl-fare-quasiquote-extras
5742   (package
5743     (inherit cl-fare-quasiquote)
5744     (name "cl-fare-quasiquote-extras")
5745     (build-system asdf-build-system/source)
5746     (propagated-inputs
5747      `(("fare-quasiquote" ,cl-fare-quasiquote)
5748        ("fare-quasiquote-optima" ,cl-fare-quasiquote-optima)
5749        ("fare-quasiquote-readtable" ,cl-fare-quasiquote-readtable)))
5750     (description "This library combines @code{fare-quasiquote-readtable} and
5751 @code{fare-quasiquote-optima}.")))
5752
5753 (define-public sbcl-trivia.level0
5754   (let ((commit "902e0c65602bbfe96ae82e679330b3771ddc7603")
5755         (revision "1"))
5756     (package
5757       (name "sbcl-trivia.level0")
5758       (build-system asdf-build-system/sbcl)
5759       (version (git-version "0.0.0" revision commit))
5760       (home-page "https://github.com/guicho271828/trivia")
5761       (source
5762        (origin
5763          (method git-fetch)
5764          (uri (git-reference
5765                (url home-page)
5766                (commit commit)))
5767          (file-name (git-file-name name version))
5768          (sha256
5769           (base32
5770            "11qbab30qqnfy9mx3x9fvgcw1jbvh1qn2cqv3p8xdn2m8981jvhr"))))
5771       (inputs
5772        `(("alexandria" ,sbcl-alexandria)))
5773       (synopsis "Pattern matching in Common Lisp")
5774       (description "Trivia is a pattern matching compiler that is compatible
5775 with Optima, another pattern matching library for Common Lisp.  It is meant to
5776 be faster and more extensible than Optima.")
5777       (license license:llgpl))))
5778
5779 (define-public sbcl-trivia.level1
5780   (package
5781     (inherit sbcl-trivia.level0)
5782     (name "sbcl-trivia.level1")
5783     (inputs
5784      `(("trivia.level0" ,sbcl-trivia.level0)))
5785     (description "Trivia is a pattern matching compiler that is compatible
5786 with Optima, another pattern matching library for Common Lisp.  It is meant to
5787 be faster and more extensible than Optima.
5788
5789 This system contains the core patterns of Trivia.")))
5790
5791 (define-public sbcl-trivia.level2
5792   (package
5793     (inherit sbcl-trivia.level0)
5794     (name "sbcl-trivia.level2")
5795     (inputs
5796      `(("trivia.level1" ,sbcl-trivia.level1)
5797        ("lisp-namespace" ,sbcl-lisp-namespace)
5798        ("trivial-cltl2" ,sbcl-trivial-cltl2)
5799        ("closer-mop" ,sbcl-closer-mop)))
5800     (description "Trivia is a pattern matching compiler that is compatible
5801 with Optima, another pattern matching library for Common Lisp.  It is meant to
5802 be faster and more extensible than Optima.
5803
5804 This system contains a non-optimized pattern matcher compatible with Optima,
5805 with extensible optimizer interface.")))
5806
5807 (define-public sbcl-trivia.trivial
5808   (package
5809     (inherit sbcl-trivia.level0)
5810     (name "sbcl-trivia.trivial")
5811     (inputs
5812      `(("trivia.level2" ,sbcl-trivia.level2)))
5813     (arguments
5814      `(#:phases
5815        (modify-phases %standard-phases
5816          (replace 'create-asd-file
5817            (lambda* (#:key outputs inputs #:allow-other-keys)
5818              (let* ((out (assoc-ref outputs "out"))
5819                     (lib (string-append out "/lib/" (%lisp-type)))
5820                     (level2 (assoc-ref inputs "trivia.level2")))
5821                (mkdir-p lib)
5822                (install-file "trivia.trivial.asd" lib)
5823                ;; XXX: This .asd does not have any component and the build
5824                ;; system fails to work in this case.  We should update the
5825                ;; build system to handle component-less .asd.
5826                ;; TODO: How do we append to file in Guile?  It seems that
5827                ;; (open-file ... "a") gets a "Permission denied".
5828                (substitute* (string-append lib "/trivia.trivial.asd")
5829                  (("\"\\)")
5830                   (string-append "\")
5831
5832 (progn (asdf/source-registry:ensure-source-registry)
5833        (setf (gethash
5834                \"trivia.level2\"
5835                asdf/source-registry:*source-registry*)
5836              #p\""
5837                                  level2
5838                                  "/share/common-lisp/sbcl-bundle-systems/trivia.level2.asd\"))")))))))))
5839     (description "Trivia is a pattern matching compiler that is compatible
5840 with Optima, another pattern matching library for Common Lisp.  It is meant to
5841 be faster and more extensible than Optima.
5842
5843 This system contains the base level system of Trivia with a trivial optimizer.")))
5844
5845 (define-public sbcl-trivia.balland2006
5846   (package
5847     (inherit sbcl-trivia.level0)
5848     (name "sbcl-trivia.balland2006")
5849     (inputs
5850      `(("trivia.trivial" ,sbcl-trivia.trivial)
5851        ("iterate" ,sbcl-iterate)
5852        ("type-i" ,sbcl-type-i)
5853        ("alexandria" ,sbcl-alexandria)))
5854     (arguments
5855      ;; Tests are done in trivia itself.
5856      `(#:tests? #f))
5857     (description "Trivia is a pattern matching compiler that is compatible
5858 with Optima, another pattern matching library for Common Lisp.  It is meant to
5859 be faster and more extensible than Optima.
5860
5861 This system contains the base level system of Trivia with a trivial optimizer.")))
5862
5863 (define-public sbcl-trivia.ppcre
5864   (package
5865     (inherit sbcl-trivia.level0)
5866     (name "sbcl-trivia.ppcre")
5867     (inputs
5868      `(("trivia.trivial" ,sbcl-trivia.trivial)
5869        ("cl-ppcre" ,sbcl-cl-ppcre)))
5870     (description "Trivia is a pattern matching compiler that is compatible
5871 with Optima, another pattern matching library for Common Lisp.  It is meant to
5872 be faster and more extensible than Optima.
5873
5874 This system contains the PPCRE extension.")))
5875
5876 (define-public sbcl-trivia.quasiquote
5877   (package
5878     (inherit sbcl-trivia.level0)
5879     (name "sbcl-trivia.quasiquote")
5880     (inputs
5881      `(("trivia.trivial" ,sbcl-trivia.trivial)
5882        ("fare-quasiquote" ,sbcl-fare-quasiquote)
5883        ("fare-quasiquote-readtable" ,sbcl-fare-quasiquote-readtable)))
5884     (description "Trivia is a pattern matching compiler that is compatible
5885 with Optima, another pattern matching library for Common Lisp.  It is meant to
5886 be faster and more extensible than Optima.
5887
5888 This system contains the fare-quasiquote extension.")))
5889
5890 (define-public sbcl-trivia.cffi
5891   (package
5892     (inherit sbcl-trivia.level0)
5893     (name "sbcl-trivia.cffi")
5894     (inputs
5895      `(("cffi" ,sbcl-cffi)
5896        ("trivia.trivial" ,sbcl-trivia.trivial)))
5897     (description "Trivia is a pattern matching compiler that is compatible
5898 with Optima, another pattern matching library for Common Lisp.  It is meant to
5899 be faster and more extensible than Optima.
5900
5901 This system contains the CFFI foreign slot access extension.")))
5902
5903 (define-public sbcl-trivia
5904   (package
5905     (inherit sbcl-trivia.level0)
5906     (name "sbcl-trivia")
5907     (inputs
5908      `(("trivia.balland2006" ,sbcl-trivia.balland2006)))
5909     (native-inputs
5910      `(("fiveam" ,sbcl-fiveam)
5911        ("trivia.ppcre" ,sbcl-trivia.ppcre)
5912        ("trivia.quasiquote" ,sbcl-trivia.quasiquote)
5913        ("trivia.cffi" ,sbcl-trivia.cffi)
5914        ("optima" ,sbcl-optima)))
5915     (arguments
5916      `(#:test-asd-file "trivia.test.asd"
5917        #:phases
5918        (modify-phases %standard-phases
5919          (add-after 'create-asd 'remove-component
5920            ;; XXX: The original .asd has no components, but our build system
5921            ;; creates an entry nonetheless.  We need to remove it for the
5922            ;; generated .asd to load properly.  See trivia.trivial for a
5923            ;; similar problem.
5924            (lambda* (#:key outputs #:allow-other-keys)
5925              (let* ((out (assoc-ref outputs "out"))
5926                     (asd (string-append out "/lib/" (%lisp-type) "/trivia.asd")))
5927                (substitute* asd
5928                  (("  :components
5929 ")
5930                   ""))
5931                (substitute* asd
5932                  ((" *\\(\\(:compiled-file \"trivia--system\"\\)\\)")
5933                   ""))))))))
5934     (description "Trivia is a pattern matching compiler that is compatible
5935 with Optima, another pattern matching library for Common Lisp.  It is meant to
5936 be faster and more extensible than Optima.")))
5937
5938 (define-public cl-trivia
5939   (sbcl-package->cl-source-package sbcl-trivia))
5940
5941 (define-public sbcl-mk-string-metrics
5942   (package
5943     (name "sbcl-mk-string-metrics")
5944     (version "0.1.2")
5945     (home-page "https://github.com/cbaggers/mk-string-metrics/")
5946     (source (origin
5947               (method git-fetch)
5948               (uri (git-reference
5949                     (url home-page)
5950                     (commit version)))
5951               (sha256
5952                (base32 "0bg0bv2mfd4k0g3x72x563hvmrx18xavaffr6xk5rh4if5j7kcf6"))
5953               (file-name (git-file-name name version))))
5954     (build-system asdf-build-system/sbcl)
5955     (synopsis "Calculate various string metrics efficiently in Common Lisp")
5956     (description "This library implements efficient algorithms that calculate
5957 various string metrics in Common Lisp:
5958
5959 @itemize
5960 @item Damerau-Levenshtein distance
5961 @item Hamming distance
5962 @item Jaccard similarity coefficient
5963 @item Jaro distance
5964 @item Jaro-Winkler distance
5965 @item Levenshtein distance
5966 @item Normalized Damerau-Levenshtein distance
5967 @item Normalized Levenshtein distance
5968 @item Overlap coefficient
5969 @end itemize\n")
5970     (license license:x11)))
5971
5972 (define-public cl-mk-string-metrics
5973   (sbcl-package->cl-source-package sbcl-mk-string-metrics))
5974
5975 (define-public sbcl-cl-str
5976   (let ((commit "3d5ec86e3a0199e5973aacde951086dfd754b5e5"))
5977     (package
5978       (name "sbcl-cl-str")
5979       (version (git-version "0.8" "1" commit))
5980       (home-page "https://github.com/vindarel/cl-str")
5981       (source (origin
5982                 (method git-fetch)
5983                 (uri (git-reference
5984                       (url home-page)
5985                       (commit commit)))
5986                 (sha256
5987                  (base32 "0szzzbygw9h985yxz909vvqrp69pmpcpahn7hn350lnyjislk9ga"))
5988                 (file-name (git-file-name name version))))
5989       (build-system asdf-build-system/sbcl)
5990       (inputs
5991        `(("cl-ppcre" ,sbcl-cl-ppcre)
5992          ("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)))
5993       (native-inputs
5994        `(("prove" ,sbcl-prove)
5995          ("prove-asdf" ,sbcl-prove-asdf)))
5996       (arguments
5997        `(#:asd-file "str.asd"
5998          #:asd-system-name "str"
5999          #:test-asd-file "str.test.asd"))
6000       (synopsis "Modern, consistent and terse Common Lisp string manipulation library")
6001       (description "A modern and consistent Common Lisp string manipulation
6002 library that focuses on modernity, simplicity and discoverability:
6003 @code{(str:trim s)} instead of @code{(string-trim '(#\\Space ...) s)}), or
6004 @code{str:concat strings} instead of an unusual format construct; one
6005 discoverable library instead of many; consistency and composability, where
6006 @code{s} is always the last argument, which makes it easier to feed pipes and
6007 arrows.")
6008       (license license:expat))))
6009
6010 (define-public cl-str
6011   (sbcl-package->cl-source-package sbcl-cl-str))
6012
6013 (define-public sbcl-cl-xmlspam
6014   (let ((commit "ea06abcca2a73a9779bcfb09081e56665f94e22a"))
6015     (package
6016       (name "sbcl-cl-xmlspam")
6017       (build-system asdf-build-system/sbcl)
6018       (version (git-version "0.0.0" "1" commit))
6019       (home-page "https://github.com/rogpeppe/cl-xmlspam")
6020       (source
6021        (origin
6022          (method git-fetch)
6023          (uri (git-reference
6024                (url home-page)
6025                (commit commit)))
6026          (file-name (string-append name "-" version))
6027          (sha256
6028           (base32
6029            "0w4rqvrgdgk3fwfq3kx4r7wwdr2bv3b6n3bdqwsiriw9psqzpz2s"))))
6030       (inputs
6031        `(("cxml" ,sbcl-cxml)
6032          ("cl-ppcre" ,sbcl-cl-ppcre)))
6033       (synopsis "Concise, regexp-like pattern matching on streaming XML for Common Lisp")
6034       (description "CXML does an excellent job at parsing XML elements, but what
6035 do you do when you have a XML file that's larger than you want to fit in
6036 memory, and you want to extract some information from it?  Writing code to deal
6037 with SAX events, or even using Klacks, quickly becomes tedious.
6038 @code{cl-xmlspam} (for XML Stream PAttern Matcher) is designed to make it easy
6039 to write code that mirrors the structure of the XML that it's parsing.  It
6040 also makes it easy to shift paradigms when necessary - the usual Lisp control
6041 constructs can be used interchangeably with pattern matching, and the full
6042 power of CXML is available when necessary.")
6043       (license license:bsd-3))))
6044
6045 ;; TODO: dbus uses ASDF's package-inferred-system which is not supported by
6046 ;; asdf-build-system/sbcl as of 2019-08-02.  We should fix
6047 ;; asdf-build-system/sbcl.
6048 (define-public cl-dbus
6049   (let ((commit "24b452df3a45ca5dc95015500f34baad175c981a")
6050         (revision "1"))
6051     (package
6052       (name "cl-dbus")
6053       (build-system asdf-build-system/source)
6054       (version (git-version "20190408" revision commit))
6055       (home-page "https://github.com/death/dbus")
6056       (source
6057        (origin
6058          (method git-fetch)
6059          (uri (git-reference
6060                (url home-page)
6061                (commit commit)))
6062          (file-name (git-file-name name version))
6063          (sha256
6064           (base32
6065            "0fw2q866yddbf23nk9pxphm9gsasx35vjyss82xzvndnjmzlqfl5"))))
6066       ;; Inputs must be propagated or else packages depending on this won't have the necessary packages.
6067       (propagated-inputs
6068        `(("alexandria" ,sbcl-alexandria)
6069          ("trivial-garbage" ,sbcl-trivial-garbage)
6070          ("babel" ,sbcl-babel)
6071          ("iolib" ,sbcl-iolib)
6072          ("iolib+multiplex" ,(@@ (gnu packages lisp-xyz) sbcl-iolib+multiplex))
6073          ("iolib+syscalls" ,(@@ (gnu packages lisp-xyz) sbcl-iolib+syscalls))
6074          ("iolib+streams" ,(@@ (gnu packages lisp-xyz) sbcl-iolib+streams))
6075          ("iolib+sockets" ,(@@ (gnu packages lisp-xyz) sbcl-iolib+sockets))
6076          ("ieee-floats" ,sbcl-ieee-floats)
6077          ("flexi-streams" ,sbcl-flexi-streams)
6078          ("cl-xmlspam" ,sbcl-cl-xmlspam)
6079          ("ironclad" ,sbcl-ironclad)))
6080       (synopsis "D-Bus client library for Common Lisp")
6081       (description "This is a Common Lisp library that allows to publish D-Bus
6082 objects as well as send and notify other objects connected to a bus.")
6083       (license license:bsd-2))))
6084
6085 (define-public sbcl-cl-hooks
6086   (let ((commit "5b638083f3b4f1221a52631d9c8a0a265565cac7")
6087         (revision "1"))
6088     (package
6089       (name "sbcl-cl-hooks")
6090       (build-system asdf-build-system/sbcl)
6091       (version (git-version "0.2.1" revision commit))
6092       (home-page "https://github.com/scymtym/architecture.hooks")
6093       (source
6094        (origin
6095          (method git-fetch)
6096          (uri (git-reference
6097                (url home-page)
6098                (commit commit)))
6099          (file-name (git-file-name name version))
6100          (sha256
6101           (base32
6102            "0bg3l0a28lw5gqqjp6p6b5nhwqk46sgkb7184w5qbfngw1hk8x9y"))))
6103       (inputs
6104        `(("alexandria" ,sbcl-alexandria)
6105          ("let-plus" ,sbcl-let-plus)
6106          ("trivial-garbage" ,sbcl-trivial-garbage)
6107          ("closer-mop" ,sbcl-closer-mop)))
6108       (native-inputs
6109        `(("fiveam" ,sbcl-fiveam)))
6110       (synopsis "Hooks extension point mechanism (as in Emacs) for Common Lisp")
6111       (description "A hook, in the present context, is a certain kind of
6112 extension point in a program that allows interleaving the execution of
6113 arbitrary code with the execution of a the program without introducing any
6114 coupling between the two.  Hooks are used extensively in the extensible editor
6115 Emacs.
6116
6117 In the Common LISP Object System (CLOS), a similar kind of extensibility is
6118 possible using the flexible multi-method dispatch mechanism.  It may even seem
6119 that the concept of hooks does not provide any benefits over the possibilities
6120 of CLOS.  However, there are some differences:
6121
6122 @itemize
6123
6124 @item There can be only one method for each combination of specializers and
6125 qualifiers.  As a result this kind of extension point cannot be used by
6126 multiple extensions independently.
6127 @item Removing code previously attached via a @code{:before}, @code{:after} or
6128 @code{:around} method can be cumbersome.
6129 @item There could be other or even multiple extension points besides @code{:before}
6130 and @code{:after} in a single method.
6131 @item Attaching codes to individual objects using eql specializers can be
6132 cumbersome.
6133 @item Introspection of code attached a particular extension point is
6134 cumbersome since this requires enumerating and inspecting the methods of a
6135 generic function.
6136 @end itemize
6137
6138 This library tries to complement some of these weaknesses of method-based
6139 extension-points via the concept of hooks.")
6140       (license license:llgpl))))
6141
6142 (define-public cl-hooks
6143   (sbcl-package->cl-source-package sbcl-cl-hooks))
6144
6145 (define-public ecl-cl-hooks
6146   (sbcl-package->ecl-package sbcl-cl-hooks))
6147
6148 (define-public sbcl-s-sysdeps
6149   (let ((commit "d28246b5dffef9e73a0e0e6cfbc4e878006fe34d")
6150         (revision "1"))
6151     (package
6152       (name "sbcl-s-sysdeps")
6153       (build-system asdf-build-system/sbcl)
6154       (version (git-version "1" revision commit))
6155       (home-page "https://github.com/svenvc/s-sysdeps")
6156       (source
6157        (origin
6158          (method git-fetch)
6159          (uri (git-reference
6160                (url home-page)
6161                (commit commit)))
6162          (file-name (git-file-name name version))
6163          (sha256
6164           (base32
6165            "14b69b81yrxmjlvmm3lfxk04x5v7hqz4fql121334wh72czznfh9"))))
6166       (synopsis "Common Lisp abstraction layer over platform dependent functionality")
6167       (description "@code{s-sysdeps} is an abstraction layer over platform
6168 dependent functionality.  This simple package is used as a building block in a
6169 number of other open source projects.
6170
6171 @code{s-sysdeps} abstracts:
6172
6173 @itemize
6174 @item managing processes,
6175 @item implementing a standard TCP/IP server,
6176 @item opening a client TCP/IP socket stream,
6177 @item working with process locks.
6178 @end itemize\n")
6179       (license license:llgpl))))
6180
6181 (define-public cl-s-sysdeps
6182   (sbcl-package->cl-source-package sbcl-s-sysdeps))
6183
6184 (define-public ecl-s-sysdeps
6185   (sbcl-package->ecl-package sbcl-s-sysdeps))
6186
6187 (define-public sbcl-cl-prevalence
6188   (let ((commit "c163c227ed85d430b82cb1e3502f72d4f88e3cfa")
6189         (revision "1"))
6190     (package
6191       (name "sbcl-cl-prevalence")
6192       (build-system asdf-build-system/sbcl)
6193       (version (git-version "5" revision commit))
6194       (home-page "https://github.com/40ants/cl-prevalence")
6195       (source
6196        (origin
6197          (method git-fetch)
6198          (uri (git-reference
6199                (url home-page)
6200                (commit commit)))
6201          (file-name (git-file-name name version))
6202          (sha256
6203           (base32
6204            "1i9zj1q2ahgwch56an21yzbgkynz0kab9fyxkq9mg8p3xrv38jjn"))))
6205       (inputs
6206        `(("s-sysdeps" ,sbcl-s-sysdeps)
6207          ("s-xml" ,sbcl-s-xml)))
6208       (synopsis "Implementation of object prevalence for Common Lisp")
6209       (description "This Common Lisp library implements object prevalence (see
6210 @url{https://en.wikipedia.org/wiki/System_prevalence}).  It allows
6211 for (de)serializing to and from s-exps as well as XML.  Serialization of arbitrary
6212 classes and cyclic data structures are supported.")
6213       (license license:llgpl))))
6214
6215 (define-public cl-prevalence
6216   (sbcl-package->cl-source-package sbcl-cl-prevalence))
6217
6218 (define-public ecl-cl-prevalence
6219   (sbcl-package->ecl-package sbcl-cl-prevalence))
6220
6221 (define-public sbcl-series
6222   (let ((commit "da9061b336119d1e5214aff9117171d494d5a58a")
6223         (revision "1"))
6224     (package
6225       (name "sbcl-series")
6226       (version (git-version "2.2.11" revision commit))
6227       (source
6228        (origin
6229          (method git-fetch)
6230          (uri (git-reference
6231                (url "git://git.code.sf.net/p/series/series")
6232                (commit commit)))
6233          (file-name (git-file-name name version))
6234          (sha256
6235           (base32
6236            "07hk2lhfx42zk018pxqvn4gs77vd4n4g8m4xxbqaxgca76mifwfw"))))
6237       (build-system asdf-build-system/sbcl)
6238       (arguments
6239        ;; Disable the tests, they are apparently buggy and I didn't find
6240        ;; a simple way to make them run and pass.
6241        '(#:tests? #f))
6242       (synopsis "Series data structure for Common Lisp")
6243       (description
6244        "This Common Lisp library provides a series data structure much like
6245 a sequence, with similar kinds of operations.  The difference is that in many
6246 situations, operations on series may be composed functionally and yet execute
6247 iteratively, without the need to construct intermediate series values
6248 explicitly.  In this manner, series provide both the clarity of a functional
6249 programming style and the efficiency of an iterative programming style.")
6250       (home-page "http://series.sourceforge.net/")
6251       (license license:expat))))
6252
6253 (define-public cl-series
6254   (sbcl-package->cl-source-package sbcl-series))
6255
6256 (define-public ecl-series
6257   (sbcl-package->ecl-package sbcl-series))
6258
6259 (define-public sbcl-periods
6260   (let ((commit "983d4a57325db3c8def942f163133cec5391ec28")
6261         (revision "1"))
6262     (package
6263       (name "sbcl-periods")
6264       (version (git-version "0.0.2" revision commit))
6265       (source
6266        (origin
6267          (method git-fetch)
6268          (uri (git-reference
6269                (url "https://github.com/jwiegley/periods.git")
6270                (commit commit)))
6271          (file-name (git-file-name name version))
6272          (sha256
6273           (base32
6274            "0z30jr3lxz3cmi019fsl4lgcgwf0yqpn95v9zkkkwgymdrkd4lga"))))
6275       (build-system asdf-build-system/sbcl)
6276       (inputs
6277        `(("local-time" ,sbcl-local-time)))
6278       (synopsis "Common Lisp library for manipulating date/time objects")
6279       (description
6280        "Periods is a Common Lisp library providing a set of utilities for
6281 manipulating times, distances between times, and both contiguous and
6282 discontiguous ranges of time.")
6283       (home-page "https://github.com/jwiegley/periods")
6284       (license license:bsd-3))))
6285
6286 (define-public cl-periods
6287   (sbcl-package->cl-source-package sbcl-periods))
6288
6289 (define-public ecl-periods
6290   (sbcl-package->ecl-package sbcl-periods))
6291
6292 (define-public sbcl-periods-series
6293   (package
6294     (inherit sbcl-periods)
6295     (name "sbcl-periods-series")
6296     (inputs
6297      `(("periods" ,sbcl-periods)
6298        ("series" ,sbcl-series)))
6299     (arguments
6300      '(#:asd-file "periods-series.asd"
6301        #:asd-system-name "periods-series"))
6302     (description
6303      "Periods-series is an extension of the periods Common Lisp library
6304 providing functions compatible with the series Common Lisp library.")))
6305
6306 (define-public cl-periods-series
6307   (sbcl-package->cl-source-package sbcl-periods-series))
6308
6309 (define-public ecl-periods-series
6310   (sbcl-package->ecl-package sbcl-periods-series))
6311
6312 (define-public sbcl-metatilities-base
6313   (let ((commit "6eaa9e3ff0939a93a92109dd0fcd218de85417d5")
6314         (revision "1"))
6315     (package
6316       (name "sbcl-metatilities-base")
6317       (version (git-version "0.6.6" revision commit))
6318       (source
6319        (origin
6320          (method git-fetch)
6321          (uri (git-reference
6322                (url "https://github.com/gwkkwg/metatilities-base.git")
6323                (commit commit)))
6324          (file-name (git-file-name name version))
6325          (sha256
6326           (base32
6327            "0xpa86pdzlnf4v5g64j3ifaplx71sx2ha8b7vvakswi652679ma0"))))
6328       (build-system asdf-build-system/sbcl)
6329       (native-inputs
6330        `(("lift" ,sbcl-lift)))
6331       (synopsis "Core of the metatilities Common Lisp library")
6332       (description
6333        "Metatilities-base is the core of the metatilities Common Lisp library
6334 which implements a set of utilities.")
6335       (home-page "https://common-lisp.net/project/metatilities-base/")
6336       (license license:expat))))
6337
6338 (define-public cl-metatilities-base
6339   (sbcl-package->cl-source-package sbcl-metatilities-base))
6340
6341 (define-public ecl-metatilities-base
6342   (sbcl-package->ecl-package sbcl-metatilities-base))
6343
6344 (define-public sbcl-cl-containers
6345   (let ((commit "810927e19d933bcf38ffeb7a23ce521efc432d45")
6346         (revision "1"))
6347     (package
6348       (name "sbcl-cl-containers")
6349       (version (git-version "0.12.1" revision commit))
6350       (source
6351        (origin
6352          (method git-fetch)
6353          (uri (git-reference
6354                (url "https://github.com/gwkkwg/cl-containers.git")
6355                (commit commit)))
6356          (file-name (git-file-name name version))
6357          (sha256
6358           (base32
6359            "1s9faxw7svhbjpkhfrz2qxgjm3cvyjb8wpyb4m8dx4i5g7vvprkv"))))
6360       (build-system asdf-build-system/sbcl)
6361       (native-inputs
6362        `(("lift" ,sbcl-lift)))
6363       (inputs
6364        `(("metatilities-base" ,sbcl-metatilities-base)))
6365       (arguments
6366        '(#:phases
6367          (modify-phases %standard-phases
6368            (add-after 'unpack 'relax-version-checks
6369              (lambda _
6370                (substitute* "cl-containers.asd"
6371                  (("\\(:version \"metatilities-base\" \"0\\.6\\.6\"\\)")
6372                   "\"metatilities-base\""))
6373                (substitute* "cl-containers-test.asd"
6374                  (("\\(:version \"lift\" \"1\\.7\\.0\"\\)")
6375                   "\"lift\""))
6376                #t)))))
6377       (synopsis "Container library for Common Lisp")
6378       (description
6379        "Common Lisp ships with a set of powerful built in data structures
6380 including the venerable list, full featured arrays, and hash-tables.
6381 CL-containers enhances and builds on these structures by adding containers
6382 that are not available in native Lisp (for example: binary search trees,
6383 red-black trees, sparse arrays and so on), and by providing a standard
6384 interface so that they are simpler to use and so that changing design
6385 decisions becomes significantly easier.")
6386       (home-page "https://common-lisp.net/project/cl-containers/")
6387       (license license:expat))))
6388
6389 (define-public cl-containers
6390   (sbcl-package->cl-source-package sbcl-cl-containers))
6391
6392 (define-public ecl-cl-containers
6393   (sbcl-package->ecl-package sbcl-cl-containers))
6394
6395 (define-public sbcl-xlunit
6396   (let ((commit "3805d34b1d8dc77f7e0ee527a2490194292dd0fc")
6397         (revision "1"))
6398     (package
6399       (name "sbcl-xlunit")
6400       (version (git-version "0.6.3" revision commit))
6401       (source
6402        (origin
6403          (method git-fetch)
6404          (uri (git-reference
6405                (url "http://git.kpe.io/xlunit.git")
6406                (commit commit)))
6407          (file-name (git-file-name name version))
6408          (sha256
6409           (base32
6410            "0argfmp9nghs4sihyj3f8ch9qfib2b7ll07v5m9ziajgzsfl5xw3"))))
6411       (build-system asdf-build-system/sbcl)
6412       (arguments
6413        '(#:phases
6414          (modify-phases %standard-phases
6415            (add-after 'unpack 'fix-tests
6416              (lambda _
6417                (substitute* "xlunit.asd"
6418                  ((" :force t") ""))
6419                #t)))))
6420       (synopsis "Unit testing package for Common Lisp")
6421       (description
6422        "The XLUnit package is a toolkit for building test suites.  It is based
6423 on the XPTest package by Craig Brozensky and the JUnit package by Kent Beck.")
6424       (home-page "http://quickdocs.org/xlunit/")
6425       (license license:bsd-3))))
6426
6427 (define-public cl-xlunit
6428   (sbcl-package->cl-source-package sbcl-xlunit))
6429
6430 (define-public ecl-xlunit
6431   (sbcl-package->ecl-package sbcl-xlunit))
6432
6433 (define-public sbcl-fprog
6434   (let ((commit "7016d1a98215f82605d1c158e7a16504ca1f4636")
6435         (revision "1"))
6436     (package
6437       (name "sbcl-fprog")
6438       (version (git-version "1.0.0" revision commit))
6439       (source
6440        (origin
6441          (method git-fetch)
6442          (uri (git-reference
6443                (url "https://github.com/jwiegley/cambl.git")
6444                (commit commit)))
6445          (file-name (git-file-name name version))
6446          (sha256
6447           (base32
6448            "103mry04j2k9vznsxm7wcvccgxkil92cdrv52miwcmxl8daa4jiz"))))
6449       (build-system asdf-build-system/sbcl)
6450       (synopsis "Functional programming utilities for Common Lisp")
6451       (description
6452        "@code{fprog} is a Common Lisp library allowing iteration over
6453 immutable lists sharing identical sublists.")
6454       (home-page "https://github.com/jwiegley/cambl")
6455       (license license:bsd-3))))
6456
6457 (define-public cl-fprog
6458   (sbcl-package->cl-source-package sbcl-fprog))
6459
6460 (define-public ecl-fprog
6461   (sbcl-package->ecl-package sbcl-fprog))
6462
6463 (define-public sbcl-cambl
6464   (let ((commit "7016d1a98215f82605d1c158e7a16504ca1f4636")
6465         (revision "1"))
6466     (package
6467       (inherit sbcl-fprog)
6468       (name "sbcl-cambl")
6469       (version (git-version "4.0.0" revision commit))
6470       (native-inputs
6471        `(("xlunit" ,sbcl-xlunit)))
6472       (inputs
6473        `(("alexandria" ,sbcl-alexandria)
6474          ("cl-containers" ,sbcl-cl-containers)
6475          ("local-time" ,sbcl-local-time)
6476          ("periods" ,sbcl-periods)
6477          ("fprog" ,sbcl-fprog)))
6478       (synopsis "Commoditized amounts and balances for Common Lisp")
6479       (description
6480        "CAMBL is a Common Lisp library providing a convenient facility for
6481 working with commoditized values.  It does not allow compound units (and so is
6482 not suited for scientific operations) but does work rather nicely for the
6483 purpose of financial calculations."))))
6484
6485 (define-public cl-cambl
6486   (sbcl-package->cl-source-package sbcl-cambl))
6487
6488 (define-public ecl-cambl
6489   (sbcl-package->ecl-package sbcl-cambl))
6490
6491 (define-public sbcl-cl-ledger
6492   (let ((commit "08e0be41795e804cd36142e51756ad0b1caa377b")
6493         (revision "1"))
6494     (package
6495       (name "sbcl-cl-ledger")
6496       (version (git-version "4.0.0" revision commit))
6497       (source
6498        (origin
6499          (method git-fetch)
6500          (uri (git-reference
6501                (url "https://github.com/ledger/cl-ledger.git")
6502                (commit commit)))
6503          (file-name (git-file-name name version))
6504          (sha256
6505           (base32
6506            "1via0qf6wjcyxnfbmfxjvms0ik9j8rqbifgpmnhrzvkhrq9pv8h1"))))
6507       (build-system asdf-build-system/sbcl)
6508       (inputs
6509        `(("cambl" ,sbcl-cambl)
6510          ("cl-ppcre" ,sbcl-cl-ppcre)
6511          ("local-time" ,sbcl-local-time)
6512          ("periods-series" ,sbcl-periods-series)))
6513       (arguments
6514        '(#:phases
6515          (modify-phases %standard-phases
6516            (add-after 'unpack 'fix-system-definition
6517              (lambda _
6518                (substitute* "cl-ledger.asd"
6519                  (("  :build-operation program-op") "")
6520                  (("  :build-pathname \"cl-ledger\"") "")
6521                  (("  :entry-point \"ledger::main\"") ""))
6522                #t)))))
6523       (synopsis "Common Lisp port of the Ledger accounting system")
6524       (description
6525        "CL-Ledger is a Common Lisp port of the Ledger double-entry accounting
6526 system.")
6527       (home-page "https://github.com/ledger/cl-ledger")
6528       (license license:bsd-3))))
6529
6530 (define-public cl-ledger
6531   (sbcl-package->cl-source-package sbcl-cl-ledger))
6532
6533 (define-public ecl-cl-ledger
6534   (sbcl-package->ecl-package sbcl-cl-ledger))
6535
6536 (define-public sbcl-bst
6537   (let ((commit "34f9c7e8e0a9f2c952fe310ab36cb630d5d9c15a")
6538         (revision "1"))
6539     (package
6540       (name "sbcl-bst")
6541       (version (git-version "1.1" revision commit))
6542       (source
6543        (origin
6544          (method git-fetch)
6545          (uri (git-reference
6546                (url "https://github.com/glv2/bst.git")
6547                (commit commit)))
6548          (file-name (git-file-name name version))
6549          (sha256
6550           (base32
6551            "1amxns7hvvh4arwbh8ciwfzplg127vh37dnbamv1m1kmmnmihfc8"))))
6552       (build-system asdf-build-system/sbcl)
6553       (native-inputs
6554        `(("alexandria" ,sbcl-alexandria)
6555          ("fiveam" ,sbcl-fiveam)))
6556       (synopsis "Binary search tree for Common Lisp")
6557       (description
6558        "BST is a Common Lisp library for working with binary search trees that
6559 can contain any kind of values.")
6560       (home-page "https://github.com/glv2/bst")
6561       (license license:gpl3))))
6562
6563 (define-public cl-bst
6564   (sbcl-package->cl-source-package sbcl-bst))
6565
6566 (define-public ecl-bst
6567   (sbcl-package->ecl-package sbcl-bst))
6568
6569 (define-public sbcl-cl-octet-streams
6570   (package
6571     (name "sbcl-cl-octet-streams")
6572     (version "1.0")
6573     (source
6574      (origin
6575        (method git-fetch)
6576        (uri (git-reference
6577              (url "https://github.com/glv2/cl-octet-streams.git")
6578              (commit (string-append "v" version))))
6579        (file-name (git-file-name name version))
6580        (sha256
6581         (base32
6582          "1d7mn6ydv0j2x4r7clpc9ijjwrnfpxmvhifv8n5j7jh7s744sf8d"))))
6583     (build-system asdf-build-system/sbcl)
6584     (native-inputs
6585      `(("fiveam" ,sbcl-fiveam)))
6586     (inputs
6587      `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
6588     (synopsis "In-memory octet streams for Common Lisp")
6589     (description
6590      "CL-octet-streams is a library implementing in-memory octet
6591 streams for Common Lisp.  It was inspired by the trivial-octet-streams and
6592 cl-plumbing libraries.")
6593     (home-page "https://github.com/glv2/cl-octet-streams")
6594     (license license:gpl3+)))
6595
6596 (define-public cl-octet-streams
6597   (sbcl-package->cl-source-package sbcl-cl-octet-streams))
6598
6599 (define-public ecl-cl-octet-streams
6600   (sbcl-package->ecl-package sbcl-cl-octet-streams))
6601
6602 (define-public sbcl-lzlib
6603   (let ((commit "0de1db7129fef9a58a059d35a2fa2ecfc5b47b47")
6604         (revision "1"))
6605     (package
6606       (name "sbcl-lzlib")
6607       (version (git-version "1.0" revision commit))
6608       (source
6609        (origin
6610          (method git-fetch)
6611          (uri (git-reference
6612                (url "https://github.com/glv2/cl-lzlib.git")
6613                (commit commit)))
6614          (file-name (git-file-name name version))
6615          (sha256
6616           (base32
6617            "12ny7vj52fgnd8hb8fc8mry92vq4c1x72x2350191m4476j95clz"))))
6618       (build-system asdf-build-system/sbcl)
6619       (native-inputs
6620        `(("fiveam" ,sbcl-fiveam)))
6621       (inputs
6622        `(("cffi" ,sbcl-cffi)
6623          ("cl-octet-streams" ,sbcl-cl-octet-streams)
6624          ("lzlib" ,lzlib)))
6625       (arguments
6626        '(#:phases
6627          (modify-phases %standard-phases
6628            (add-after 'unpack 'fix-paths
6629              (lambda* (#:key inputs #:allow-other-keys)
6630                (substitute* "src/lzlib.lisp"
6631                  (("liblz\\.so")
6632                   (string-append (assoc-ref inputs "lzlib") "/lib/liblz.so")))
6633                #t)))))
6634       (synopsis "Common Lisp library for lzip (de)compression")
6635       (description
6636        "This Common Lisp library provides functions for lzip (LZMA)
6637 compression/decompression using bindings to the lzlib C library.")
6638       (home-page "https://github.com/glv2/cl-lzlib")
6639       (license license:gpl3+))))
6640
6641 (define-public cl-lzlib
6642   (sbcl-package->cl-source-package sbcl-lzlib))
6643
6644 (define-public ecl-lzlib
6645   (sbcl-package->ecl-package sbcl-lzlib))
6646
6647 (define-public sbcl-chanl
6648   (let ((commit "2362b57550c2c9238cc882d03553aaa1040b7340")
6649         (revision "0"))
6650     (package
6651       (name "sbcl-chanl")
6652       (version (git-version "0.4.1" revision commit))
6653       (source
6654        (origin
6655          (method git-fetch)
6656          (uri (git-reference
6657                (url "https://github.com/zkat/chanl.git")
6658                (commit commit)))
6659          (file-name (git-file-name name version))
6660          (sha256
6661           (base32
6662            "0ag3wz7yrqwp0s5069wwda98z3rrqd25spg8sa8rdqghj084w28w"))))
6663       (build-system asdf-build-system/sbcl)
6664       (native-inputs
6665        `(("fiveam" ,sbcl-fiveam)))
6666       (inputs
6667        `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
6668       (synopsis "Portable channel-based concurrency for Common Lisp")
6669       (description "Common Lisp library for channel-based concurrency.  In
6670 a nutshell, you create various threads sequentially executing tasks you need
6671 done, and use channel objects to communicate and synchronize the state of these
6672 threads.")
6673       (home-page "https://github.com/zkat/chanl")
6674       (license (list license:expat license:bsd-3)))))
6675
6676 (define-public cl-chanl
6677   (sbcl-package->cl-source-package sbcl-chanl))
6678
6679 (define-public ecl-chanl
6680   (let ((base (sbcl-package->ecl-package sbcl-chanl)))
6681     (package
6682       (inherit base)
6683       (arguments
6684        (substitute-keyword-arguments (package-arguments base)
6685          ;; The CHANL.ACTORS package uses the :ARGUMENTS option of
6686          ;; DEFINE-METHOD-COMBINATION, which is not implemented in ECL yet
6687          ;; (see https://gitlab.com/embeddable-common-lisp/ecl/issues/305).
6688          ;; So let's disable it for now, as it allows compiling the library
6689          ;; and using the rest of it.
6690          ((#:phases phases '%standard-phases)
6691           `(modify-phases ,phases
6692              (add-after 'unpack 'disable-chanl-actors
6693                (lambda _
6694                  (substitute* "chanl.asd"
6695                    (("\\(:file \"actors\"\\)") ""))
6696                  #t))))
6697          ;; Disable the tests for now, as the SEND-SEQUENCE test seems to
6698          ;; never end.
6699          ((#:tests? _ #f) #f))))))
6700
6701 (define-public sbcl-cl-store
6702   (let ((commit "c787337a16ea8cf8a06227f35933a4ec774746b3")
6703         (revision "1"))
6704     (package
6705       (name "sbcl-cl-store")
6706       (version (git-version "0.8.11" revision commit))
6707       (source
6708        (origin
6709          (method git-fetch)
6710          (uri (git-reference
6711                (url "https://github.com/skypher/cl-store.git")
6712                (commit commit)))
6713          (file-name (git-file-name name version))
6714          (sha256
6715           (base32
6716            "194srkg8nrym19c6i7zbnkzshc1qhqa82m53qnkirz9fw928bqxr"))))
6717       (build-system asdf-build-system/sbcl)
6718       (native-inputs
6719        `(("rt" ,sbcl-rt)))
6720       (synopsis "Common Lisp library to serialize data")
6721       (description
6722        "CL-STORE is a portable serialization package which should give you the
6723 ability to store all Common Lisp data types into streams.")
6724       (home-page "https://www.common-lisp.net/project/cl-store/")
6725       (license license:expat))))
6726
6727 (define-public cl-store
6728   (sbcl-package->cl-source-package sbcl-cl-store))
6729
6730 (define-public ecl-cl-store
6731   (sbcl-package->ecl-package sbcl-cl-store))
6732
6733 (define-public sbcl-cl-gobject-introspection
6734   (let ((commit "7b703e2384945ea0ac39d9b766de434a08d81560")
6735         (revision "0"))
6736     (package
6737       (name "sbcl-cl-gobject-introspection")
6738       (version (git-version "0.3" revision commit))
6739       (home-page "https://github.com/andy128k/cl-gobject-introspection")
6740       (source
6741        (origin
6742          (method git-fetch)
6743          (uri (git-reference
6744                (url home-page)
6745                (commit commit)))
6746          (file-name (git-file-name name version))
6747          (sha256
6748           (base32
6749            "1zcqd2qj14f6b38vys8gr89s6cijsp9r8j43xa8lynilwva7bwyh"))))
6750       (build-system asdf-build-system/sbcl)
6751       (inputs
6752        `(("alexandria" ,sbcl-alexandria)
6753          ("cffi" ,sbcl-cffi)
6754          ("iterate" ,sbcl-iterate)
6755          ("trivial-garbage" ,sbcl-trivial-garbage)
6756          ("glib" ,glib)
6757          ("gobject-introspection" ,gobject-introspection)))
6758       (native-inputs
6759        `(("fiveam" ,sbcl-fiveam)))
6760       (arguments
6761        ;; TODO: Tests fail, see
6762        ;; https://github.com/andy128k/cl-gobject-introspection/issues/70.
6763        '(#:tests? #f
6764          #:phases
6765          (modify-phases %standard-phases
6766            (add-after (quote unpack) (quote fix-paths)
6767              (lambda* (#:key inputs #:allow-other-keys)
6768                (substitute* "src/init.lisp"
6769                  (("libgobject-2\\.0\\.so")
6770                   (string-append (assoc-ref inputs "glib") "/lib/libgobject-2.0.so"))
6771                  (("libgirepository-1\\.0\\.so")
6772                   (string-append (assoc-ref inputs "gobject-introspection")
6773                                  "/lib/libgirepository-1.0.so")))
6774                #t)))))
6775       (synopsis "Common Lisp bindings to GObject Introspection")
6776       (description
6777        "This library is a bridge between Common Lisp and GObject
6778 Introspection, which enables Common Lisp programs to access the full interface
6779 of C+GObject libraries without the need of writing dedicated bindings.")
6780       (license (list license:bsd-3
6781                      ;; Tests are under a different license.
6782                      license:llgpl)))))
6783
6784 (define-public cl-gobject-introspection
6785   (sbcl-package->cl-source-package sbcl-cl-gobject-introspection))
6786
6787 (define-public sbcl-string-case
6788   (let ((commit "718c761e33749e297cd2809c7ba3ade1985c49f7")
6789         (revision "0"))
6790     (package
6791       (name "sbcl-string-case")
6792       (version (git-version "0.0.2" revision commit))
6793       (home-page "https://github.com/pkhuong/string-case")
6794       (source
6795        (origin
6796          (method git-fetch)
6797          (uri (git-reference
6798                (url home-page)
6799                (commit commit)))
6800          (file-name (git-file-name name version))
6801          (sha256
6802           (base32
6803            "1n5i3yh0h5s636rcnwn7jwqy3rjflikra04lymimhpcshhjsk0md"))))
6804       (build-system asdf-build-system/sbcl)
6805       (synopsis "Efficient string= case in Common Lisp")
6806       (description
6807        "@code{string-case} is a Common Lisp macro that generates specialised decision
6808 trees to dispatch on string equality.")
6809       (license license:bsd-3))))
6810
6811 (define-public cl-string-case
6812   (sbcl-package->cl-source-package sbcl-string-case))
6813
6814 (define-public ecl-string-case
6815   (sbcl-package->ecl-package sbcl-string-case))
6816
6817 (define-public sbcl-global-vars
6818   (let ((commit "c749f32c9b606a1457daa47d59630708ac0c266e")
6819         (revision "0"))
6820     (package
6821       (name "sbcl-global-vars")
6822       (version (git-version "1.0.0" revision commit))
6823       (home-page "https://github.com/lmj/global-vars")
6824       (source
6825        (origin
6826          (method git-fetch)
6827          (uri (git-reference
6828                (url home-page)
6829                (commit commit)))
6830          (file-name (git-file-name name version))
6831          (sha256
6832           (base32
6833            "06m3xc8l3pgsapl8fvsi9wf6y46zs75cp9zn7zh6dc65v4s5wz3d"))))
6834       (build-system asdf-build-system/sbcl)
6835       (synopsis "Efficient global variables in Common Lisp")
6836       (description
6837        "In Common Lisp, a special variable that is never dynamically bound
6838 typically serves as a stand-in for a global variable.  The @code{global-vars}
6839 library provides true global variables that are implemented by some compilers.
6840 An attempt to rebind a global variable properly results in a compiler error.
6841 That is, a global variable cannot be dynamically bound.
6842
6843 Global variables therefore allow us to communicate an intended usage that
6844 differs from special variables.  Global variables are also more efficient than
6845 special variables, especially in the presence of threads.")
6846       (license license:expat))))
6847
6848 (define-public cl-global-vars
6849   (sbcl-package->cl-source-package sbcl-global-vars))
6850
6851 (define-public ecl-global-vars
6852   (sbcl-package->ecl-package sbcl-global-vars))
6853
6854 (define-public sbcl-trivial-file-size
6855   (let ((commit "1c1d672a01a446ba0391dbb4ffc40be3b0476f23")
6856         (revision "0"))
6857     (package
6858       (name "sbcl-trivial-file-size")
6859       (version (git-version "0.0.0" revision commit))
6860       (home-page "https://github.com/ruricolist/trivial-file-size")
6861       (source
6862        (origin
6863          (method git-fetch)
6864          (uri (git-reference
6865                (url home-page)
6866                (commit commit)))
6867          (file-name (git-file-name name version))
6868          (sha256
6869           (base32
6870            "17pp86c9zs4y7i1sh7q9gbfw9iqv6655k7fz8qbj9ly1ypgxp4qs"))))
6871       (build-system asdf-build-system/sbcl)
6872       (native-inputs
6873        `(("fiveam" ,sbcl-fiveam)))
6874       (synopsis "Size of a file in bytes in Common Lisp")
6875       (description
6876        "The canonical way to determine the size of a file in bytes, using Common Lisp,
6877 is to open the file with an element type of (unsigned-byte 8) and then
6878 calculate the length of the stream.  This is less than ideal.  In most cases
6879 it is better to get the size of the file from its metadata, using a system
6880 call.
6881
6882 This library exports a single function, file-size-in-octets.  It returns the
6883 size of a file in bytes, using system calls when possible.")
6884       (license license:expat))))
6885
6886 (define-public cl-trivial-file-size
6887   (sbcl-package->cl-source-package sbcl-trivial-file-size))
6888
6889 (define-public ecl-trivial-file-size
6890   (sbcl-package->ecl-package sbcl-trivial-file-size))
6891
6892 (define-public sbcl-trivial-macroexpand-all
6893   (let ((commit "933270ac7107477de1bc92c1fd641fe646a7a8a9")
6894         (revision "0"))
6895     (package
6896       (name "sbcl-trivial-macroexpand-all")
6897       (version (git-version "0.0.0" revision commit))
6898       (home-page "https://github.com/cbaggers/trivial-macroexpand-all")
6899       (source
6900        (origin
6901          (method git-fetch)
6902          (uri (git-reference
6903                (url home-page)
6904                (commit commit)))
6905          (file-name (git-file-name name version))
6906          (sha256
6907           (base32
6908            "191hnn4b5j4i3crydmlzbm231kj0h7l8zj6mzj69r1npbzkas4bd"))))
6909       (build-system asdf-build-system/sbcl)
6910       (native-inputs
6911        `(("fiveam" ,sbcl-fiveam)))
6912       (synopsis "Portable macroexpand-all for Common Lisp")
6913       (description
6914        "This library provides a macroexpand-all function that calls the
6915 implementation specific equivalent.")
6916       (license license:unlicense))))
6917
6918 (define-public cl-trivial-macroexpand-all
6919   (sbcl-package->cl-source-package sbcl-trivial-macroexpand-all))
6920
6921 (define-public ecl-trivial-macroexpand-all
6922   (sbcl-package->ecl-package sbcl-trivial-macroexpand-all))
6923
6924 (define-public sbcl-serapeum
6925   (let ((commit "65837f8a0d65b36369ec8d000fff5c29a395b5fe")
6926         (revision "0"))
6927     (package
6928       (name "sbcl-serapeum")
6929       (version (git-version "0.0.0" revision commit))
6930       (home-page "https://github.com/ruricolist/serapeum")
6931       (source
6932        (origin
6933          (method git-fetch)
6934          (uri (git-reference
6935                (url home-page)
6936                (commit commit)))
6937          (file-name (git-file-name name version))
6938          (sha256
6939           (base32
6940            "0clwf81r2lvk1rbfvk91s9zmbkas9imf57ilqclw12mxaxlfsnbw"))))
6941       (build-system asdf-build-system/sbcl)
6942       (inputs
6943        `(("alexandria" ,sbcl-alexandria)
6944          ("trivia" ,sbcl-trivia)
6945          ("trivia.quasiquote" ,sbcl-trivia.quasiquote)
6946          ("split-sequence" ,sbcl-split-sequence)
6947          ("string-case" ,sbcl-string-case)
6948          ("parse-number" ,sbcl-parse-number)
6949          ("trivial-garbage" ,sbcl-trivial-garbage)
6950          ("bordeaux-threads" ,sbcl-bordeaux-threads)
6951          ("named-readtables" ,sbcl-named-readtables)
6952          ("fare-quasiquote-extras" ,cl-fare-quasiquote-extras)
6953          ("parse-declarations-1.0" ,sbcl-parse-declarations)
6954          ("global-vars" ,sbcl-global-vars)
6955          ("trivial-file-size" ,sbcl-trivial-file-size)
6956          ("trivial-macroexpand-all" ,sbcl-trivial-macroexpand-all)))
6957       (native-inputs
6958        `(("fiveam" ,sbcl-fiveam)
6959          ("local-time" ,sbcl-local-time)))
6960       (arguments
6961        '(#:phases
6962          (modify-phases %standard-phases
6963            (add-after 'unpack 'disable-failing-tests
6964              (lambda* (#:key inputs #:allow-other-keys)
6965                (substitute* "serapeum.asd"
6966                  ;; Guix does not have Quicklisp, and probably never will.
6967                  (("\\(:file \"quicklisp\"\\)") ""))
6968                #t)))))
6969       (synopsis "Common Lisp utility library beyond Alexandria")
6970       (description
6971        "Serapeum is a conservative library of Common Lisp utilities.  It is a
6972 supplement, not a competitor, to Alexandria.")
6973       (license license:expat))))
6974
6975 (define-public cl-serapeum
6976   (sbcl-package->cl-source-package sbcl-serapeum))
6977
6978 (define-public sbcl-arrows
6979   (let ((commit "df7cf0067e0132d9697ac8b1a4f1b9c88d4f5382")
6980         (revision "0"))
6981     (package
6982       (name "sbcl-arrows")
6983       (version (git-version "0.2.0" revision commit))
6984       (source
6985        (origin
6986          (method git-fetch)
6987          (uri (git-reference
6988                (url "https://gitlab.com/Harleqin/arrows.git")
6989                (commit commit)))
6990          (file-name (git-file-name name version))
6991          (sha256
6992           (base32
6993            "042k9vkssrqx9nhp14wdzm942zgdxvp35mba0p2syz98i75im2yy"))))
6994       (build-system asdf-build-system/sbcl)
6995       (native-inputs
6996        `(("hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
6997       (synopsis "Clojure-like arrow macros for Common Lisp")
6998       (description
6999        "This library implements the @code{->} and @code{->>} macros from
7000 Clojure, as well as several expansions on the idea.")
7001       (home-page "https://gitlab.com/Harleqin/arrows")
7002       (license license:public-domain))))
7003
7004 (define-public cl-arrows
7005   (sbcl-package->cl-source-package sbcl-arrows))
7006
7007 (define-public ecl-arrows
7008   (sbcl-package->ecl-package sbcl-arrows))
7009
7010 (define-public sbcl-simple-parallel-tasks
7011   (let ((commit "db460f7a3f7bbfe2d3a2223ed21e162068d04dda")
7012         (revision "0"))
7013     (package
7014       (name "sbcl-simple-parallel-tasks")
7015       (version (git-version "1.0" revision commit))
7016       (source
7017        (origin
7018          (method git-fetch)
7019          (uri (git-reference
7020                (url "https://github.com/glv2/simple-parallel-tasks.git")
7021                (commit commit)))
7022          (file-name (git-file-name name version))
7023          (sha256
7024           (base32
7025            "0amw3qk23wnlyrsgzszs6rs7y4zvxv8dr03rnqhc60mnm8ds4dd5"))))
7026       (build-system asdf-build-system/sbcl)
7027       (native-inputs
7028        `(("fiveam" ,sbcl-fiveam)))
7029       (inputs
7030        `(("chanl" ,sbcl-chanl)))
7031       (synopsis "Common Lisp library to evaluate some forms in parallel")
7032       (description "This is a simple Common Lisp library to evaluate some
7033 forms in parallel.")
7034       (home-page "https://github.com/glv2/simple-parallel-tasks")
7035       (license license:gpl3))))
7036
7037 (define-public cl-simple-parallel-tasks
7038   (sbcl-package->cl-source-package sbcl-simple-parallel-tasks))
7039
7040 (define-public ecl-simple-parallel-tasks
7041   (sbcl-package->ecl-package sbcl-simple-parallel-tasks))
7042
7043 (define-public sbcl-cl-heap
7044   (package
7045     (name "sbcl-cl-heap")
7046     (version "0.1.6")
7047     (source
7048      (origin
7049        (method url-fetch)
7050        (uri (string-append "https://common-lisp.net/project/cl-heap/releases/"
7051                            "cl-heap_" version ".tar.gz"))
7052        (sha256
7053         (base32
7054          "163hb07p2nxz126rpq3cj5dyala24n0by5i5786n2qcr1w0bak4i"))))
7055     (build-system asdf-build-system/sbcl)
7056     (native-inputs
7057      `(("xlunit" ,sbcl-xlunit)))
7058     (arguments
7059      `(#:test-asd-file "cl-heap-tests.asd"))
7060     (synopsis "Heap and priority queue data structures for Common Lisp")
7061     (description
7062      "CL-HEAP provides various implementations of heap data structures (a
7063 binary heap and a Fibonacci heap) as well as an efficient priority queue.")
7064     (home-page "https://common-lisp.net/project/cl-heap/")
7065     (license license:gpl3+)))
7066
7067 (define-public cl-heap
7068   (sbcl-package->cl-source-package sbcl-cl-heap))
7069
7070 (define-public ecl-cl-heap
7071   (sbcl-package->ecl-package sbcl-cl-heap))
7072
7073 (define-public sbcl-curry-compose-reader-macros
7074   (let ((commit "beaa92dedf392726c042184bfd6149fa8d9e6ac2")
7075         (revision "0"))
7076     (package
7077       (name "sbcl-curry-compose-reader-macros")
7078       (version (git-version "1.0.0" revision commit))
7079       (source
7080        (origin
7081          (method git-fetch)
7082          (uri
7083           (git-reference
7084            (url "https://github.com/eschulte/curry-compose-reader-macros.git")
7085            (commit commit)))
7086          (file-name (git-file-name name version))
7087          (sha256
7088           (base32
7089            "0rv9bl8xrad5wfcg5zs1dazvnpmvqz6297lbn8bywsrcfnlf7h98"))))
7090       (build-system asdf-build-system/sbcl)
7091       (inputs
7092        `(("alexandria" ,sbcl-alexandria)
7093          ("named-readtables" ,sbcl-named-readtables)))
7094       (synopsis "Reader macros for partial application and composition")
7095       (description
7096        "This Common Lisp library provides reader macros for concise expression
7097 of function partial application and composition.")
7098       (home-page "https://eschulte.github.io/curry-compose-reader-macros/")
7099       (license license:public-domain))))
7100
7101 (define-public cl-curry-compose-reader-macros
7102   (sbcl-package->cl-source-package sbcl-curry-compose-reader-macros))
7103
7104 (define-public ecl-curry-compose-reader-macros
7105   (sbcl-package->ecl-package sbcl-curry-compose-reader-macros))
7106
7107 (define-public sbcl-yason
7108   (package
7109     (name "sbcl-yason")
7110     (version "0.7.7")
7111     (source
7112      (origin
7113        (method git-fetch)
7114        (uri (git-reference
7115              (url "https://github.com/phmarek/yason.git")
7116              (commit (string-append "v" version))))
7117        (file-name (git-file-name name version))
7118        (sha256
7119         (base32
7120          "0479rbjgbj80jpk5bby18inlv1kfp771a82rlcq5psrz65qqa9bj"))))
7121     (build-system asdf-build-system/sbcl)
7122     (inputs
7123      `(("alexandria" ,sbcl-alexandria)
7124        ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
7125     (synopsis "Common Lisp JSON parser/encoder")
7126     (description
7127      "YASON is a Common Lisp library for encoding and decoding data in the
7128 JSON interchange format.")
7129     (home-page "https://github.com/phmarek/yason")
7130     (license license:bsd-3)))
7131
7132 (define-public cl-yason
7133   (sbcl-package->cl-source-package sbcl-yason))
7134
7135 (define-public ecl-yason
7136   (sbcl-package->ecl-package sbcl-yason))
7137
7138 (define-public sbcl-stefil
7139   (let ((commit "0398548ec95dceb50fc2c2c03e5fb0ce49b86c7a")
7140         (revision "0"))
7141     (package
7142       (name "sbcl-stefil")
7143       (version (git-version "0.1" revision commit))
7144       (source
7145        (origin
7146          (method git-fetch)
7147          (uri (git-reference
7148                (url "https://gitlab.common-lisp.net/stefil/stefil.git")
7149                (commit commit)))
7150          (file-name (git-file-name name version))
7151          (sha256
7152           (base32
7153            "0bqz64q2szzhf91zyqyssmvrz7da6442rs01808pf3wrdq28bclh"))))
7154       (build-system asdf-build-system/sbcl)
7155       (inputs
7156        `(("alexandria" ,sbcl-alexandria)
7157          ("iterate" ,sbcl-iterate)
7158          ("metabang-bind" ,sbcl-metabang-bind)))
7159       (propagated-inputs
7160        ;; Swank doesn't have a pre-compiled package, therefore we must
7161        ;; propagate its sources.
7162        `(("swank" ,cl-slime-swank)))
7163       (arguments
7164        '(#:phases
7165          (modify-phases %standard-phases
7166            (add-after 'unpack 'drop-unnecessary-dependency
7167              (lambda _
7168                (substitute* "package.lisp"
7169                  ((":stefil-system") ""))
7170                #t)))))
7171       (home-page "https://common-lisp.net/project/stefil/index-old.shtml")
7172       (synopsis "Simple test framework")
7173       (description
7174        "Stefil is a simple test framework for Common Lisp, with a focus on
7175 interactive development.")
7176       (license license:public-domain))))
7177
7178 (define-public cl-stefil
7179   (sbcl-package->cl-source-package sbcl-stefil))
7180
7181 (define-public sbcl-graph
7182   (let ((commit "78bf9ec930d8eae4f0861b5be76765fb1e45e24f")
7183         (revision "0"))
7184     (package
7185       (name "sbcl-graph")
7186       (version (git-version "0.0.0" revision commit))
7187       (source
7188        (origin
7189          (method git-fetch)
7190          (uri
7191           (git-reference
7192            (url "https://github.com/eschulte/graph.git")
7193            (commit commit)))
7194          (file-name (git-file-name name version))
7195          (sha256
7196           (base32
7197            "1qpij4xh8bqwc2myahpilcbh916v7vg0acz2fij14d3y0jm02h0g"))
7198          (patches (search-patches "sbcl-graph-asdf-definitions.patch"))))
7199       (build-system asdf-build-system/sbcl)
7200       (native-inputs
7201        `(("stefil" ,sbcl-stefil)))
7202       (inputs
7203        `(("alexandria" ,sbcl-alexandria)
7204          ("cl-heap" ,sbcl-cl-heap)
7205          ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
7206          ("metabang-bind" ,sbcl-metabang-bind)
7207          ("named-readtables" ,sbcl-named-readtables)))
7208       (arguments
7209        '(#:test-asd-file "graph.test.asd"))
7210       (synopsis "Graph data structure and algorithms for Common Lisp")
7211       (description
7212        "The GRAPH Common Lisp library provides a data structures to represent
7213 graphs, as well as some graph manipulation and analysis algorithms (shortest
7214 path, maximum flow, minimum spanning tree, etc.).")
7215       (home-page "https://eschulte.github.io/graph/")
7216       (license license:gpl3+))))
7217
7218 (define-public cl-graph
7219   (sbcl-package->cl-source-package sbcl-graph))
7220
7221 (define-public sbcl-graph-dot
7222   (package
7223     (inherit sbcl-graph)
7224     (name "sbcl-graph-dot")
7225     (inputs
7226      `(("alexandria" ,sbcl-alexandria)
7227        ("cl-ppcre" ,sbcl-cl-ppcre)
7228        ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
7229        ("graph" ,sbcl-graph)
7230        ("metabang-bind" ,sbcl-metabang-bind)
7231        ("named-readtables" ,sbcl-named-readtables)))
7232     (arguments
7233      (substitute-keyword-arguments (package-arguments sbcl-graph)
7234        ((#:asd-file _ "") "graph.dot.asd")
7235        ((#:asd-system-name _ #f) "graph-dot")))
7236     (synopsis "Serialize graphs to and from DOT format")))
7237
7238 (define-public sbcl-graph-json
7239   (package
7240     (inherit sbcl-graph)
7241     (name "sbcl-graph-json")
7242     (inputs
7243      `(("alexandria" ,sbcl-alexandria)
7244        ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
7245        ("graph" ,sbcl-graph)
7246        ("metabang-bind" ,sbcl-metabang-bind)
7247        ("named-readtables" ,sbcl-named-readtables)
7248        ("yason" ,sbcl-yason)))
7249     (arguments
7250      (substitute-keyword-arguments (package-arguments sbcl-graph)
7251        ((#:asd-file _ "") "graph.json.asd")
7252        ((#:asd-system-name _ #f) "graph-json")))
7253     (synopsis "Serialize graphs to and from JSON format")))
7254
7255 (define-public sbcl-trivial-indent
7256   (let ((commit "2d016941751647c6cc5bd471751c2cf68861c94a")
7257         (revision "0"))
7258     (package
7259       (name "sbcl-trivial-indent")
7260       (version (git-version "1.0.0" revision commit))
7261       (source
7262        (origin
7263          (method git-fetch)
7264          (uri
7265           (git-reference
7266            (url "https://github.com/Shinmera/trivial-indent")
7267            (commit commit)))
7268          (file-name (git-file-name name version))
7269          (sha256
7270           (base32
7271            "1sj90nqz17w4jq0ixz00gb9g5g6d2s7l8r17zdby27gxxh51w266"))))
7272       (build-system asdf-build-system/sbcl)
7273       (synopsis "Simple Common Lisp library to allow indentation hints for SWANK")
7274       (description
7275        "This library allows you to define custom indentation hints for your
7276 macros if the one recognised by SLIME automatically produces unwanted
7277 results.")
7278       (home-page "https://shinmera.github.io/trivial-indent/")
7279       (license license:zlib))))
7280
7281 (define-public cl-trivial-indent
7282   (sbcl-package->cl-source-package sbcl-trivial-indent))
7283
7284 (define-public sbcl-documentation-utils
7285   (let ((commit "98630dd5f7e36ae057fa09da3523f42ccb5d1f55")
7286         (revision "0"))
7287     (package
7288       (name "sbcl-documentation-utils")
7289       (version (git-version "1.2.0" revision commit))
7290       (source
7291        (origin
7292          (method git-fetch)
7293          (uri
7294           (git-reference
7295            (url "https://github.com/Shinmera/documentation-utils.git")
7296            (commit commit)))
7297          (file-name (git-file-name name version))
7298          (sha256
7299           (base32
7300            "098qhkqskmmrh4wix34mawf7p5c87yql28r51r75yjxj577k5idq"))))
7301       (build-system asdf-build-system/sbcl)
7302       (inputs
7303        `(("trivial-indent" ,sbcl-trivial-indent)))
7304       (synopsis "Few simple tools to document Common Lisp libraries")
7305       (description
7306        "This is a small library to help you with managing the Common Lisp
7307 docstrings for your library.")
7308       (home-page "https://shinmera.github.io/documentation-utils/")
7309       (license license:zlib))))
7310
7311 (define-public cl-documentation-utils
7312   (sbcl-package->cl-source-package sbcl-documentation-utils))
7313
7314 (define-public sbcl-form-fiddle
7315   (let ((commit "e0c23599dbb8cff3e83e012f3d86d0764188ad18")
7316         (revision "0"))
7317     (package
7318       (name "sbcl-form-fiddle")
7319       (version (git-version "1.1.0" revision commit))
7320       (source
7321        (origin
7322          (method git-fetch)
7323          (uri
7324           (git-reference
7325            (url "https://github.com/Shinmera/form-fiddle")
7326            (commit commit)))
7327          (file-name (git-file-name name version))
7328          (sha256
7329           (base32
7330            "041iznc9mpfyrl0sv5893ys9pbb2pvbn9g3clarqi7gsfj483jln"))))
7331       (build-system asdf-build-system/sbcl)
7332       (inputs
7333        `(("documentation-utils" ,sbcl-documentation-utils)))
7334       (synopsis "Utilities to destructure Common Lisp lambda forms")
7335       (description
7336        "Often times we need to destructure a form definition in a Common Lisp
7337 macro.  This library provides a set of simple utilities to help with that.")
7338       (home-page "https://shinmera.github.io/form-fiddle/")
7339       (license license:zlib))))
7340
7341 (define-public cl-form-fiddle
7342   (sbcl-package->cl-source-package sbcl-form-fiddle))