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