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, 2020 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 ;;; Copyright © 2020 Konrad Hinsen <konrad.hinsen@fastmail.net>
  20 ;;; Copyright © 2020 Dimakis Dimakakos <me@bendersteed.tech>
  21 ;;; Copyright © 2020 Oleg Pykhalov <go.wigust@gmail.com>
  22 ;;;
  23 ;;; This file is part of GNU Guix.
  24 ;;;
  25 ;;; GNU Guix is free software; you can redistribute it and/or modify it
  26 ;;; under the terms of the GNU General Public License as published by
  27 ;;; the Free Software Foundation; either version 3 of the License, or (at
  28 ;;; your option) any later version.
  29 ;;;
  30 ;;; GNU Guix is distributed in the hope that it will be useful, but
  31 ;;; WITHOUT ANY WARRANTY; without even the implied warranty of
  32 ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  33 ;;; GNU General Public License for more details.
  34 ;;;
  35 ;;; You should have received a copy of the GNU General Public License
  36 ;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.
  37
  38 ;;; This file only contains Common Lisp libraries.
  39 ;;; Common Lisp compilers and tooling go to lisp.scm.
  40 ;;; Common Lisp applications should go to the most appropriate file,
  41 ;;; e.g. StumpWM is in wm.scm.
  42
  43 (define-module (gnu packages lisp-xyz)
  44   #:use-module (gnu packages)
  45   #:use-module ((guix licenses) #:prefix license:)
  46   #:use-module (guix packages)
  47   #:use-module (guix download)
  48   #:use-module (guix git-download)
  49   #:use-module (guix hg-download)
  50   #:use-module (guix utils)
  51   #:use-module (guix build-system asdf)
  52   #:use-module (guix build-system trivial)
  53   #:use-module (gnu packages c)
  54   #:use-module (gnu packages compression)
  55   #:use-module (gnu packages databases)
  56   #:use-module (gnu packages enchant)
  57   #:use-module (gnu packages glib)
  58   #:use-module (gnu packages gtk)
  59   #:use-module (gnu packages imagemagick)
  60   #:use-module (gnu packages libevent)
  61   #:use-module (gnu packages libffi)
  62   #:use-module (gnu packages lisp)
  63   #:use-module (gnu packages maths)
  64   #:use-module (gnu packages networking)
  65   #:use-module (gnu packages pkg-config)
  66   #:use-module (gnu packages python)
  67   #:use-module (gnu packages python-xyz)
  68   #:use-module (gnu packages sqlite)
  69   #:use-module (gnu packages tcl)
  70   #:use-module (gnu packages tls)
  71   #:use-module (gnu packages webkit)
  72   #:use-module (gnu packages xdisorg)
  73   #:use-module (ice-9 match)
  74   #:use-module (srfi srfi-19))
  75
  76 (define-public sbcl-alexandria
  77   (let ((revision "1")
  78         (commit "3b849bc0116ea70f215ee6b2fbf354e862aaa9dd"))
  79     (package
  80       (name "sbcl-alexandria")
  81       (version (git-version "1.0.0" revision commit))
  82       (source
  83        (origin
  84          (method git-fetch)
  85          (uri (git-reference
  86                (url "https://gitlab.common-lisp.net/alexandria/alexandria.git")
  87                (commit commit)))
  88          (sha256
  89           (base32
  90            "04amwvx2vl691f0plcfbqqwxgib9zimih7jrn5zl7mbwvrxy022b"))
  91          (file-name (git-file-name name version))))
  92       (build-system asdf-build-system/sbcl)
  93       (native-inputs
  94        `(("rt" ,sbcl-rt)))
  95       (synopsis "Collection of portable utilities for Common Lisp")
  96       (description
  97        "Alexandria is a collection of portable utilities.  It does not contain
  98 conceptual extensions to Common Lisp.  It is conservative in scope, and
  99 portable between implementations.")
 100       (home-page "https://common-lisp.net/project/alexandria/")
 101       (license license:public-domain))))
 102
 103 (define-public cl-alexandria
 104   (sbcl-package->cl-source-package sbcl-alexandria))
 105
 106 (define-public ecl-alexandria
 107   (sbcl-package->ecl-package sbcl-alexandria))
 108
 109 (define-public sbcl-net.didierverna.asdf-flv
 110   (package
 111     (name "sbcl-net.didierverna.asdf-flv")
 112     (version "2.1")
 113     (source
 114      (origin
 115        (method git-fetch)
 116        (uri (git-reference
 117              (url "https://github.com/didierverna/asdf-flv")
 118              (commit (string-append "version-" version))))
 119        (file-name (git-file-name "asdf-flv" version))
 120        (sha256
 121         (base32 "1fi2y4baxan103jbg4idjddzihy03kwnj2mzbwrknw4d4x7xlgwj"))))
 122     (build-system asdf-build-system/sbcl)
 123     (synopsis "Common Lisp ASDF extension to provide support for file-local variables")
 124     (description "ASDF-FLV provides support for file-local variables through
 125 ASDF.  A file-local variable behaves like @code{*PACKAGE*} and
 126 @code{*READTABLE*} with respect to @code{LOAD} and @code{COMPILE-FILE}: a new
 127 dynamic binding is created before processing the file, so that any
 128 modification to the variable becomes essentially file-local.
 129
 130 In order to make one or several variables file-local, use the macros
 131 @code{SET-FILE-LOCAL-VARIABLE(S)}.")
 132     (home-page "https://www.lrde.epita.fr/~didier/software/lisp/misc.php#asdf-flv")
 133     (license (license:non-copyleft
 134               "https://www.gnu.org/prep/maintain/html_node/License-Notices-for-Other-Files.html"
 135               "GNU All-Permissive License"))))
 136
 137 (define-public cl-net.didierverna.asdf-flv
 138   (sbcl-package->cl-source-package sbcl-net.didierverna.asdf-flv))
 139
 140 (define-public ecl-net.didierverna.asdf-flv
 141   (sbcl-package->ecl-package sbcl-net.didierverna.asdf-flv))
 142
 143 (define-public sbcl-fiveam
 144   (package
 145     (name "sbcl-fiveam")
 146     (version "1.4.1")
 147     (source
 148      (origin
 149        (method git-fetch)
 150        (uri (git-reference
 151              (url "https://github.com/sionescu/fiveam.git")
 152              (commit (string-append "v" version))))
 153        (file-name (git-file-name "fiveam" version))
 154        (sha256
 155         (base32 "1q3d38pwafnwnw42clq0f8g5xw7pbzr287jl9jsqmb1vb0n1vrli"))))
 156     (inputs
 157      `(("alexandria" ,sbcl-alexandria)
 158        ("net.didierverna.asdf-flv" ,sbcl-net.didierverna.asdf-flv)
 159        ("trivial-backtrace" ,sbcl-trivial-backtrace)))
 160     (build-system asdf-build-system/sbcl)
 161     (synopsis "Common Lisp testing framework")
 162     (description "FiveAM is a simple (as far as writing and running tests
 163 goes) regression testing framework.  It has been designed with Common Lisp's
 164 interactive development model in mind.")
 165     (home-page "https://common-lisp.net/project/fiveam/")
 166     (license license:bsd-3)))
 167
 168 (define-public cl-fiveam
 169   (sbcl-package->cl-source-package sbcl-fiveam))
 170
 171 (define-public ecl-fiveam
 172   (sbcl-package->ecl-package sbcl-fiveam))
 173
 174 (define-public sbcl-bordeaux-threads
 175   (package
 176     (name "sbcl-bordeaux-threads")
 177     (version "0.8.7")
 178     (source (origin
 179               (method git-fetch)
 180               (uri (git-reference
 181                     (url "https://github.com/sionescu/bordeaux-threads.git")
 182                     (commit (string-append "v" version))))
 183               (sha256
 184                (base32 "1whpfmyxp2fsw6viqj45fqgsifgr534c575bfh5vaqw5m84b6alp"))
 185               (file-name
 186                (git-file-name "bordeaux-threads" version))))
 187     (inputs `(("alexandria" ,sbcl-alexandria)))
 188     (native-inputs `(("fiveam" ,sbcl-fiveam)))
 189     (build-system asdf-build-system/sbcl)
 190     (synopsis "Portable shared-state concurrency library for Common Lisp")
 191     (description "BORDEAUX-THREADS is a proposed standard for a minimal
 192 MP/Threading interface.  It is similar to the CLIM-SYS threading and lock
 193 support.")
 194     (home-page "https://common-lisp.net/project/bordeaux-threads/")
 195     (license license:x11)))
 196
 197 (define-public cl-bordeaux-threads
 198   (sbcl-package->cl-source-package sbcl-bordeaux-threads))
 199
 200 (define-public ecl-bordeaux-threads
 201   (sbcl-package->ecl-package sbcl-bordeaux-threads))
 202
 203 (define-public sbcl-trivial-gray-streams
 204   (let ((revision "1")
 205         (commit "0483ade330508b4b2edeabdb47d16ec9437ee1cb"))
 206     (package
 207       (name "sbcl-trivial-gray-streams")
 208       (version (string-append "0.0.0-" revision "." (string-take commit 7)))
 209       (source
 210        (origin
 211          (method git-fetch)
 212          (uri
 213           (git-reference
 214            (url "https://github.com/trivial-gray-streams/trivial-gray-streams.git")
 215            (commit commit)))
 216          (sha256
 217           (base32 "0m3rpf2x0zmdk3nf1qfa01j6a55vj7gkwhyw78qslcgbjlgh8p4d"))
 218          (file-name
 219           (string-append "trivial-gray-streams-" version "-checkout"))))
 220       (build-system asdf-build-system/sbcl)
 221       (synopsis "Compatibility layer for Gray streams implementations")
 222       (description "Gray streams is an interface proposed for inclusion with
 223 ANSI CL by David N. Gray.  The proposal did not make it into ANSI CL, but most
 224 popular CL implementations implement it.  This package provides an extremely
 225 thin compatibility layer for gray streams.")
 226       (home-page "https://www.cliki.net/trivial-gray-streams")
 227       (license license:x11))))
 228
 229 (define-public cl-trivial-gray-streams
 230   (sbcl-package->cl-source-package sbcl-trivial-gray-streams))
 231
 232 (define-public ecl-trivial-gray-streams
 233   (sbcl-package->ecl-package sbcl-trivial-gray-streams))
 234
 235 (define-public sbcl-fiasco
 236   (let ((commit "d62f7558b21addc89f87e306f65d7f760632655f")
 237         (revision "1"))
 238     (package
 239       (name "sbcl-fiasco")
 240       (version (git-version "0.0.1" revision commit))
 241       (source
 242        (origin
 243          (method git-fetch)
 244          (uri (git-reference
 245                (url "https://github.com/joaotavora/fiasco.git")
 246                (commit commit)))
 247          (file-name (git-file-name "fiasco" version))
 248          (sha256
 249           (base32
 250            "1zwxs3d6iswayavcmb49z2892xhym7n556d8dnmvalc32pm9bkjh"))))
 251       (build-system asdf-build-system/sbcl)
 252       (inputs
 253        `(("alexandria" ,sbcl-alexandria)
 254          ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
 255       (synopsis "Simple and powerful test framework for Common Lisp")
 256       (description "A Common Lisp test framework that treasures your failures,
 257 logical continuation of Stefil.  It focuses on interactive debugging.")
 258       (home-page "https://github.com/joaotavora/fiasco")
 259       ;; LICENCE specifies this is public-domain unless the legislation
 260       ;; doesn't allow or recognize it.  In that case it falls back to a
 261       ;; permissive licence.
 262       (license (list license:public-domain
 263                      (license:x11-style "file://LICENCE"))))))
 264
 265 (define-public cl-fiasco
 266   (sbcl-package->cl-source-package sbcl-fiasco))
 267
 268 (define-public ecl-fiasco
 269   (sbcl-package->ecl-package sbcl-fiasco))
 270
 271 (define-public sbcl-flexi-streams
 272   (package
 273     (name "sbcl-flexi-streams")
 274     (version "1.0.18")
 275     (source
 276      (origin
 277        (method git-fetch)
 278        (uri (git-reference
 279              (url "https://github.com/edicl/flexi-streams.git")
 280              (commit (string-append "v" version))))
 281        (file-name (git-file-name "flexi-streams" version))
 282        (sha256
 283         (base32 "0bjv7fd2acknidc5dyi3h85pn10krxv5jyxs1xg8jya2rlfv7f1j"))))
 284     (build-system asdf-build-system/sbcl)
 285     (arguments
 286      `(#:phases
 287        (modify-phases %standard-phases
 288          (add-after 'unpack 'make-git-checkout-writable
 289            (lambda _
 290              (for-each make-file-writable (find-files "."))
 291              #t)))))
 292     (inputs `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
 293     (synopsis "Implementation of virtual bivalent streams for Common Lisp")
 294     (description "Flexi-streams is an implementation of \"virtual\" bivalent
 295 streams that can be layered atop real binary or bivalent streams and that can
 296 be used to read and write character data in various single- or multi-octet
 297 encodings which can be changed on the fly.  It also supplies in-memory binary
 298 streams which are similar to string streams.")
 299     (home-page "http://weitz.de/flexi-streams/")
 300     (license license:bsd-3)))
 301
 302 (define-public cl-flexi-streams
 303   (sbcl-package->cl-source-package sbcl-flexi-streams))
 304
 305 (define-public ecl-flexi-streams
 306   (sbcl-package->ecl-package sbcl-flexi-streams))
 307
 308 (define-public sbcl-cl-ppcre
 309   (package
 310     (name "sbcl-cl-ppcre")
 311     (version "2.1.1")
 312     (source
 313      (origin
 314        (method git-fetch)
 315        (uri (git-reference
 316              (url "https://github.com/edicl/cl-ppcre.git")
 317              (commit (string-append "v" version))))
 318        (file-name (git-file-name "cl-ppcre" version))
 319        (sha256
 320         (base32 "0dwvr29diqzcg5n6jvbk2rnd90i05l7n828hhw99khmqd0kz7xsi"))))
 321     (build-system asdf-build-system/sbcl)
 322     (native-inputs `(("flexi-streams" ,sbcl-flexi-streams)))
 323     (synopsis "Portable regular expression library for Common Lisp")
 324     (description "CL-PPCRE is a portable regular expression library for Common
 325 Lisp, which is compatible with perl.  It is pretty fast, thread-safe, and
 326 compatible with ANSI-compliant Common Lisp implementations.")
 327     (home-page "http://weitz.de/cl-ppcre/")
 328     (license license:bsd-2)))
 329
 330 (define-public cl-ppcre
 331   (sbcl-package->cl-source-package sbcl-cl-ppcre))
 332
 333 (define-public ecl-cl-ppcre
 334   (sbcl-package->ecl-package sbcl-cl-ppcre))
 335
 336 (define sbcl-cl-unicode-base
 337   (package
 338     (name "sbcl-cl-unicode-base")
 339     (version "0.1.6")
 340     (source (origin
 341               (method git-fetch)
 342               (uri (git-reference
 343                     (url "https://github.com/edicl/cl-unicode.git")
 344                     (commit (string-append "v" version))))
 345               (file-name (git-file-name name version))
 346               (sha256
 347                (base32
 348                 "0ykx2s9lqfl74p1px0ik3l2izd1fc9jd1b4ra68s5x34rvjy0hza"))))
 349     (build-system asdf-build-system/sbcl)
 350     (arguments
 351      '(#:asd-file "cl-unicode.asd"
 352        #:asd-system-name "cl-unicode/base"))
 353     (inputs
 354      `(("cl-ppcre" ,sbcl-cl-ppcre)))
 355     (home-page "http://weitz.de/cl-unicode/")
 356     (synopsis "Portable Unicode library for Common Lisp")
 357     (description "CL-UNICODE is a portable Unicode library Common Lisp, which
 358 is compatible with perl.  It is pretty fast, thread-safe, and compatible with
 359 ANSI-compliant Common Lisp implementations.")
 360     (license license:bsd-2)))
 361
 362 (define-public sbcl-cl-unicode
 363   (package
 364     (inherit sbcl-cl-unicode-base)
 365     (name "sbcl-cl-unicode")
 366     (inputs
 367      `(("cl-unicode/base" ,sbcl-cl-unicode-base)
 368        ,@(package-inputs sbcl-cl-unicode-base)))
 369     (native-inputs
 370      `(("flexi-streams" ,sbcl-flexi-streams)))
 371     (arguments '())))
 372
 373 (define-public ecl-cl-unicode
 374   (sbcl-package->ecl-package sbcl-cl-unicode))
 375
 376 (define-public cl-unicode
 377   (sbcl-package->cl-source-package sbcl-cl-unicode))
 378
 379 (define-public sbcl-zpb-ttf
 380   (package
 381     (name "sbcl-zpb-ttf")
 382     (version "1.0.3")
 383     (source
 384      (origin
 385        (method git-fetch)
 386        (uri (git-reference
 387              (url "https://github.com/xach/zpb-ttf.git")
 388              (commit (string-append "release-" version))))
 389        (file-name (git-file-name name version))
 390        (sha256
 391         (base32
 392          "1wh66vjijzqlydnrihynpwp6796917xwrh0i9li93c17kyxa74ih"))))
 393     (build-system asdf-build-system/sbcl)
 394     (home-page "https://github.com/xach/zpb-ttf")
 395     (synopsis "TrueType font file access for Common Lisp")
 396     (description
 397      "ZPB-TTF is a TrueType font file parser that provides an interface for
 398 reading typographic metrics, glyph outlines, and other information from the
 399 file.")
 400     (license license:bsd-2)))
 401
 402 (define-public ecl-zpb-ttf
 403   (sbcl-package->ecl-package sbcl-zpb-ttf))
 404
 405 (define-public cl-zpb-ttf
 406   (sbcl-package->cl-source-package sbcl-zpb-ttf))
 407
 408 (define-public sbcl-cl-aa
 409   (package
 410     (name "sbcl-cl-aa")
 411     (version "0.1.5")
 412     (source
 413      (origin
 414        (method url-fetch)
 415        (uri (string-append "http://projects.tuxee.net/cl-vectors/"
 416                            "files/cl-vectors-" version ".tar.gz"))
 417        (sha256
 418         (base32
 419          "04lhwi0kq8pkwhgd885pk80m1cp9sfvjjn5zj70s1dnckibhdmqh"))))
 420     (build-system asdf-build-system/sbcl)
 421     (arguments '(#:asd-file "cl-aa.asd"))
 422     (home-page "http://projects.tuxee.net/cl-vectors/")
 423     (synopsis "Polygon rasterizer")
 424     (description
 425      "This is a Common Lisp library implementing the AA polygon rasterization
 426 algorithm from the @url{http://antigrain.com, Antigrain} project.")
 427     (license license:expat)))
 428
 429 (define-public ecl-cl-aa
 430   (sbcl-package->ecl-package sbcl-cl-aa))
 431
 432 (define-public cl-aa
 433   (sbcl-package->cl-source-package sbcl-cl-aa))
 434
 435 (define-public sbcl-cl-paths
 436   (package
 437     (inherit sbcl-cl-aa)
 438     (name "sbcl-cl-paths")
 439     (arguments '(#:asd-file "cl-paths.asd"))
 440     (synopsis "Facilities to create and manipulate vectorial paths")
 441     (description
 442      "This package provides facilities to create and manipulate vectorial
 443 paths.")))
 444
 445 (define-public ecl-cl-paths
 446   (sbcl-package->ecl-package sbcl-cl-paths))
 447
 448 (define-public cl-paths
 449   (sbcl-package->cl-source-package sbcl-cl-paths))
 450
 451 (define-public sbcl-cl-paths-ttf
 452   (package
 453     (inherit sbcl-cl-aa)
 454     (name "sbcl-cl-paths-ttf")
 455     (arguments '(#:asd-file "cl-paths-ttf.asd"))
 456     (inputs
 457      `(("cl-paths" ,sbcl-cl-paths)
 458        ("zpb-ttf" ,sbcl-zpb-ttf)))
 459     (synopsis "Facilities to create and manipulate vectorial paths")
 460     (description
 461      "This package provides facilities to create and manipulate vectorial
 462 paths.")))
 463
 464 (define-public ecl-cl-paths-ttf
 465   (sbcl-package->ecl-package sbcl-cl-paths-ttf))
 466
 467 (define-public cl-paths-ttf
 468   (sbcl-package->cl-source-package sbcl-cl-paths-ttf))
 469
 470 (define-public sbcl-cl-vectors
 471   (package
 472     (inherit sbcl-cl-aa)
 473     (name "sbcl-cl-vectors")
 474     (arguments '(#:asd-file "cl-vectors.asd"))
 475     (inputs
 476      `(("cl-aa" ,sbcl-cl-aa)
 477        ("cl-paths" ,sbcl-cl-paths)))
 478     (synopsis "Create, transform and render anti-aliased vectorial paths")
 479     (description
 480      "This is a pure Common Lisp library to create, transform and render
 481 anti-aliased vectorial paths.")))
 482
 483 (define-public ecl-cl-vectors
 484   (sbcl-package->ecl-package sbcl-cl-vectors))
 485
 486 (define-public cl-vectors
 487   (sbcl-package->cl-source-package sbcl-cl-vectors))
 488
 489 (define-public sbcl-spatial-trees
 490   ;; There have been no releases.
 491   (let ((commit "81fdad0a0bf109c80a53cc96eca2e093823400ba")
 492         (revision "1"))
 493     (package
 494       (name "sbcl-spatial-trees")
 495       (version (git-version "0" revision commit))
 496       (source
 497        (origin
 498          (method git-fetch)
 499          (uri (git-reference
 500                (url "https://github.com/rpav/spatial-trees.git")
 501                (commit commit)))
 502          (file-name (git-file-name name version))
 503          (sha256
 504           (base32
 505            "11rhc6h501dwcik2igkszz7b9n515cr99m5pjh4r2qfwgiri6ysa"))))
 506       (build-system asdf-build-system/sbcl)
 507       (arguments
 508        '(#:tests? #f           ; spatial-trees.test requires spatial-trees.nns
 509          #:asd-file "spatial-trees.asd"
 510          #:test-asd-file "spatial-trees.test.asd"))
 511       (native-inputs
 512        `(("fiveam" ,sbcl-fiveam)))
 513       (home-page "https://github.com/rpav/spatial-trees")
 514       (synopsis "Dynamic index data structures for spatially-extended data")
 515       (description
 516        "Spatial-trees is a set of dynamic index data structures for
 517 spatially-extended data.")
 518       (license license:bsd-3))))
 519
 520 (define-public ecl-spatial-trees
 521   (sbcl-package->ecl-package sbcl-spatial-trees))
 522
 523 (define-public cl-spatial-trees
 524   (sbcl-package->cl-source-package sbcl-spatial-trees))
 525
 526 (define-public sbcl-flexichain
 527   ;; There are no releases.
 528   (let ((commit "13d2a6c505ed0abfcd4c4ec7d7145059b06855d6")
 529         (revision "1"))
 530     (package
 531       (name "sbcl-flexichain")
 532       (version "1.5.1")
 533       (source
 534        (origin
 535          (method git-fetch)
 536          (uri (git-reference
 537                (url "https://github.com/robert-strandh/Flexichain.git")
 538                (commit commit)))
 539          (file-name (git-file-name name version))
 540          (sha256
 541           (base32
 542            "0pfyvhsfbjd2sjb30grfs52r51a428xglv7bwydvpg2lc117qimg"))))
 543       (build-system asdf-build-system/sbcl)
 544       (home-page "https://github.com/robert-strandh/Flexichain.git")
 545       (synopsis "Dynamically add elements to or remove them from sequences")
 546       (description
 547        "This package provides an implementation of the flexichain protocol,
 548 allowing client code to dynamically add elements to, and delete elements from
 549 a sequence (or chain) of such elements.")
 550       (license license:lgpl2.1+))))
 551
 552 (define-public ecl-flexichain
 553   (sbcl-package->ecl-package sbcl-flexichain))
 554
 555 (define-public cl-flexichain
 556   (sbcl-package->cl-source-package sbcl-flexichain))
 557
 558 (define-public sbcl-cl-pdf
 559   ;; There are no releases
 560   (let ((commit "752e337e6d6fc206f09d091a982e7f8e5c404e4e")
 561         (revision "1"))
 562     (package
 563       (name "sbcl-cl-pdf")
 564       (version (git-version "0" revision commit))
 565       (source
 566        (origin
 567          (method git-fetch)
 568          (uri (git-reference
 569                (url "https://github.com/mbattyani/cl-pdf.git")
 570                (commit commit)))
 571          (file-name (git-file-name name version))
 572          (sha256
 573           (base32
 574            "1cg3k3m3r11ipb8j008y8ipynj97l3xjlpi2knqc9ndmx4r3kb1r"))))
 575       (build-system asdf-build-system/sbcl)
 576       (inputs
 577        `(("iterate" ,sbcl-iterate)
 578          ("zpb-ttf" ,sbcl-zpb-ttf)))
 579       (home-page "https://github.com/mbattyani/cl-pdf")
 580       (synopsis "Common Lisp library for generating PDF files")
 581       (description
 582        "CL-PDF is a cross-platform Common Lisp library for generating PDF
 583 files.")
 584       (license license:bsd-2))))
 585
 586 (define-public ecl-cl-pdf
 587   (sbcl-package->ecl-package sbcl-cl-pdf))
 588
 589 (define-public cl-pdf
 590   (sbcl-package->cl-source-package sbcl-cl-pdf))
 591
 592 (define-public sbcl-clx
 593   (package
 594     (name "sbcl-clx")
 595     (version "0.7.5")
 596     (source
 597      (origin
 598        (method git-fetch)
 599        (uri
 600         (git-reference
 601          (url "https://github.com/sharplispers/clx.git")
 602          (commit version)))
 603        (sha256
 604         (base32
 605          "1vi67z9hpj5rr4xcmfbfwzmlcc0ah7hzhrmfid6lqdkva238v2wf"))
 606        (file-name (string-append "clx-" version))))
 607     (build-system asdf-build-system/sbcl)
 608     (native-inputs
 609      `(("fiasco" ,sbcl-fiasco)))
 610     (home-page "https://www.cliki.net/portable-clx")
 611     (synopsis "X11 client library for Common Lisp")
 612     (description "CLX is an X11 client library for Common Lisp.  The code was
 613 originally taken from a CMUCL distribution, was modified somewhat in order to
 614 make it compile and run under SBCL, then a selection of patches were added
 615 from other CLXes around the net.")
 616     (license license:x11)))
 617
 618 (define-public cl-clx
 619   (sbcl-package->cl-source-package sbcl-clx))
 620
 621 (define-public ecl-clx
 622   (sbcl-package->ecl-package sbcl-clx))
 623
 624 (define-public sbcl-clx-truetype
 625   (let ((commit "c6e10a918d46632324d5863a8ed067a83fc26de8")
 626         (revision "1"))
 627     (package
 628       (name "sbcl-clx-truetype")
 629       (version (git-version "0.0.1" revision commit))
 630       (source
 631        (origin
 632          (method git-fetch)
 633          (uri (git-reference
 634                (url "https://github.com/l04m33/clx-truetype")
 635                (commit commit)))
 636          (file-name (git-file-name name version))
 637          (sha256
 638           (base32
 639            "079hyp92cjkdfn6bhkxsrwnibiqbz4y4af6nl31lzw6nm91j5j37"))
 640          (modules '((guix build utils)))
 641          (snippet
 642           '(begin
 643              (substitute* "package.lisp"
 644                ((":export") ":export\n   :+font-cache-filename+"))
 645              #t))))
 646       (build-system asdf-build-system/sbcl)
 647       (inputs
 648        `(("clx" ,sbcl-clx)
 649          ("zpb-ttf" ,sbcl-zpb-ttf)
 650          ("cl-vectors" ,sbcl-cl-vectors)
 651          ("cl-paths-ttf" ,sbcl-cl-paths-ttf)
 652          ("cl-fad" ,sbcl-cl-fad)
 653          ("cl-store" ,sbcl-cl-store)
 654          ("trivial-features" ,sbcl-trivial-features)))
 655       (home-page "https://github.com/l04m33/clx-truetype")
 656       (synopsis "Antialiased TrueType font rendering using CLX and XRender")
 657       (description "CLX-TrueType is pure common lisp solution for
 658 antialiased TrueType font rendering using CLX and XRender extension.")
 659       (license license:expat))))
 660
 661 (define-public sbcl-cl-ppcre-unicode
 662   (package (inherit sbcl-cl-ppcre)
 663     (name "sbcl-cl-ppcre-unicode")
 664     (arguments
 665      `(#:tests? #f ; tests fail with "Component :CL-PPCRE-TEST not found"
 666        #:asd-file "cl-ppcre-unicode.asd"))
 667     (inputs
 668      `(("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
 669        ("sbcl-cl-unicode" ,sbcl-cl-unicode)))))
 670
 671 (define-public ecl-cl-ppcre-unicode
 672   (sbcl-package->ecl-package sbcl-cl-ppcre-unicode))
 673
 674 ;; The slynk that users expect to install includes all of slynk's contrib
 675 ;; modules.  Therefore, we build the base module and all contribs first; then
 676 ;; we expose the union of these as `sbcl-slynk'.  The following variable
 677 ;; describes the base module.
 678 (define sbcl-slynk-boot0
 679   (let ((revision "2")
 680         (commit "cbf84c36c4eca8b032e3fd16177a7bc02df3ec4c"))
 681     (package
 682       (name "sbcl-slynk-boot0")
 683       (version (string-append "1.0.0-beta-" revision "." (string-take commit 7)))
 684       (source
 685        (origin
 686          (method git-fetch)
 687          (uri
 688           (git-reference
 689            (url "https://github.com/joaotavora/sly.git")
 690            (commit commit)))
 691          (sha256
 692           (base32 "13dyhsravn591p7g6is01mp2ynzjnnj7pwgi57r6xqmd4611y9vh"))
 693          (file-name (string-append "slynk-" version "-checkout"))
 694          (modules '((guix build utils)
 695                     (ice-9 ftw)))
 696          (snippet
 697           '(begin
 698              ;; Move the contribs into the main source directory for easier
 699              ;; access
 700              (substitute* "slynk/slynk.asd"
 701                (("\\.\\./contrib")
 702                 "contrib")
 703                (("\\(defsystem :slynk/util")
 704                 "(defsystem :slynk/util :depends-on (:slynk)")
 705                ((":depends-on \\(:slynk :slynk/util\\)")
 706                 ":depends-on (:slynk :slynk-util)"))
 707              (substitute* "contrib/slynk-trace-dialog.lisp"
 708                (("\\(slynk::reset-inspector\\)") ; Causes problems on load
 709                 "nil"))
 710              (substitute* "contrib/slynk-profiler.lisp"
 711                (("slynk:to-line")
 712                 "slynk-pprint-to-line"))
 713              (substitute* "contrib/slynk-fancy-inspector.lisp"
 714                (("slynk/util") "slynk-util")
 715                ((":compile-toplevel :load-toplevel") ""))
 716              (rename-file "contrib" "slynk/contrib")
 717              ;; Move slynk's contents into the base directory for easier
 718              ;; access
 719              (for-each (lambda (file)
 720                          (unless (string-prefix? "." file)
 721                            (rename-file (string-append "slynk/" file)
 722                                         (string-append "./" (basename file)))))
 723                        (scandir "slynk"))
 724              #t))))
 725       (build-system asdf-build-system/sbcl)
 726       (arguments
 727        `(#:tests? #f ; No test suite
 728          #:asd-system-name "slynk"))
 729       (synopsis "Common Lisp IDE for Emacs")
 730       (description "SLY is a fork of SLIME, an IDE backend for Common Lisp.
 731 It also features a completely redesigned REPL based on Emacs's own
 732 full-featured comint.el, live code annotations, and a consistent interactive
 733 button interface.  Everything can be copied to the REPL.  One can create
 734 multiple inspectors with independent history.")
 735       (home-page "https://github.com/joaotavora/sly")
 736       (license license:public-domain)
 737       (properties `((cl-source-variant . ,(delay cl-slynk)))))))
 738
 739 (define-public cl-slynk
 740   (package
 741     (inherit (sbcl-package->cl-source-package sbcl-slynk-boot0))
 742     (name "cl-slynk")))
 743
 744 (define ecl-slynk-boot0
 745   (sbcl-package->ecl-package sbcl-slynk-boot0))
 746
 747 (define sbcl-slynk-arglists
 748   (package
 749     (inherit sbcl-slynk-boot0)
 750     (name "sbcl-slynk-arglists")
 751     (inputs `(("slynk" ,sbcl-slynk-boot0)))
 752     (arguments
 753      (substitute-keyword-arguments (package-arguments sbcl-slynk-boot0)
 754        ((#:asd-file _ "") "slynk.asd")
 755        ((#:asd-system-name _ #f) "slynk/arglists")))))
 756
 757 (define ecl-slynk-arglists
 758   (sbcl-package->ecl-package sbcl-slynk-arglists))
 759
 760 (define sbcl-slynk-util
 761   (package
 762     (inherit sbcl-slynk-boot0)
 763     (name "sbcl-slynk-util")
 764     (inputs `(("slynk" ,sbcl-slynk-boot0)))
 765     (arguments
 766      (substitute-keyword-arguments (package-arguments sbcl-slynk-boot0)
 767        ((#:asd-file _ "") "slynk.asd")
 768        ((#:asd-system-name _ #f) "slynk/util")))))
 769
 770 (define ecl-slynk-util
 771   (sbcl-package->ecl-package sbcl-slynk-util))
 772
 773 (define sbcl-slynk-fancy-inspector
 774   (package
 775     (inherit sbcl-slynk-arglists)
 776     (name "sbcl-slynk-fancy-inspector")
 777     (inputs `(("slynk-util" ,sbcl-slynk-util)
 778               ,@(package-inputs sbcl-slynk-arglists)))
 779     (arguments
 780      (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
 781        ((#:asd-system-name _ #f) "slynk/fancy-inspector")))))
 782
 783 (define ecl-slynk-fancy-inspector
 784   (sbcl-package->ecl-package sbcl-slynk-fancy-inspector))
 785
 786 (define sbcl-slynk-package-fu
 787   (package
 788     (inherit sbcl-slynk-arglists)
 789     (name "sbcl-slynk-package-fu")
 790     (arguments
 791      (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
 792        ((#:asd-system-name _ #f) "slynk/package-fu")))))
 793
 794 (define ecl-slynk-package-fu
 795   (sbcl-package->ecl-package sbcl-slynk-package-fu))
 796
 797 (define sbcl-slynk-mrepl
 798   (package
 799     (inherit sbcl-slynk-fancy-inspector)
 800     (name "sbcl-slynk-mrepl")
 801     (arguments
 802      (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
 803        ((#:asd-system-name _ #f) "slynk/mrepl")))))
 804
 805 (define ecl-slynk-mrepl
 806   (sbcl-package->ecl-package sbcl-slynk-mrepl))
 807
 808 (define sbcl-slynk-trace-dialog
 809   (package
 810     (inherit sbcl-slynk-arglists)
 811     (name "sbcl-slynk-trace-dialog")
 812     (arguments
 813      (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
 814        ((#:asd-system-name _ #f) "slynk/trace-dialog")))))
 815
 816 (define ecl-slynk-trace-dialog
 817   (sbcl-package->ecl-package sbcl-slynk-trace-dialog))
 818
 819 (define sbcl-slynk-profiler
 820   (package
 821     (inherit sbcl-slynk-arglists)
 822     (name "sbcl-slynk-profiler")
 823     (arguments
 824      (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
 825        ((#:asd-system-name _ #f) "slynk/profiler")))))
 826
 827 (define ecl-slynk-profiler
 828   (sbcl-package->ecl-package sbcl-slynk-profiler))
 829
 830 (define sbcl-slynk-stickers
 831   (package
 832     (inherit sbcl-slynk-arglists)
 833     (name "sbcl-slynk-stickers")
 834     (arguments
 835      (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
 836        ((#:asd-system-name _ #f) "slynk/stickers")))))
 837
 838 (define ecl-slynk-stickers
 839   (sbcl-package->ecl-package sbcl-slynk-stickers))
 840
 841 (define sbcl-slynk-indentation
 842   (package
 843     (inherit sbcl-slynk-arglists)
 844     (name "sbcl-slynk-indentation")
 845     (arguments
 846      (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
 847        ((#:asd-system-name _ #f) "slynk/indentation")))))
 848
 849 (define ecl-slynk-indentation
 850   (sbcl-package->ecl-package sbcl-slynk-indentation))
 851
 852 (define sbcl-slynk-retro
 853   (package
 854     (inherit sbcl-slynk-arglists)
 855     (name "sbcl-slynk-retro")
 856     (arguments
 857      (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
 858        ((#:asd-system-name _ #f) "slynk/retro")))))
 859
 860 (define ecl-slynk-retro
 861   (sbcl-package->ecl-package sbcl-slynk-retro))
 862
 863 (define slynk-systems
 864   '("slynk"
 865     "slynk-util"
 866     "slynk-arglists"
 867     "slynk-fancy-inspector"
 868     "slynk-package-fu"
 869     "slynk-mrepl"
 870     "slynk-profiler"
 871     "slynk-trace-dialog"
 872     "slynk-stickers"
 873     "slynk-indentation"
 874     "slynk-retro"))
 875
 876 (define-public sbcl-slynk
 877   (package
 878     (inherit sbcl-slynk-boot0)
 879     (name "sbcl-slynk")
 880     (inputs
 881      `(("slynk" ,sbcl-slynk-boot0)
 882        ("slynk-util" ,sbcl-slynk-util)
 883        ("slynk-arglists" ,sbcl-slynk-arglists)
 884        ("slynk-fancy-inspector" ,sbcl-slynk-fancy-inspector)
 885        ("slynk-package-fu" ,sbcl-slynk-package-fu)
 886        ("slynk-mrepl" ,sbcl-slynk-mrepl)
 887        ("slynk-profiler" ,sbcl-slynk-profiler)
 888        ("slynk-trace-dialog" ,sbcl-slynk-trace-dialog)
 889        ("slynk-stickers" ,sbcl-slynk-stickers)
 890        ("slynk-indentation" ,sbcl-slynk-indentation)
 891        ("slynk-retro" ,sbcl-slynk-retro)))
 892     (native-inputs `(("sbcl" ,sbcl)))
 893     (build-system trivial-build-system)
 894     (source #f)
 895     (outputs '("out" "image"))
 896     (arguments
 897      `(#:modules ((guix build union)
 898                   (guix build utils)
 899                   (guix build lisp-utils))
 900        #:builder
 901        (begin
 902          (use-modules (ice-9 match)
 903                       (srfi srfi-1)
 904                       (guix build union)
 905                       (guix build lisp-utils))
 906
 907          (union-build
 908           (assoc-ref %outputs "out")
 909           (filter-map
 910            (match-lambda
 911              ((name . path)
 912               (if (string-prefix? "slynk" name) path #f)))
 913            %build-inputs))
 914
 915          (prepend-to-source-registry
 916           (string-append (assoc-ref %outputs "out") "//"))
 917
 918          (parameterize ((%lisp-type "sbcl")
 919                         (%lisp (string-append (assoc-ref %build-inputs "sbcl")
 920                                               "/bin/sbcl")))
 921            (build-image (string-append
 922                          (assoc-ref %outputs "image")
 923                          "/bin/slynk")
 924                         %outputs
 925                         #:dependencies ',slynk-systems))
 926          #t)))))
 927
 928 (define-public ecl-slynk
 929   (package
 930     (inherit sbcl-slynk)
 931     (name "ecl-slynk")
 932     (inputs
 933      (map (match-lambda
 934             ((name pkg . _)
 935              (list name (sbcl-package->ecl-package pkg))))
 936           (package-inputs sbcl-slynk)))
 937     (native-inputs '())
 938     (outputs '("out"))
 939     (arguments
 940      '(#:modules ((guix build union))
 941        #:builder
 942        (begin
 943          (use-modules (ice-9 match)
 944                       (guix build union))
 945          (match %build-inputs
 946            (((names . paths) ...)
 947             (union-build (assoc-ref %outputs "out")
 948                          paths)
 949             #t)))))))
 950
 951 (define-public sbcl-parse-js
 952   (let ((commit "fbadc6029bec7039602abfc06c73bb52970998f6")
 953         (revision "1"))
 954     (package
 955       (name "sbcl-parse-js")
 956       (version (string-append "0.0.0-" revision "." (string-take commit 9)))
 957       (source
 958        (origin
 959          (method git-fetch)
 960          (uri (git-reference
 961                (url "http://marijn.haverbeke.nl/git/parse-js")
 962                (commit commit)))
 963          (file-name (string-append name "-" commit "-checkout"))
 964          (sha256
 965           (base32
 966            "1wddrnr5kiya5s3gp4cdq6crbfy9fqcz7fr44p81502sj3bvdv39"))))
 967       (build-system asdf-build-system/sbcl)
 968       (home-page "https://marijnhaverbeke.nl/parse-js/")
 969       (synopsis "Parse JavaScript")
 970       (description "Parse-js is a Common Lisp package for parsing
 971 JavaScript (ECMAScript 3).  It has basic support for ECMAScript 5.")
 972       (license license:zlib))))
 973
 974 (define-public cl-parse-js
 975   (sbcl-package->cl-source-package sbcl-parse-js))
 976
 977 (define-public sbcl-parse-number
 978   (package
 979     (name "sbcl-parse-number")
 980     (version "1.7")
 981     (source
 982      (origin
 983        (method git-fetch)
 984        (uri (git-reference
 985               (url "https://github.com/sharplispers/parse-number/")
 986               (commit (string-append "v" version))))
 987        (file-name (git-file-name name version))
 988        (sha256
 989         (base32
 990          "0sk06ib1bhqv9y39vwnnw44vmbc4b0kvqm37xxmkxd4dwchq82d7"))))
 991     (build-system asdf-build-system/sbcl)
 992     (home-page "https://www.cliki.net/PARSE-NUMBER")
 993     (synopsis "Parse numbers")
 994     (description "@code{parse-number} is a library of functions for parsing
 995 strings into one of the standard Common Lisp number types without using the
 996 reader.  @code{parse-number} accepts an arbitrary string and attempts to parse
 997 the string into one of the standard Common Lisp number types, if possible, or
 998 else @code{parse-number} signals an error of type @code{invalid-number}.")
 999     (license license:bsd-3)))
1000
1001 (define-public cl-parse-number
1002   (sbcl-package->cl-source-package sbcl-parse-number))
1003
1004 (define-public sbcl-iterate
1005   (package
1006     (name "sbcl-iterate")
1007     (version "1.5")
1008     (source
1009      (origin
1010        (method url-fetch)
1011        (uri (string-append "https://common-lisp.net/project/iterate/releases/"
1012                            "iterate-" version ".tar.gz"))
1013        (sha256
1014         (base32
1015          "1lqsbhrkfl0yif46aymvb7l3nb9wdcmj4jyw485blj32jb4famzn"))))
1016     (build-system asdf-build-system/sbcl)
1017     (native-inputs
1018      `(("rt" ,sbcl-rt)))
1019     (home-page "https://common-lisp.net/project/iterate/")
1020     (synopsis "Iteration construct for Common Lisp")
1021     (description "@code{iterate} is an iteration construct for Common Lisp.
1022 It is similar to the @code{CL:LOOP} macro, with these distinguishing marks:
1023
1024 @itemize
1025 @item it is extensible,
1026 @item it helps editors like Emacs indent iterate forms by having a more
1027   lisp-like syntax, and
1028 @item it isn't part of the ANSI standard for Common Lisp.
1029 @end itemize\n")
1030     (license license:expat)))
1031
1032 (define-public cl-iterate
1033   (sbcl-package->cl-source-package sbcl-iterate))
1034
1035 (define-public ecl-iterate
1036   (sbcl-package->ecl-package sbcl-iterate))
1037
1038 (define-public sbcl-cl-uglify-js
1039   ;; There have been many bug fixes since the 2010 release.
1040   (let ((commit "429c5e1d844e2f96b44db8fccc92d6e8e28afdd5")
1041         (revision "1"))
1042     (package
1043       (name "sbcl-cl-uglify-js")
1044       (version (string-append "0.1-" revision "." (string-take commit 9)))
1045       (source
1046        (origin
1047          (method git-fetch)
1048          (uri (git-reference
1049                (url "https://github.com/mishoo/cl-uglify-js.git")
1050                (commit commit)))
1051          (file-name (git-file-name name version))
1052          (sha256
1053           (base32
1054            "0k39y3c93jgxpr7gwz7w0d8yknn1fdnxrjhd03057lvk5w8js27a"))))
1055       (build-system asdf-build-system/sbcl)
1056       (inputs
1057        `(("sbcl-parse-js" ,sbcl-parse-js)
1058          ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
1059          ("sbcl-cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)
1060          ("sbcl-parse-number" ,sbcl-parse-number)
1061          ("sbcl-iterate" ,sbcl-iterate)))
1062       (home-page "https://github.com/mishoo/cl-uglify-js")
1063       (synopsis "JavaScript compressor library for Common Lisp")
1064       (description "This is a Common Lisp version of UglifyJS, a JavaScript
1065 compressor.  It works on data produced by @code{parse-js} to generate a
1066 @dfn{minified} version of the code.  Currently it can:
1067
1068 @itemize
1069 @item reduce variable names (usually to single letters)
1070 @item join consecutive @code{var} statements
1071 @item resolve simple binary expressions
1072 @item group most consecutive statements using the @code{sequence} operator (comma)
1073 @item remove unnecessary blocks
1074 @item convert @code{IF} expressions in various ways that result in smaller code
1075 @item remove some unreachable code
1076 @end itemize\n")
1077       (license license:zlib))))
1078
1079 (define-public cl-uglify-js
1080   (sbcl-package->cl-source-package sbcl-cl-uglify-js))
1081
1082 (define-public uglify-js
1083   (package
1084     (inherit sbcl-cl-uglify-js)
1085     (name "uglify-js")
1086     (build-system trivial-build-system)
1087     (arguments
1088      `(#:modules ((guix build utils))
1089        #:builder
1090        (let* ((bin    (string-append (assoc-ref %outputs "out") "/bin/"))
1091               (script (string-append bin "uglify-js")))
1092          (use-modules (guix build utils))
1093          (mkdir-p bin)
1094          (with-output-to-file script
1095            (lambda _
1096              (format #t "#!~a/bin/sbcl --script
1097  (require :asdf)
1098  (push (truename \"~a/lib/sbcl\") asdf:*central-registry*)"
1099                      (assoc-ref %build-inputs "sbcl")
1100                      (assoc-ref %build-inputs "sbcl-cl-uglify-js"))
1101              ;; FIXME: cannot use progn here because otherwise it fails to
1102              ;; find cl-uglify-js.
1103              (for-each
1104               write
1105               '(;; Quiet, please!
1106                 (let ((*standard-output* (make-broadcast-stream))
1107                       (*error-output* (make-broadcast-stream)))
1108                   (asdf:load-system :cl-uglify-js))
1109                 (let ((file (cadr *posix-argv*)))
1110                   (if file
1111                       (format t "~a"
1112                               (cl-uglify-js:ast-gen-code
1113                                (cl-uglify-js:ast-mangle
1114                                 (cl-uglify-js:ast-squeeze
1115                                  (with-open-file (in file)
1116                                                  (parse-js:parse-js in))))
1117                                :beautify nil))
1118                       (progn
1119                        (format *error-output*
1120                                "Please provide a JavaScript file.~%")
1121                        (sb-ext:exit :code 1))))))))
1122          (chmod script #o755)
1123          #t)))
1124     (inputs
1125      `(("sbcl" ,sbcl)
1126        ("sbcl-cl-uglify-js" ,sbcl-cl-uglify-js)))
1127     (synopsis "JavaScript compressor")))
1128
1129 (define-public sbcl-cl-strings
1130   (let ((revision "1")
1131         (commit "c5c5cbafbf3e6181d03c354d66e41a4f063f00ae"))
1132     (package
1133       (name "sbcl-cl-strings")
1134       (version (git-version "0.0.0" revision commit))
1135       (source
1136        (origin
1137          (method git-fetch)
1138          (uri (git-reference
1139                (url "https://github.com/diogoalexandrefranco/cl-strings")
1140                (commit commit)))
1141          (sha256
1142           (base32
1143            "00754mfaqallj480lwd346nkfb6ra8pa8xcxcylf4baqn604zlmv"))
1144          (file-name (string-append "cl-strings-" version "-checkout"))))
1145       (build-system asdf-build-system/sbcl)
1146       (synopsis "Portable, dependency-free set of utilities to manipulate strings in Common Lisp")
1147       (description
1148        "@command{cl-strings} is a small, portable, dependency-free set of
1149 utilities that make it even easier to manipulate text in Common Lisp.  It has
1150 100% test coverage and works at least on sbcl, ecl, ccl, abcl and clisp.")
1151       (home-page "https://github.com/diogoalexandrefranco/cl-strings")
1152       (license license:expat))))
1153
1154 (define-public cl-strings
1155   (sbcl-package->cl-source-package sbcl-cl-strings))
1156
1157 (define-public ecl-cl-strings
1158   (sbcl-package->ecl-package sbcl-cl-strings))
1159
1160 (define-public sbcl-trivial-features
1161   (package
1162     (name "sbcl-trivial-features")
1163     (version "0.8")
1164     (source
1165      (origin
1166        (method git-fetch)
1167        (uri (git-reference
1168              (url "https://github.com/trivial-features/trivial-features.git")
1169              (commit (string-append "v" version))))
1170        (file-name (git-file-name "trivial-features" version))
1171        (sha256
1172         (base32 "0ccv7dqyrk55xga78i5vzlic7mdwp28in3g1a8fqhlk6626scsq9"))))
1173     (build-system asdf-build-system/sbcl)
1174     (arguments '(#:tests? #f))
1175     (home-page "https://cliki.net/trivial-features")
1176     (synopsis "Ensures consistency of @code{*FEATURES*} in Common Lisp")
1177     (description "Trivial-features ensures that @code{*FEATURES*} is
1178 consistent across multiple Common Lisp implementations.")
1179     (license license:expat)))
1180
1181 (define-public cl-trivial-features
1182   (sbcl-package->cl-source-package sbcl-trivial-features))
1183
1184 (define-public ecl-trivial-features
1185   (sbcl-package->ecl-package sbcl-trivial-features))
1186
1187 (define-public sbcl-hu.dwim.asdf
1188   (package
1189     (name "sbcl-hu.dwim.asdf")
1190     (version "20190521")
1191     (source
1192      (origin
1193        (method url-fetch)
1194        (uri (string-append "http://beta.quicklisp.org/archive/hu.dwim.asdf/"
1195                            "2019-05-21/hu.dwim.asdf-" version "-darcs.tgz"))
1196        (sha256
1197         (base32
1198          "0rsbv71vyszy8w35yjwb5h6zcmknjq223hkzir79y72qdsc6sabn"))))
1199     (build-system asdf-build-system/sbcl)
1200     (home-page "https://hub.darcs.net/hu.dwim/hu.dwim.asdf")
1201     (synopsis "Extensions to ASDF")
1202     (description "Various ASDF extensions such as attached test and
1203 documentation system, explicit development support, etc.")
1204     (license license:public-domain)))
1205
1206 (define-public cl-hu.dwim.asdf
1207   (sbcl-package->cl-source-package sbcl-hu.dwim.asdf))
1208
1209 (define-public ecl-hu.dwim.asdf
1210   (sbcl-package->ecl-package sbcl-hu.dwim.asdf))
1211
1212 (define-public sbcl-hu.dwim.stefil
1213   (let ((commit "ab6d1aa8995878a1b66d745dfd0ba021090bbcf9"))
1214     (package
1215       (name "sbcl-hu.dwim.stefil")
1216       (version (git-version "0.0.0" "1" commit))
1217       (source
1218        (origin
1219          (method git-fetch)
1220          (uri
1221           (git-reference
1222            (url "https://gitlab.common-lisp.net/xcvb/hu.dwim.stefil.git")
1223            (commit commit)))
1224          (sha256
1225           (base32 "1d8yccw65zj3zh46cbi3x6nmn1dwdb76s9d0av035077mvyirqqp"))
1226          (file-name (git-file-name "hu.dwim.stefil" version))))
1227       (build-system asdf-build-system/sbcl)
1228       (native-inputs
1229        `(("asdf:cl-hu.dwim.asdf" ,sbcl-hu.dwim.asdf)))
1230       (inputs
1231        `(("sbcl-alexandria" ,sbcl-alexandria)))
1232       (home-page "https://hub.darcs.net/hu.dwim/hu.dwim.stefil")
1233       (synopsis "Simple test framework")
1234       (description "Stefil is a simple test framework for Common Lisp,
1235 with a focus on interactive development.")
1236       (license license:public-domain))))
1237
1238 (define-public cl-hu.dwim.stefil
1239   (sbcl-package->cl-source-package sbcl-hu.dwim.stefil))
1240
1241 (define-public ecl-hu.dwim.stefil
1242   (sbcl-package->ecl-package sbcl-hu.dwim.stefil))
1243
1244 (define-public sbcl-babel
1245   (package
1246     (name "sbcl-babel")
1247     (version "0.5.0")
1248     (source
1249      (origin
1250        (method git-fetch)
1251        (uri (git-reference
1252              (url "https://github.com/cl-babel/babel.git")
1253              (commit (string-append "v" version))))
1254        (file-name (git-file-name "babel" version))
1255        (sha256
1256         (base32 "139a8rn2gnhj082n8jg01gc8fyr63hkj57hgrnmb3d1r327yc77f"))))
1257     (build-system asdf-build-system/sbcl)
1258     (native-inputs
1259      `(("tests:cl-hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
1260     (inputs
1261      `(("sbcl-alexandria" ,sbcl-alexandria)
1262        ("sbcl-trivial-features" ,sbcl-trivial-features)))
1263     (home-page "https://common-lisp.net/project/babel/")
1264     (synopsis "Charset encoding and decoding library")
1265     (description "Babel is a charset encoding and decoding library, not unlike
1266 GNU libiconv, but completely written in Common Lisp.")
1267     (license license:expat)))
1268
1269 (define-public cl-babel
1270   (sbcl-package->cl-source-package sbcl-babel))
1271
1272 (define-public ecl-babel
1273   (sbcl-package->ecl-package sbcl-babel))
1274
1275 (define-public sbcl-cl-yacc
1276   (package
1277     (name "sbcl-cl-yacc")
1278     (version "0.3")
1279     (source
1280      (origin
1281        (method git-fetch)
1282        (uri (git-reference
1283              (url "https://github.com/jech/cl-yacc")
1284              (commit (string-append "cl-yacc-" version))))
1285        (sha256
1286         (base32
1287          "16946pzf8vvadnyfayvj8rbh4zjzw90h0azz2qk1mxrvhh5wklib"))
1288        (file-name (string-append "cl-yacc-" version "-checkout"))))
1289     (build-system asdf-build-system/sbcl)
1290     (arguments
1291      `(#:asd-file "yacc.asd"
1292        #:asd-system-name "yacc"))
1293     (synopsis "LALR(1) parser generator for Common Lisp, similar in spirit to Yacc")
1294     (description
1295      "CL-Yacc is a LALR(1) parser generator for Common Lisp, similar in spirit
1296 to AT&T Yacc, Berkeley Yacc, GNU Bison, Zebu, lalr.cl or lalr.scm.
1297
1298 CL-Yacc uses the algorithm due to Aho and Ullman, which is the one also used
1299 by AT&T Yacc, Berkeley Yacc and Zebu.  It does not use the faster algorithm due
1300 to DeRemer and Pennello, which is used by Bison and lalr.scm (not lalr.cl).")
1301     (home-page "https://www.irif.fr/~jch//software/cl-yacc/")
1302     (license license:expat)))
1303
1304 (define-public cl-yacc
1305   (sbcl-package->cl-source-package sbcl-cl-yacc))
1306
1307 (define-public ecl-cl-yacc
1308   (sbcl-package->ecl-package sbcl-cl-yacc))
1309
1310 (define-public sbcl-jpl-util
1311   (let ((commit "0311ed374e19a49d43318064d729fe3abd9a3b62"))
1312     (package
1313       (name "sbcl-jpl-util")
1314       (version "20151005")
1315       (source
1316        (origin
1317          (method git-fetch)
1318          (uri (git-reference
1319                ;; Quicklisp uses this fork.
1320                (url "https://github.com/hawkir/cl-jpl-util")
1321                (commit commit)))
1322          (file-name
1323           (git-file-name "jpl-util" version))
1324          (sha256
1325           (base32
1326            "0nc0rk9n8grkg3045xsw34whmcmddn2sfrxki4268g7kpgz0d2yz"))))
1327       (build-system asdf-build-system/sbcl)
1328       (synopsis "Collection of Common Lisp utility functions and macros")
1329       (description
1330        "@command{cl-jpl-util} is a collection of Common Lisp utility functions
1331 and macros, primarily for software projects written in CL by the author.")
1332       (home-page "https://www.thoughtcrime.us/software/cl-jpl-util/")
1333       (license license:isc))))
1334
1335 (define-public cl-jpl-util
1336   (sbcl-package->cl-source-package sbcl-jpl-util))
1337
1338 (define-public ecl-jpl-util
1339   (sbcl-package->ecl-package sbcl-jpl-util))
1340
1341 (define-public sbcl-jpl-queues
1342   (package
1343     (name "sbcl-jpl-queues")
1344     (version "0.1")
1345     (source
1346      (origin
1347        (method url-fetch)
1348        (uri (string-append
1349              "http://www.thoughtcrime.us/software/jpl-queues/jpl-queues-"
1350              version
1351              ".tar.gz"))
1352        (sha256
1353         (base32
1354          "1wvvv7j117h9a42qaj1g4fh4mji28xqs7s60rn6d11gk9jl76h96"))))
1355     (build-system asdf-build-system/sbcl)
1356     (inputs
1357      `(("jpl-util" ,sbcl-jpl-util)
1358        ("bordeaux-threads" ,sbcl-bordeaux-threads)))
1359     (arguments
1360      ;; Tests seem to be broken.
1361      `(#:tests? #f))
1362     (synopsis "Common Lisp library implementing a few different kinds of queues")
1363     (description
1364      "A Common Lisp library implementing a few different kinds of queues:
1365
1366 @itemize
1367 @item Bounded and unbounded FIFO queues.
1368 @item Lossy bounded FIFO queues that drop elements when full.
1369 @item Unbounded random-order queues that use less memory than unbounded FIFO queues.
1370 @end itemize
1371
1372 Additionally, a synchronization wrapper is provided to make any queue
1373 conforming to the @command{jpl-queues} API thread-safe for lightweight
1374 multithreading applications.  (See Calispel for a more sophisticated CL
1375 multithreaded message-passing library with timeouts and alternation among
1376 several blockable channels.)")
1377     (home-page "https://www.thoughtcrime.us/software/jpl-queues/")
1378     (license license:isc)))
1379
1380 (define-public cl-jpl-queues
1381   (sbcl-package->cl-source-package sbcl-jpl-queues))
1382
1383 (define-public ecl-jpl-queues
1384   (sbcl-package->ecl-package sbcl-jpl-queues))
1385
1386 (define-public sbcl-eos
1387   (let ((commit "b0faca83781ead9a588661e37bd47f90362ccd94"))
1388     (package
1389       (name "sbcl-eos")
1390       (version (git-version "0.0.0" "1" commit))
1391       (source
1392        (origin
1393          (method git-fetch)
1394          (uri (git-reference
1395                (url "https://github.com/adlai/Eos")
1396                (commit commit)))
1397          (sha256
1398           (base32
1399            "1bq8cfg087iyxmxi1mwgx5cfgy3b8ydrf81xljcis8qbgb2vszph"))
1400          (file-name (git-file-name "eos" version))))
1401       (build-system asdf-build-system/sbcl)
1402       (synopsis "Unit Testing for Common Lisp")
1403       (description
1404        "Eos was a unit testing library for Common Lisp.
1405 It began as a fork of FiveAM; however, FiveAM development has continued, while
1406 that of Eos has not.  Thus, Eos is now deprecated in favor of FiveAM.")
1407       (home-page "https://github.com/adlai/Eos")
1408       (license license:expat))))
1409
1410 (define-public cl-eos
1411   (sbcl-package->cl-source-package sbcl-eos))
1412
1413 (define-public ecl-eos
1414   (sbcl-package->ecl-package sbcl-eos))
1415
1416 (define-public sbcl-esrap
1417   (let ((commit "133be8b05c2aae48696fe5b739eea2fa573fa48d"))
1418     (package
1419       (name "sbcl-esrap")
1420       (version (git-version "0.0.0" "1" commit))
1421       (source
1422        (origin
1423          (method git-fetch)
1424          (uri (git-reference
1425                (url "https://github.com/nikodemus/esrap")
1426                (commit commit)))
1427          (sha256
1428           (base32
1429            "02d5clihsdryhf7pix8c5di2571fdsffh75d40fkzhws90r5mksl"))
1430          (file-name (git-file-name "esrap" version))))
1431       (build-system asdf-build-system/sbcl)
1432       (native-inputs
1433        `(("eos" ,sbcl-eos)))            ;For testing only.
1434       (inputs
1435        `(("alexandria" ,sbcl-alexandria)))
1436       (synopsis "Common Lisp packrat parser")
1437       (description
1438        "A packrat parser for Common Lisp.
1439 In addition to regular Packrat / Parsing Grammar / TDPL features ESRAP supports:
1440
1441 @itemize
1442 @item dynamic redefinition of nonterminals
1443 @item inline grammars
1444 @item semantic predicates
1445 @item introspective facilities (describing grammars, tracing, setting breaks)
1446 @end itemize\n")
1447       (home-page "https://nikodemus.github.io/esrap/")
1448       (license license:expat))))
1449
1450 (define-public cl-esrap
1451   (sbcl-package->cl-source-package sbcl-esrap))
1452
1453 (define-public ecl-esrap
1454   (sbcl-package->ecl-package sbcl-esrap))
1455
1456 (define-public sbcl-split-sequence
1457   (package
1458     (name "sbcl-split-sequence")
1459     (version "2.0.0")
1460     (source
1461      (origin
1462        (method git-fetch)
1463        (uri (git-reference
1464              (url "https://github.com/sharplispers/split-sequence")
1465              (commit (string-append "v" version))))
1466        (sha256
1467         (base32
1468          "0jcpnx21hkfwqj5fvp7kc6pn1qcz9hk7g2s5x8h0349x1j2irln0"))
1469        (file-name (git-file-name "split-sequence" version))))
1470     (build-system asdf-build-system/sbcl)
1471     (native-inputs
1472      `(("fiveam" ,sbcl-fiveam)))
1473     (synopsis "Member of the Common Lisp Utilities family of programs")
1474     (description
1475      "Splits sequence into a list of subsequences delimited by objects
1476 satisfying the test.")
1477     (home-page "https://cliki.net/split-sequence")
1478     (license license:expat)))
1479
1480 (define-public cl-split-sequence
1481   (sbcl-package->cl-source-package sbcl-split-sequence))
1482
1483 (define-public ecl-split-sequence
1484   (sbcl-package->ecl-package sbcl-split-sequence))
1485
1486 (define-public sbcl-html-encode
1487   (package
1488     (name "sbcl-html-encode")
1489     (version "1.2")
1490     (source
1491      (origin
1492        (method url-fetch)
1493        (uri (string-append
1494              "http://beta.quicklisp.org/archive/html-encode/2010-10-06/html-encode-"
1495              version ".tgz"))
1496        (sha256
1497         (base32
1498          "06mf8wn95yf5swhmzk4vp0xr4ylfl33dgfknkabbkd8n6jns8gcf"))
1499        (file-name (string-append "colorize" version "-checkout"))))
1500     (build-system asdf-build-system/sbcl)
1501     (synopsis "Common Lisp library for encoding text in various web-savvy encodings")
1502     (description
1503      "A library for encoding text in various web-savvy encodings.")
1504     (home-page "http://quickdocs.org/html-encode/")
1505     (license license:expat)))
1506
1507 (define-public cl-html-encode
1508   (sbcl-package->cl-source-package sbcl-html-encode))
1509
1510 (define-public ecl-html-encode
1511   (sbcl-package->ecl-package sbcl-html-encode))
1512
1513 (define-public sbcl-colorize
1514   (let ((commit "ea676b584e0899cec82f21a9e6871172fe3c0eb5"))
1515     (package
1516       (name "sbcl-colorize")
1517       (version (git-version "0.0.0" "1" commit))
1518       (source
1519        (origin
1520          (method git-fetch)
1521          (uri (git-reference
1522                (url "https://github.com/kingcons/colorize")
1523                (commit commit)))
1524          (sha256
1525           (base32
1526            "1pdg4kiaczmr3ivffhirp7m3lbr1q27rn7dhaay0vwghmi31zcw9"))
1527          (file-name (git-file-name "colorize" version))))
1528       (build-system asdf-build-system/sbcl)
1529       (inputs
1530        `(("alexandria" ,sbcl-alexandria)
1531          ("split-sequence" ,sbcl-split-sequence)
1532          ("html-encode" ,sbcl-html-encode)))
1533       (synopsis "Common Lisp for syntax highlighting")
1534       (description
1535        "@command{colorize} is a Lisp library for syntax highlighting
1536 supporting the following languages: Common Lisp, Emacs Lisp, Scheme, Clojure,
1537 C, C++, Java, Python, Erlang, Haskell, Objective-C, Diff, Webkit.")
1538       (home-page "https://github.com/kingcons/colorize")
1539       ;; TODO: Missing license?
1540       (license license:expat))))
1541
1542 (define-public cl-colorize
1543   (sbcl-package->cl-source-package sbcl-colorize))
1544
1545 (define-public ecl-colorize
1546   (sbcl-package->ecl-package sbcl-colorize))
1547
1548 (define-public sbcl-3bmd
1549   (let ((commit "192ea13435b605a96ef607df51317056914cabbd"))
1550     (package
1551       (name "sbcl-3bmd")
1552       (version (git-version "0.0.0" "1" commit))
1553       (source
1554        (origin
1555          (method git-fetch)
1556          (uri (git-reference
1557                (url "https://github.com/3b/3bmd")
1558                (commit commit)))
1559          (sha256
1560           (base32
1561            "1rgv3gi7wf963ikmmpk132wgn0icddf226gq3bmcnk1fr3v9gf2f"))
1562          (file-name (git-file-name "3bmd" version))))
1563       (build-system asdf-build-system/sbcl)
1564       (arguments
1565        ;; FIXME: We need to specify the name because the build-system thinks
1566        ;; "3" is a version marker.
1567        `(#:asd-system-name "3bmd"))
1568       (inputs
1569        `(("esrap" ,sbcl-esrap)
1570          ("split-sequence" ,sbcl-split-sequence)))
1571       (synopsis "Markdown processor in Command Lisp using esrap parser")
1572       (description
1573        "Common Lisp Markdown -> HTML converter, using @command{esrap} for
1574 parsing, and grammar based on @command{peg-markdown}.")
1575       (home-page "https://github.com/3b/3bmd")
1576       (license license:expat))))
1577
1578 (define-public cl-3bmd
1579   (sbcl-package->cl-source-package sbcl-3bmd))
1580
1581 (define-public ecl-3bmd
1582   (sbcl-package->ecl-package sbcl-3bmd))
1583
1584 (define-public sbcl-3bmd-ext-code-blocks
1585   (let ((commit "192ea13435b605a96ef607df51317056914cabbd"))
1586     (package
1587       (inherit sbcl-3bmd)
1588       (name "sbcl-3bmd-ext-code-blocks")
1589       (arguments
1590        `(#:asd-system-name "3bmd-ext-code-blocks"
1591          #:asd-file "3bmd-ext-code-blocks.asd"))
1592       (inputs
1593        `(("3bmd" ,sbcl-3bmd)
1594          ("colorize" ,sbcl-colorize)))
1595       (synopsis "3bmd extension which adds support for GitHub-style fenced
1596 code blocks")
1597       (description
1598        "3bmd extension which adds support for GitHub-style fenced code blocks,
1599 with @command{colorize} support."))))
1600
1601 (define-public cl-3bmd-ext-code-blocks
1602   (sbcl-package->cl-source-package sbcl-3bmd-ext-code-blocks))
1603
1604 (define-public ecl-3bmd-ext-code-blocks
1605   (sbcl-package->ecl-package sbcl-3bmd-ext-code-blocks))
1606
1607 (define-public sbcl-cl-fad
1608   (package
1609     (name "sbcl-cl-fad")
1610     (version "0.7.6")
1611     (source
1612      (origin
1613        (method git-fetch)
1614        (uri (git-reference
1615              (url "https://github.com/edicl/cl-fad/")
1616              (commit (string-append "v" version))))
1617        (sha256
1618         (base32
1619          "1gc8i82v6gks7g0lnm54r4prk2mklidv2flm5fvbr0a7rsys0vpa"))
1620        (file-name (string-append "cl-fad" version "-checkout"))))
1621     (build-system asdf-build-system/sbcl)
1622     (inputs
1623      `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
1624     (synopsis "Portable pathname library for Common Lisp")
1625     (description
1626      "CL-FAD (for \"Files and Directories\") is a thin layer atop Common
1627 Lisp's standard pathname functions.  It is intended to provide some
1628 unification between current CL implementations on Windows, OS X, Linux, and
1629 Unix.  Most of the code was written by Peter Seibel for his book Practical
1630 Common Lisp.")
1631     (home-page "https://edicl.github.io/cl-fad/")
1632     (license license:bsd-2)))
1633
1634 (define-public cl-fad
1635   (sbcl-package->cl-source-package sbcl-cl-fad))
1636
1637 (define-public ecl-cl-fad
1638   (sbcl-package->ecl-package sbcl-cl-fad))
1639
1640 (define-public sbcl-rt
1641   (let ((commit "a6a7503a0b47953bc7579c90f02a6dba1f6e4c5a")
1642         (revision "1"))
1643     (package
1644       (name "sbcl-rt")
1645       (version (git-version "1990.12.19" revision commit))
1646       (source
1647        (origin
1648          (method git-fetch)
1649          (uri (git-reference
1650                (url "http://git.kpe.io/rt.git")
1651                (commit commit)))
1652          (file-name (git-file-name name version))
1653          (sha256
1654           (base32 "13si2rrxaagbr0bkvg6sqicxxpyshabx6ad6byc9n2ik5ysna69b"))))
1655       (build-system asdf-build-system/sbcl)
1656       (synopsis "MIT Regression Tester")
1657       (description
1658        "RT provides a framework for writing regression test suites.")
1659       (home-page "https://www.cliki.net/rt")
1660       (license license:expat))))
1661
1662 (define-public cl-rt
1663   (sbcl-package->cl-source-package sbcl-rt))
1664
1665 (define-public ecl-rt
1666   (sbcl-package->ecl-package sbcl-rt))
1667
1668 (define-public sbcl-nibbles
1669   (package
1670     (name "sbcl-nibbles")
1671     (version "0.14")
1672     (source
1673      (origin
1674        (method git-fetch)
1675        (uri (git-reference
1676              (url "https://github.com/sharplispers/nibbles/")
1677              (commit (string-append "v" version))))
1678        (sha256
1679         (base32
1680          "1v7qfgpvdr6nz7v63dj69d26dis0kff3rd8xamr1llfdvza2pm8f"))
1681        (file-name (git-file-name "nibbles" version))))
1682     (build-system asdf-build-system/sbcl)
1683     (native-inputs
1684      ;; Tests only.
1685      `(("rt" ,sbcl-rt)))
1686     (synopsis "Common Lisp library for accessing octet-addressed blocks of data")
1687     (description
1688      "When dealing with network protocols and file formats, it's common to
1689 have to read or write 16-, 32-, or 64-bit datatypes in signed or unsigned
1690 flavors.  Common Lisp sort of supports this by specifying :element-type for
1691 streams, but that facility is underspecified and there's nothing similar for
1692 read/write from octet vectors.  What most people wind up doing is rolling their
1693 own small facility for their particular needs and calling it a day.
1694
1695 This library attempts to be comprehensive and centralize such
1696 facilities.  Functions to read 16-, 32-, and 64-bit quantities from octet
1697 vectors in signed or unsigned flavors are provided; these functions are also
1698 SETFable.  Since it's sometimes desirable to read/write directly from streams,
1699 functions for doing so are also provided.  On some implementations,
1700 reading/writing IEEE singles/doubles (i.e. single-float and double-float) will
1701 also be supported.")
1702     (home-page "https://github.com/sharplispers/nibbles")
1703     (license license:bsd-3)))
1704
1705 (define-public cl-nibbles
1706   (sbcl-package->cl-source-package sbcl-nibbles))
1707
1708 (define-public ecl-nibbles
1709   (sbcl-package->ecl-package sbcl-nibbles))
1710
1711 (define-public sbcl-ironclad
1712   (package
1713     (name "sbcl-ironclad")
1714     (version "0.49")
1715     (source
1716      (origin
1717        (method git-fetch)
1718        (uri (git-reference
1719              (url "https://github.com/sharplispers/ironclad/")
1720              (commit (string-append "v" version))))
1721        (sha256
1722         (base32 "0kbzqg2aasrhjwy3nrzy2ddy809n1j045w4qkyc3r2syqd203d4q"))
1723        (file-name (git-file-name name version))))
1724     (build-system asdf-build-system/sbcl)
1725     (native-inputs
1726      ;; Tests only.
1727      `(("rt" ,sbcl-rt)))
1728     (inputs
1729      `(("bordeaux-threads" ,sbcl-bordeaux-threads)
1730        ("flexi-streams" ,sbcl-flexi-streams)
1731        ("trivial-garbage" ,sbcl-trivial-garbage)))
1732     (synopsis "Cryptographic toolkit written in Common Lisp")
1733     (description
1734      "Ironclad is a cryptography library written entirely in Common Lisp.
1735 It includes support for several popular ciphers, digests, MACs and public key
1736 cryptography algorithms.  For several implementations that support Gray
1737 streams, support is included for convenient stream wrappers.")
1738     (home-page "https://github.com/sharplispers/ironclad")
1739     (license license:bsd-3)))
1740
1741 (define-public cl-ironclad
1742   (sbcl-package->cl-source-package sbcl-ironclad))
1743
1744 (define-public ecl-ironclad
1745   (sbcl-package->ecl-package sbcl-ironclad))
1746
1747 (define-public sbcl-named-readtables
1748   (let ((commit "4dfb89fa1af6b305b6492b8af042f5190c11e9fc")
1749         (revision "1"))
1750     (package
1751       (name "sbcl-named-readtables")
1752       (version (string-append "0.9-" revision "." (string-take commit 7)))
1753       (source
1754        (origin
1755          (method git-fetch)
1756          (uri (git-reference
1757                (url "https://github.com/melisgl/named-readtables.git")
1758                (commit commit)))
1759          (sha256
1760           (base32 "083kgh5462iqbb4px6kq8s7sggvpvkm36hx4qi9rnaw53b6ilqkk"))
1761          (file-name (git-file-name "named-readtables" version))))
1762       (build-system asdf-build-system/sbcl)
1763       (arguments
1764        ;; Tests seem to be broken.
1765        `(#:tests? #f))
1766       (home-page "https://github.com/melisgl/named-readtables/")
1767       (synopsis "Library that creates a namespace for named readtables")
1768       (description "Named readtables is a library that creates a namespace for
1769 named readtables, which is akin to package namespacing in Common Lisp.")
1770       (license license:bsd-3))))
1771
1772 (define-public cl-named-readtables
1773   (sbcl-package->cl-source-package sbcl-named-readtables))
1774
1775 (define-public ecl-named-readtables
1776   (sbcl-package->ecl-package sbcl-named-readtables))
1777
1778 (define-public sbcl-pythonic-string-reader
1779   (let ((commit "47a70ba1e32362e03dad6ef8e6f36180b560f86a"))
1780     (package
1781       (name "sbcl-pythonic-string-reader")
1782       (version (git-version "0.0.0" "1" commit))
1783       (source
1784        (origin
1785          (method git-fetch)
1786          (uri (git-reference
1787                (url "https://github.com/smithzvk/pythonic-string-reader/")
1788                (commit commit)))
1789          (sha256
1790           (base32 "1b5iryqw8xsh36swckmz8rrngmc39k92si33fgy5pml3n9l5rq3j"))
1791          (file-name (git-file-name "pythonic-string-reader" version))))
1792       (build-system asdf-build-system/sbcl)
1793       (inputs
1794        `(("named-readtables" ,sbcl-named-readtables)))
1795       (home-page "https://github.com/smithzvk/pythonic-string-reader")
1796       (synopsis "Read table modification inspired by Python's three quote strings")
1797       (description "This piece of code sets up some reader macros that make it
1798 simpler to input string literals which contain backslashes and double quotes
1799 This is very useful for writing complicated docstrings and, as it turns out,
1800 writing code that contains string literals that contain code themselves.")
1801       (license license:bsd-3))))
1802
1803 (define-public cl-pythonic-string-reader
1804   (sbcl-package->cl-source-package sbcl-pythonic-string-reader))
1805
1806 (define-public ecl-pythonic-string-reader
1807   (sbcl-package->ecl-package sbcl-pythonic-string-reader))
1808
1809 ;; SLIME does not have a ASDF system definition to build all of Swank.  As a
1810 ;; result, the asdf-build-system/sbcl will produce an almost empty package.
1811 ;; Some work was done to fix this at
1812 ;; https://github.com/sionescu/slime/tree/swank-asdf but it was never merged
1813 ;; and is now lagging behind.  Building SBCL fasls might not be worth the
1814 ;; hassle, so let's just ship the source then.
1815 (define-public cl-slime-swank
1816   (package
1817     (name "cl-slime-swank")
1818     (version "2.24")
1819     (source
1820      (origin
1821        (file-name (string-append name "-" version ".tar.gz"))
1822        (method git-fetch)
1823        (uri (git-reference
1824              (url "https://github.com/slime/slime/")
1825              (commit (string-append "v" version))))
1826        (sha256
1827         (base32
1828          "0js24x42m7b5iymb4rxz501dff19vav5pywnzv50b673rbkaaqvh"))))
1829     (build-system asdf-build-system/source)
1830     (home-page "https://github.com/slime/slime")
1831     (synopsis "Common Lisp Swank server")
1832     (description
1833      "This is only useful if you want to start a Swank server in a Lisp
1834 processes that doesn't run under Emacs.  Lisp processes created by
1835 @command{M-x slime} automatically start the server.")
1836     (license (list license:gpl2+ license:public-domain))))
1837
1838 (define-public sbcl-slime-swank
1839   (deprecated-package "sbcl-slime-swank" cl-slime-swank))
1840
1841 (define-public sbcl-mgl-pax
1842   (let ((commit "818448418d6b9de74620f606f5b23033c6082769"))
1843     (package
1844       (name "sbcl-mgl-pax")
1845       (version (git-version "0.0.0" "1" commit))
1846       (source
1847        (origin
1848          (method git-fetch)
1849          (uri (git-reference
1850                (url "https://github.com/melisgl/mgl-pax")
1851                (commit commit)))
1852          (sha256
1853           (base32
1854            "1p97zfkh130bdxqqxwaw2j9psv58751wakx7czbfpq410lg7dd7i"))
1855          (file-name (git-file-name "mgl-pax" version))))
1856       (build-system asdf-build-system/sbcl)
1857       (inputs
1858        `(("3bmd" ,sbcl-3bmd)
1859          ("3bmd-ext-code-blocks" ,sbcl-3bmd-ext-code-blocks)
1860          ("babel" ,sbcl-babel)
1861          ("cl-fad" ,sbcl-cl-fad)
1862          ("ironclad" ,sbcl-ironclad)
1863          ("named-readtables" ,sbcl-named-readtables)
1864          ("pythonic-string-reader" ,sbcl-pythonic-string-reader)))
1865       (propagated-inputs
1866        ;; Packages having mgl-pax as input complain that it can't find
1867        ;; swank if we put it in inputs, so let's put it in propageted-inputs.
1868        `(("swank" ,cl-slime-swank)))
1869       (synopsis "Exploratory programming environment and documentation generator")
1870       (description
1871        "PAX provides an extremely poor man's Explorable Programming
1872 environment.  Narrative primarily lives in so called sections that mix markdown
1873 docstrings with references to functions, variables, etc, all of which should
1874 probably have their own docstrings.
1875
1876 The primary focus is on making code easily explorable by using SLIME's
1877 @command{M-.} (@command{slime-edit-definition}).  See how to enable some
1878 fanciness in Emacs Integration.  Generating documentation from sections and all
1879 the referenced items in Markdown or HTML format is also implemented.
1880
1881 With the simplistic tools provided, one may accomplish similar effects as with
1882 Literate Programming, but documentation is generated from code, not vice versa
1883 and there is no support for chunking yet.  Code is first, code must look
1884 pretty, documentation is code.")
1885       (home-page "http://quotenil.com/")
1886       (license license:expat))))
1887
1888 (define-public cl-mgl-pax
1889   (sbcl-package->cl-source-package sbcl-mgl-pax))
1890
1891 (define-public ecl-mgl-pax
1892   (sbcl-package->ecl-package sbcl-mgl-pax))
1893
1894 (define-public sbcl-lisp-unit
1895   (let ((commit "89653a232626b67400bf9a941f9b367da38d3815"))
1896     (package
1897       (name "sbcl-lisp-unit")
1898       (version (git-version "0.0.0" "1" commit))
1899       (source
1900        (origin
1901          (method git-fetch)
1902          (uri (git-reference
1903                (url "https://github.com/OdonataResearchLLC/lisp-unit")
1904                (commit commit)))
1905          (sha256
1906           (base32
1907            "0p6gdmgr7p383nvd66c9y9fp2bjk4jx1lpa5p09g43hr9y9pp9ry"))
1908          (file-name (git-file-name "lisp-unit" version))))
1909       (build-system asdf-build-system/sbcl)
1910       (synopsis "Common Lisp Test framework inspired by JUnit to be simple of use")
1911       (description
1912        "@command{lisp-unit} is a Common Lisp library that supports unit
1913 testing.  It is an extension of the library written by Chris Riesbeck.")
1914       (home-page "https://github.com/OdonataResearchLLC/lisp-unit")
1915       (license license:expat))))
1916
1917 (define-public cl-lisp-unit
1918   (sbcl-package->cl-source-package sbcl-lisp-unit))
1919
1920 (define-public ecl-lisp-unit
1921   (sbcl-package->ecl-package sbcl-lisp-unit))
1922
1923 (define-public sbcl-anaphora
1924   (package
1925     (name "sbcl-anaphora")
1926     (version "0.9.6")
1927     (source
1928      (origin
1929        (method git-fetch)
1930        (uri (git-reference
1931              (url "https://github.com/tokenrove/anaphora")
1932              (commit version)))
1933        (sha256
1934         (base32
1935          "19wfrk3asimznkli0x2rfy637hwpdgqyvwj3vhq9x7vjvyf5vv6x"))
1936        (file-name (git-file-name "anaphora" version))))
1937     (build-system asdf-build-system/sbcl)
1938     (native-inputs
1939      `(("rt" ,sbcl-rt)))
1940     (synopsis "The anaphoric macro collection from Hell")
1941     (description
1942      "Anaphora is the anaphoric macro collection from Hell: it includes many
1943 new fiends in addition to old friends like @command{aif} and
1944 @command{awhen}.")
1945     (home-page "https://github.com/tokenrove/anaphora")
1946     (license license:public-domain)))
1947
1948 (define-public cl-anaphora
1949   (sbcl-package->cl-source-package sbcl-anaphora))
1950
1951 (define-public ecl-anaphora
1952   (sbcl-package->ecl-package sbcl-anaphora))
1953
1954 (define-public sbcl-lift
1955   (let ((commit "7d49a66c62759535624037826891152223d4206c"))
1956     (package
1957       (name "sbcl-lift")
1958       (version (git-version "1.7.1" "1" commit))
1959       (source
1960        (origin
1961          (method git-fetch)
1962          (uri (git-reference
1963                (url "https://github.com/gwkkwg/lift")
1964                (commit commit)))
1965          (sha256
1966           (base32
1967            "127v5avpz1i4m0lkaxqrq8hrl69rdazqaxf6s8awf0nd7wj2g4dp"))
1968          (file-name (git-file-name "lift" version))
1969          (modules '((guix build utils)))
1970          (snippet
1971           ;; Don't keep the bundled website
1972           `(begin
1973              (delete-file-recursively "website")
1974              #t))))
1975       (build-system asdf-build-system/sbcl)
1976       (arguments
1977        ;; The tests require a debugger, but we run with the debugger disabled.
1978        '(#:tests? #f))
1979       (synopsis "LIsp Framework for Testing")
1980       (description
1981        "The LIsp Framework for Testing (LIFT) is a unit and system test tool for LISP.
1982 Though inspired by SUnit and JUnit, it's built with Lisp in mind.  In LIFT,
1983 testcases are organized into hierarchical testsuites each of which can have
1984 its own fixture.  When run, a testcase can succeed, fail, or error.  LIFT
1985 supports randomized testing, benchmarking, profiling, and reporting.")
1986       (home-page "https://github.com/gwkkwg/lift")
1987       (license license:expat))))
1988
1989 (define-public cl-lift
1990   (sbcl-package->cl-source-package sbcl-lift))
1991
1992 (define-public ecl-lift
1993   (sbcl-package->ecl-package sbcl-lift))
1994
1995 (define-public sbcl-let-plus
1996   (let ((commit "5f14af61d501ecead02ec6b5a5c810efc0c9fdbb"))
1997     (package
1998       (name "sbcl-let-plus")
1999       (version (git-version "0.0.0" "1" commit))
2000       (source
2001        (origin
2002          (method git-fetch)
2003          (uri (git-reference
2004                (url "https://github.com/sharplispers/let-plus")
2005                (commit commit)))
2006          (sha256
2007           (base32
2008            "0i050ca2iys9f5mb7dgqgqdxfnc3b0rnjdwv95sqd490vkiwrsaj"))
2009          (file-name (git-file-name "let-plus" version))))
2010       (build-system asdf-build-system/sbcl)
2011       (inputs
2012        `(("alexandria" ,sbcl-alexandria)
2013          ("anaphora" ,sbcl-anaphora)))
2014       (native-inputs
2015        `(("lift" ,sbcl-lift)))
2016       (synopsis "Destructuring extension of let*")
2017       (description
2018        "This library implements the let+ macro, which is a dectructuring
2019 extension of let*.  It features:
2020
2021 @itemize
2022 @item Clean, consistent syntax and small implementation (less than 300 LOC,
2023 not counting tests)
2024 @item Placeholder macros allow editor hints and syntax highlighting
2025 @item @command{&ign} for ignored values (in forms where that makes sense)
2026 @item Very easy to extend
2027 @end itemize\n")
2028       (home-page "https://github.com/sharplispers/let-plus")
2029       (license license:boost1.0))))
2030
2031 (define-public cl-let-plus
2032   (sbcl-package->cl-source-package sbcl-let-plus))
2033
2034 (define-public ecl-let-plus
2035   (sbcl-package->ecl-package sbcl-let-plus))
2036
2037 (define-public sbcl-cl-colors
2038   (let ((commit "827410584553f5c717eec6182343b7605f707f75"))
2039     (package
2040       (name "sbcl-cl-colors")
2041       (version (git-version "0.0.0" "1" commit))
2042       (source
2043        (origin
2044          (method git-fetch)
2045          (uri (git-reference
2046                (url "https://github.com/tpapp/cl-colors")
2047                (commit commit)))
2048          (sha256
2049           (base32
2050            "0l446lday4hybsm9bq3jli97fvv8jb1d33abg79vbylpwjmf3y9a"))
2051          (file-name (git-file-name "cl-colors" version))))
2052       (build-system asdf-build-system/sbcl)
2053       (inputs
2054        `(("alexandria" ,sbcl-alexandria)
2055          ("let-plus" ,sbcl-let-plus)))
2056       (synopsis "Simple color library for Common Lisp")
2057       (description
2058        "This is a very simple color library for Common Lisp, providing
2059
2060 @itemize
2061 @item Types for representing colors in HSV and RGB spaces.
2062 @item Simple conversion functions between the above types (and also
2063 hexadecimal representation for RGB).
2064 @item Some predefined colors (currently X11 color names – of course the
2065 library does not depend on X11).Because color in your terminal is nice.
2066 @end itemize
2067
2068 This library is no longer supported by its author.")
2069       (home-page "https://github.com/tpapp/cl-colors")
2070       (license license:boost1.0))))
2071
2072 (define-public cl-colors
2073   (sbcl-package->cl-source-package sbcl-cl-colors))
2074
2075 (define-public ecl-cl-colors
2076   (sbcl-package->ecl-package sbcl-cl-colors))
2077
2078 (define-public sbcl-cl-ansi-text
2079   (let ((commit "53badf7878f27f22f2d4a2a43e6df458e43acbe9"))
2080     (package
2081       (name "sbcl-cl-ansi-text")
2082       (version (git-version "1.0.0" "1" commit))
2083       (source
2084        (origin
2085          (method git-fetch)
2086          (uri (git-reference
2087                (url "https://github.com/pnathan/cl-ansi-text")
2088                (commit commit)))
2089          (sha256
2090           (base32
2091            "11i27n0dbz5lmygiw65zzr8lx0rac6b6yysqranphn31wls6ja3v"))
2092          (file-name (git-file-name "cl-ansi-text" version))))
2093       (build-system asdf-build-system/sbcl)
2094       (inputs
2095        `(("alexandria" ,sbcl-alexandria)
2096          ("cl-colors" ,sbcl-cl-colors)))
2097       (native-inputs
2098        `(("fiveam" ,sbcl-fiveam)))
2099       (synopsis "ANSI terminal color implementation for Common Lisp")
2100       (description
2101        "@command{cl-ansi-text} provides utilities which enable printing to an
2102 ANSI terminal with colored text.  It provides the macro @command{with-color}
2103 which causes everything printed in the body to be displayed with the provided
2104 color.  It further provides functions which will print the argument with the
2105 named color.")
2106       (home-page "https://github.com/pnathan/cl-ansi-text")
2107       (license license:llgpl))))
2108
2109 (define-public cl-ansi-text
2110   (sbcl-package->cl-source-package sbcl-cl-ansi-text))
2111
2112 (define-public ecl-cl-ansi-text
2113   (sbcl-package->ecl-package sbcl-cl-ansi-text))
2114
2115 (define-public sbcl-prove-asdf
2116   (let ((commit "4f9122bd393e63c5c70c1fba23070622317cfaa0"))
2117     (package
2118       (name "sbcl-prove-asdf")
2119       (version (git-version "1.0.0" "1" commit))
2120       (source
2121        (origin
2122          (method git-fetch)
2123          (uri (git-reference
2124                (url "https://github.com/fukamachi/prove")
2125                (commit commit)))
2126          (sha256
2127           (base32
2128            "07sbfw459z8bbjvx1qlmfa8qk2mvbjnnzi2mi0x72blaj8bkl4vc"))
2129          (file-name (git-file-name "prove" version))))
2130       (build-system asdf-build-system/sbcl)
2131       (arguments
2132        `(#:asd-file "prove-asdf.asd"))
2133       (synopsis "Test requirement for the Common Lisp 'prove' library")
2134       (description
2135        "Test requirement for the Common Lisp @command{prove} library.")
2136       (home-page "https://github.com/fukamachi/prove")
2137       (license license:expat))))
2138
2139 (define-public cl-prove-asdf
2140   (sbcl-package->cl-source-package sbcl-prove-asdf))
2141
2142 (define-public ecl-prove-asdf
2143   (sbcl-package->ecl-package sbcl-prove-asdf))
2144
2145 (define-public sbcl-prove
2146   (package
2147     (inherit sbcl-prove-asdf)
2148     (name "sbcl-prove")
2149     (inputs
2150      `(("alexandria" ,sbcl-alexandria)
2151        ("cl-ppcre" ,sbcl-cl-ppcre)
2152        ("cl-ansi-text" ,sbcl-cl-ansi-text)))
2153     (native-inputs
2154      `(("prove-asdf" ,sbcl-prove-asdf)))
2155     (arguments
2156      `(#:asd-file "prove.asd"))
2157     (synopsis "Yet another unit testing framework for Common Lisp")
2158     (description
2159      "This project was originally called @command{cl-test-more}.
2160 @command{prove} is yet another unit testing framework for Common Lisp.  The
2161 advantages of @command{prove} are:
2162
2163 @itemize
2164 @item Various simple functions for testing and informative error messages
2165 @item ASDF integration
2166 @item Extensible test reporters
2167 @item Colorizes the report if it's available (note for SLIME)
2168 @item Reports test durations
2169 @end itemize\n")))
2170
2171 (define-public cl-prove
2172   (sbcl-package->cl-source-package sbcl-prove))
2173
2174 (define-public ecl-prove
2175   (sbcl-package->ecl-package sbcl-prove))
2176
2177 (define-public sbcl-proc-parse
2178   (let ((commit "ac3636834d561bdc2686c956dbd82494537285fd"))
2179     (package
2180       (name "sbcl-proc-parse")
2181       (version (git-version "0.0.0" "1" commit))
2182       (source
2183        (origin
2184          (method git-fetch)
2185          (uri (git-reference
2186                (url "https://github.com/fukamachi/proc-parse")
2187                (commit commit)))
2188          (sha256
2189           (base32
2190            "06rnl0h4cx6xv2wj3jczmmcxqn2703inmmvg1s4npbghmijsybfh"))
2191          (file-name (git-file-name "proc-parse" version))))
2192       (build-system asdf-build-system/sbcl)
2193       (inputs
2194        `(("alexandria" ,sbcl-alexandria)
2195          ("babel" ,sbcl-babel)))
2196       (native-inputs
2197        `(("prove" ,sbcl-prove)
2198          ("prove-asdf" ,sbcl-prove-asdf)))
2199       (arguments
2200        ;; TODO: Tests don't find "proc-parse-test", why?
2201        `(#:tests? #f))
2202       (synopsis "Procedural vector parser")
2203       (description
2204        "This is a string/octets parser library for Common Lisp with speed and
2205 readability in mind.  Unlike other libraries, the code is not a
2206 pattern-matching-like, but a char-by-char procedural parser.")
2207       (home-page "https://github.com/fukamachi/proc-parse")
2208       (license license:bsd-2))))
2209
2210 (define-public cl-proc-parse
2211   (sbcl-package->cl-source-package sbcl-proc-parse))
2212
2213 (define-public ecl-proc-parse
2214   (sbcl-package->ecl-package sbcl-proc-parse))
2215
2216 (define-public sbcl-parse-float
2217   (let ((commit "2aae569f2a4b2eb3bfb5401a959425dcf151b09c"))
2218     (package
2219       (name "sbcl-parse-float")
2220       (version (git-version "0.0.0" "1" commit))
2221       (source
2222        (origin
2223          (method git-fetch)
2224          (uri (git-reference
2225                (url "https://github.com/soemraws/parse-float")
2226                (commit commit)))
2227          (sha256
2228           (base32
2229            "08xw8cchhmqcc0byng69m3f5a2izc9y2290jzz2k0qrbibp1fdk7"))
2230          (file-name (git-file-name "proc-parse" version))))
2231       (build-system asdf-build-system/sbcl)
2232       (inputs
2233        `(("alexandria" ,sbcl-alexandria)
2234          ("babel" ,sbcl-babel)))
2235       (native-inputs
2236        `(("prove" ,sbcl-prove)
2237          ("prove-asdf" ,sbcl-prove-asdf)))
2238       (arguments
2239        ;; TODO: Tests don't find "proc-parse-test", why?
2240        `(#:tests? #f))
2241       (synopsis "Parse a floating point value from a string in Common Lisp")
2242       (description
2243        "This package exports the following function to parse floating-point
2244 values from a string in Common Lisp.")
2245       (home-page "https://github.com/soemraws/parse-float")
2246       (license license:public-domain))))
2247
2248 (define-public cl-parse-float
2249   (sbcl-package->cl-source-package sbcl-parse-float))
2250
2251 (define-public ecl-parse-float
2252   (sbcl-package->ecl-package sbcl-parse-float))
2253
2254 (define-public sbcl-ascii-strings
2255   (let ((revision "1")
2256         (changeset "5048480a61243e6f1b02884012c8f25cdbee6d97"))
2257     (package
2258       (name "sbcl-ascii-strings")
2259       (version (string-append "0-" revision "." (string-take changeset 7)))
2260       (source
2261        (origin
2262          (method hg-fetch)
2263          (uri (hg-reference
2264                (url "https://bitbucket.org/vityok/cl-string-match/")
2265                (changeset changeset)))
2266          (sha256
2267           (base32
2268            "01wn5qx562w43ssy92xlfgv79w7p0nv0wbl76mpmba131n9ziq2y"))
2269          (file-name (git-file-name "cl-string-match" version))))
2270       (build-system asdf-build-system/sbcl)
2271       (inputs
2272        `(("alexandria" ,sbcl-alexandria)
2273          ("babel" ,sbcl-babel)))
2274       (arguments
2275        `(#:asd-file "ascii-strings.asd"))
2276       (synopsis "Operations on ASCII strings")
2277       (description
2278        "Operations on ASCII strings.  Essentially this can be any kind of
2279 single-byte encoded strings.")
2280       (home-page "https://bitbucket.org/vityok/cl-string-match/")
2281       (license license:bsd-3))))
2282
2283 (define-public cl-ascii-strings
2284   (sbcl-package->cl-source-package sbcl-ascii-strings))
2285
2286 (define-public ecl-ascii-strings
2287   (sbcl-package->ecl-package sbcl-ascii-strings))
2288
2289 (define-public sbcl-simple-scanf
2290   (package
2291     (inherit sbcl-ascii-strings)
2292     (name "sbcl-simple-scanf")
2293     (inputs
2294      `(("alexandria" ,sbcl-alexandria)
2295        ("iterate" ,sbcl-iterate)
2296        ("proc-parse" ,sbcl-proc-parse)
2297        ("parse-float" ,sbcl-parse-float)))
2298     (arguments
2299      `(#:asd-file "simple-scanf.asd"))
2300     (synopsis "Simple scanf-like functionality implementation")
2301     (description
2302      "A simple scanf-like functionality implementation.")))
2303
2304 (define-public cl-simple-scanf
2305   (sbcl-package->cl-source-package sbcl-simple-scanf))
2306
2307 (define-public ecl-simple-scanf
2308   (sbcl-package->ecl-package sbcl-simple-scanf))
2309
2310 (define-public sbcl-cl-string-match
2311   (package
2312     (inherit sbcl-ascii-strings)
2313     (name "sbcl-cl-string-match")
2314     (inputs
2315      `(("alexandria" ,sbcl-alexandria)
2316        ("ascii-strings" ,sbcl-ascii-strings)
2317        ("yacc" ,sbcl-cl-yacc)
2318        ("jpl-util" ,sbcl-jpl-util)
2319        ("jpl-queues" ,sbcl-jpl-queues)
2320        ("mgl-pax" ,sbcl-mgl-pax)
2321        ("iterate" ,sbcl-iterate)))
2322     ;; TODO: Tests are not evaluated properly.
2323     (native-inputs
2324      ;; For testing:
2325      `(("lisp-unit" ,sbcl-lisp-unit)
2326        ("simple-scanf" ,sbcl-simple-scanf)))
2327     (arguments
2328      `(#:tests? #f
2329        #:asd-file "cl-string-match.asd"))
2330     (synopsis "Portable, dependency-free set of utilities to manipulate strings in Common Lisp")
2331     (description
2332      "@command{cl-strings} is a small, portable, dependency-free set of
2333 utilities that make it even easier to manipulate text in Common Lisp.  It has
2334 100% test coverage and works at least on sbcl, ecl, ccl, abcl and clisp.")))
2335
2336 (define-public cl-string-match
2337   (sbcl-package->cl-source-package sbcl-cl-string-match))
2338
2339 (define-public ecl-cl-string-match
2340   (sbcl-package->ecl-package sbcl-cl-string-match))
2341
2342 (define-public sbcl-ptester
2343   (let ((commit "fe69fde54f4bce00ce577feb918796c293fc7253")
2344         (revision "1"))
2345     (package
2346       (name "sbcl-ptester")
2347       (version (git-version "2.1.3" revision commit))
2348       (source
2349        (origin
2350          (method git-fetch)
2351          (uri (git-reference
2352                (url "http://git.kpe.io/ptester.git")
2353                (commit commit)))
2354          (file-name (git-file-name name version))
2355          (sha256
2356           (base32 "1l0lfl7cdnr2qf4zh38hi4llxg22c49zkm639bdkmvlkzwj3ndwf"))))
2357       (build-system asdf-build-system/sbcl)
2358       (home-page "http://quickdocs.org/ptester/")
2359       (synopsis "Portable test harness package")
2360       (description
2361        "@command{ptester} is a portable testing framework based on Franz's
2362 tester module.")
2363       (license license:llgpl))))
2364
2365 (define-public cl-ptester
2366   (sbcl-package->cl-source-package sbcl-ptester))
2367
2368 (define-public ecl-ptester
2369   (sbcl-package->ecl-package sbcl-ptester))
2370
2371 (define-public sbcl-puri
2372   (let ((commit "ef5afb9e5286c8e952d4344f019c1a636a717b97")
2373         (revision "1"))
2374     (package
2375       (name "sbcl-puri")
2376       (version (git-version "1.5.7" revision commit))
2377       (source
2378        (origin
2379          (method git-fetch)
2380          (uri (git-reference
2381                (url "http://git.kpe.io/puri.git")
2382                (commit commit)))
2383          (file-name (git-file-name name version))
2384          (sha256
2385           (base32 "1vm25pdl92laj72p5vyd538kf3cjy2655z6bdc99h20ana2p231s"))))
2386       (build-system asdf-build-system/sbcl)
2387       (native-inputs
2388        `(("ptester" ,sbcl-ptester)))
2389       (home-page "http://quickdocs.org/puri/")
2390       (synopsis "Portable URI Library")
2391       (description
2392        "This is a portable Universal Resource Identifier library for Common
2393 Lisp programs.  It parses URI according to the RFC 2396 specification.")
2394       (license license:llgpl))))
2395
2396 (define-public cl-puri
2397   (sbcl-package->cl-source-package sbcl-puri))
2398
2399 (define-public ecl-puri
2400   (sbcl-package->ecl-package sbcl-puri))
2401
2402 (define-public sbcl-queues
2403   (let ((commit "47d4da65e9ea20953b74aeeab7e89a831b66bc94"))
2404     (package
2405       (name "sbcl-queues")
2406       (version (git-version "0.0.0" "1" commit))
2407       (source
2408        (origin
2409          (method git-fetch)
2410          (uri (git-reference
2411                (url "https://github.com/oconnore/queues")
2412                (commit commit)))
2413          (file-name (git-file-name "queues" version))
2414          (sha256
2415           (base32
2416            "0wdhfnzi4v6d97pggzj2aw55si94w4327br94jrmyvwf351wqjvv"))))
2417       (build-system asdf-build-system/sbcl)
2418       (home-page "https://github.com/oconnore/queues")
2419       (synopsis "Common Lisp queue library")
2420       (description
2421        "This is a simple queue library for Common Lisp with features such as
2422 non-consing thread safe queues and fibonacci priority queues.")
2423       (license license:expat))))
2424
2425 (define-public cl-queues
2426   (sbcl-package->cl-source-package sbcl-queues))
2427
2428 (define-public ecl-queues
2429   (sbcl-package->ecl-package sbcl-queues))
2430
2431 (define-public sbcl-queues.simple-queue
2432   (package
2433     (inherit sbcl-queues)
2434     (name "sbcl-queues.simple-queue")
2435     (inputs
2436      `(("sbcl-queues" ,sbcl-queues)))
2437     (arguments
2438      `(#:asd-file "queues.simple-queue.asd"))
2439     (synopsis "Simple queue implementation")
2440     (description
2441      "This is a simple queue library for Common Lisp with features such as
2442 non-consing thread safe queues and fibonacci priority queues.")
2443     (license license:expat)))
2444
2445 (define-public cl-queues.simple-queue
2446   (sbcl-package->cl-source-package sbcl-queues.simple-queue))
2447
2448 (define-public ecl-queues.simple-queue
2449   (sbcl-package->ecl-package sbcl-queues.simple-queue))
2450
2451 (define-public sbcl-queues.simple-cqueue
2452   (package
2453     (inherit sbcl-queues)
2454     (name "sbcl-queues.simple-cqueue")
2455     (inputs
2456      `(("sbcl-queues" ,sbcl-queues)
2457        ("sbcl-queues.simple-queue" ,sbcl-queues.simple-queue)
2458        ("bordeaux-threads" ,sbcl-bordeaux-threads)))
2459     (arguments
2460      `(#:asd-file "queues.simple-cqueue.asd"))
2461     (synopsis "Thread safe queue implementation")
2462     (description
2463      "This is a simple queue library for Common Lisp with features such as
2464 non-consing thread safe queues and fibonacci priority queues.")
2465     (license license:expat)))
2466
2467 (define-public cl-queues.simple-cqueue
2468   (sbcl-package->cl-source-package sbcl-queues.simple-cqueue))
2469
2470 (define-public ecl-queues.simple-cqueue
2471   (sbcl-package->ecl-package sbcl-queues.simple-cqueue))
2472
2473 (define-public sbcl-queues.priority-queue
2474   (package
2475     (inherit sbcl-queues)
2476     (name "sbcl-queues.priority-queue")
2477     (inputs
2478      `(("sbcl-queues" ,sbcl-queues)))
2479     (arguments
2480      `(#:asd-file "queues.priority-queue.asd"))
2481     (synopsis "Priority queue (Fibonacci) implementation")
2482     (description
2483      "This is a simple queue library for Common Lisp with features such as
2484 non-consing thread safe queues and fibonacci priority queues.")
2485     (license license:expat)))
2486
2487 (define-public cl-queues.priority-queue
2488   (sbcl-package->cl-source-package sbcl-queues.priority-queue))
2489
2490 (define-public ecl-queues.priority-queue
2491   (sbcl-package->ecl-package sbcl-queues.priority-queue))
2492
2493 (define-public sbcl-queues.priority-cqueue
2494   (package
2495     (inherit sbcl-queues)
2496     (name "sbcl-queues.priority-cqueue")
2497     (inputs
2498      `(("sbcl-queues" ,sbcl-queues)
2499        ("sbcl-queues.priority-queue" ,sbcl-queues.priority-queue)
2500        ("bordeaux-threads" ,sbcl-bordeaux-threads)))
2501     (arguments
2502      `(#:asd-file "queues.priority-cqueue.asd"))
2503     (synopsis "Thread safe fibonacci priority queue implementation")
2504     (description
2505      "This is a simple queue library for Common Lisp with features such as
2506 non-consing thread safe queues and fibonacci priority queues.")
2507     (license license:expat)))
2508
2509 (define-public cl-queues.priority-cqueue
2510   (sbcl-package->cl-source-package sbcl-queues.priority-cqueue))
2511
2512 (define-public ecl-queues.priority-cqueue
2513   (sbcl-package->ecl-package sbcl-queues.priority-cqueue))
2514
2515 (define sbcl-cffi-bootstrap
2516   (package
2517     (name "sbcl-cffi-bootstrap")
2518     (version "0.21.0")
2519     (source
2520      (origin
2521        (method git-fetch)
2522        (uri (git-reference
2523              (url "https://github.com/cffi/cffi.git")
2524              (commit (string-append "v" version))))
2525        (file-name (git-file-name "cffi-bootstrap" version))
2526        (sha256
2527         (base32 "1qalargz9bhp850qv60ffwpdqi4xirzar4l3g6qcg8yc6xqf2cjk"))))
2528     (build-system asdf-build-system/sbcl)
2529     (inputs
2530      `(("libffi" ,libffi)
2531        ("alexandria" ,sbcl-alexandria)
2532        ("babel" ,sbcl-babel)
2533        ("trivial-features" ,sbcl-trivial-features)))
2534     (native-inputs
2535      `(("pkg-config" ,pkg-config)))
2536     (arguments
2537      '(#:phases
2538        (modify-phases %standard-phases
2539          (add-after 'unpack 'fix-paths
2540            (lambda* (#:key inputs #:allow-other-keys)
2541              (substitute* "libffi/libffi.lisp"
2542                (("libffi.so.6" all) (string-append
2543                                      (assoc-ref inputs "libffi")
2544                                      "/lib/" all)))
2545              (substitute* "toolchain/c-toolchain.lisp"
2546                (("\"cc\"") (format #f "~S" (which "gcc")))))))
2547        #:asd-system-name "cffi"
2548        #:tests? #f))
2549     (home-page "https://common-lisp.net/project/cffi/")
2550     (synopsis "Common Foreign Function Interface for Common Lisp")
2551     (description "The Common Foreign Function Interface (CFFI)
2552 purports to be a portable foreign function interface for Common Lisp.
2553 The CFFI library is composed of a Lisp-implementation-specific backend
2554 in the CFFI-SYS package, and a portable frontend in the CFFI
2555 package.")
2556     (license license:expat)))
2557
2558 (define-public sbcl-cffi-toolchain
2559   (package
2560     (inherit sbcl-cffi-bootstrap)
2561     (name "sbcl-cffi-toolchain")
2562     (inputs
2563      `(("libffi" ,libffi)
2564        ("sbcl-cffi" ,sbcl-cffi-bootstrap)))
2565     (arguments
2566      (substitute-keyword-arguments (package-arguments sbcl-cffi-bootstrap)
2567        ((#:asd-system-name _) #f)
2568        ((#:tests? _) #t)))))
2569
2570 (define-public sbcl-cffi-libffi
2571   (package
2572     (inherit sbcl-cffi-toolchain)
2573     (name "sbcl-cffi-libffi")
2574     (inputs
2575      `(("cffi" ,sbcl-cffi-bootstrap)
2576        ("cffi-grovel" ,sbcl-cffi-grovel)
2577        ("trivial-features" ,sbcl-trivial-features)
2578        ("libffi" ,libffi)))))
2579
2580 (define-public sbcl-cffi-grovel
2581   (package
2582     (inherit sbcl-cffi-toolchain)
2583     (name "sbcl-cffi-grovel")
2584     (inputs
2585      `(("libffi" ,libffi)
2586        ("cffi" ,sbcl-cffi-bootstrap)
2587        ("cffi-toolchain" ,sbcl-cffi-toolchain)
2588        ("alexandria" ,sbcl-alexandria)))
2589     (arguments
2590      (substitute-keyword-arguments (package-arguments sbcl-cffi-toolchain)
2591        ((#:phases phases)
2592         `(modify-phases ,phases
2593            (add-after 'build 'install-headers
2594              (lambda* (#:key outputs #:allow-other-keys)
2595                (install-file "grovel/common.h"
2596                              (string-append
2597                               (assoc-ref outputs "out")
2598                               "/include/grovel"))))))))))
2599
2600 (define-public sbcl-cffi
2601   (package
2602     (inherit sbcl-cffi-toolchain)
2603     (name "sbcl-cffi")
2604     (inputs (package-inputs sbcl-cffi-bootstrap))
2605     (native-inputs
2606      `(("cffi-grovel" ,sbcl-cffi-grovel)
2607        ("cffi-libffi" ,sbcl-cffi-libffi)
2608        ("rt" ,sbcl-rt)
2609        ("bordeaux-threads" ,sbcl-bordeaux-threads)
2610        ,@(package-native-inputs sbcl-cffi-bootstrap)))))
2611
2612 (define-public cl-cffi
2613   (sbcl-package->cl-source-package sbcl-cffi))
2614
2615 (define-public sbcl-cffi-uffi-compat
2616   (package
2617     (inherit sbcl-cffi-toolchain)
2618     (name "sbcl-cffi-uffi-compat")
2619     (native-inputs
2620      `(,@(package-inputs sbcl-cffi-bootstrap))) ; For fix-paths phase
2621     (inputs
2622      `(("cffi" ,sbcl-cffi)))
2623     (synopsis "UFFI Compatibility Layer for CFFI")))
2624
2625 (define-public cl-cffi-uffi-compat
2626   (sbcl-package->cl-source-package sbcl-cffi-uffi-compat))
2627
2628 (define-public sbcl-cl-sqlite
2629   (let ((commit "c738e66d4266ef63a1debc4ef4a1b871a068c112"))
2630     (package
2631       (name "sbcl-cl-sqlite")
2632       (version (git-version "0.2" "1" commit))
2633       (source
2634        (origin
2635          (method git-fetch)
2636          (uri (git-reference
2637                (url "https://github.com/dmitryvk/cl-sqlite")
2638                (commit commit)))
2639          (file-name (git-file-name "cl-sqlite" version))
2640          (sha256
2641           (base32
2642            "1ng45k1hdb84sqjryrfx93g66bsbybmpy301wd0fdybnc5jzr36q"))))
2643       (build-system asdf-build-system/sbcl)
2644       (inputs
2645        `(("iterate" ,sbcl-iterate)
2646          ("cffi" ,sbcl-cffi)
2647          ("sqlite" ,sqlite)))
2648       (native-inputs
2649        `(("fiveam" ,sbcl-fiveam)
2650          ("bordeaux-threads" ,sbcl-bordeaux-threads)))
2651       (arguments
2652        `(#:tests? #f                    ; Upstream seems to have issues with tests: https://github.com/dmitryvk/cl-sqlite/issues/7
2653          #:asd-file "sqlite.asd"
2654          #:asd-system-name "sqlite"
2655          #:phases
2656          (modify-phases %standard-phases
2657            (add-after 'unpack 'fix-paths
2658              (lambda* (#:key inputs #:allow-other-keys)
2659                (substitute* "sqlite-ffi.lisp"
2660                  (("libsqlite3" all) (string-append
2661                                       (assoc-ref inputs "sqlite")"/lib/" all))))))))
2662       (home-page "https://common-lisp.net/project/cl-sqlite/")
2663       (synopsis "Common Lisp binding for SQLite")
2664       (description
2665        "The @command{cl-sqlite} package is an interface to the SQLite embedded
2666 relational database engine.")
2667       (license license:public-domain))))
2668
2669 (define-public cl-sqlite
2670   (sbcl-package->cl-source-package sbcl-cl-sqlite))
2671
2672 (define-public sbcl-parenscript
2673   (let ((commit "061d8e286c81c3f45c84fb2b11ee7d83f590a8f8"))
2674     (package
2675       (name "sbcl-parenscript")
2676       (version (git-version "2.6" "1" commit))
2677       (source
2678        (origin
2679          (method git-fetch)
2680          (uri (git-reference
2681                (url "https://gitlab.common-lisp.net/parenscript/parenscript")
2682                (commit commit)))
2683          (file-name (git-file-name "parenscript" version))
2684          (sha256
2685           (base32
2686            "1kbhgsjbikc73m5cwdp4d4fdafyqcr1b7b630qjrziql0nh6mi3k"))))
2687       (build-system asdf-build-system/sbcl)
2688       (inputs
2689        `(("cl-ppcre" ,sbcl-cl-ppcre)
2690          ("anaphora" ,sbcl-anaphora)
2691          ("named-readtables" ,sbcl-named-readtables)))
2692       (home-page "https://common-lisp.net/project/parenscript/")
2693       (synopsis "Translator from a subset of Common Lisp to JavaScript")
2694       (description
2695        "Parenscript is a translator from an extended subset of Common Lisp to
2696 JavaScript.  Parenscript code can run almost identically on both the
2697 browser (as JavaScript) and server (as Common Lisp).
2698
2699 Parenscript code is treated the same way as Common Lisp code, making the full
2700 power of Lisp macros available for JavaScript.  This provides a web
2701 development environment that is unmatched in its ability to reduce code
2702 duplication and provide advanced meta-programming facilities to web
2703 developers.
2704
2705 At the same time, Parenscript is different from almost all other \"language
2706 X\" to JavaScript translators in that it imposes almost no overhead:
2707
2708 @itemize
2709 @item No run-time dependencies: Any piece of Parenscript code is runnable
2710 as-is.  There are no JavaScript files to include.
2711 @item Native types: Parenscript works entirely with native JavaScript data
2712 types.  There are no new types introduced, and object prototypes are not
2713 touched.
2714 @item Native calling convention: Any JavaScript code can be called without the
2715 need for bindings.  Likewise, Parenscript can be used to make efficient,
2716 self-contained JavaScript libraries.
2717 @item Readable code: Parenscript generates concise, formatted, idiomatic
2718 JavaScript code.  Identifier names are preserved.  This enables seamless
2719 debugging in tools like Firebug.
2720 @item Efficiency: Parenscript introduces minimal overhead for advanced Common
2721 Lisp features.  The generated code is almost as fast as hand-written
2722 JavaScript.
2723 @end itemize\n")
2724       (license license:bsd-3))))
2725
2726 (define-public cl-parenscript
2727   (sbcl-package->cl-source-package sbcl-parenscript))
2728
2729 (define-public ecl-parenscript
2730   (sbcl-package->ecl-package sbcl-parenscript))
2731
2732 (define-public sbcl-cl-json
2733   (let ((commit "6dfebb9540bfc3cc33582d0c03c9ec27cb913e79"))
2734     (package
2735       (name "sbcl-cl-json")
2736       (version (git-version "0.5" "1" commit))
2737       (source
2738        (origin
2739          (method git-fetch)
2740          (uri (git-reference
2741                (url "https://github.com/hankhero/cl-json")
2742                (commit commit)))
2743          (file-name (git-file-name "cl-json" version))
2744          (sha256
2745           (base32
2746            "0fx3m3x3s5ji950yzpazz4s0img3l6b3d6l3jrfjv0lr702496lh"))))
2747       (build-system asdf-build-system/sbcl)
2748       (native-inputs
2749        `(("fiveam" ,sbcl-fiveam)))
2750       (home-page "https://github.com/hankhero/cl-json")
2751       (synopsis "JSON encoder and decoder for Common-Lisp")
2752       (description
2753        "@command{cl-json} provides an encoder of Lisp objects to JSON format
2754 and a corresponding decoder of JSON data to Lisp objects.  Both the encoder
2755 and the decoder are highly customizable; at the same time, the default
2756 settings ensure a very simple mode of operation, similar to that provided by
2757 @command{yason} or @command{st-json}.")
2758       (license license:expat))))
2759
2760 (define-public cl-json
2761   (sbcl-package->cl-source-package sbcl-cl-json))
2762
2763 (define-public ecl-cl-json
2764   (sbcl-package->ecl-package sbcl-cl-json))
2765
2766 (define-public sbcl-unix-opts
2767   (package
2768     (name "sbcl-unix-opts")
2769     (version "0.1.7")
2770     (source
2771      (origin
2772        (method git-fetch)
2773        (uri (git-reference
2774              (url "https://github.com/libre-man/unix-opts")
2775              (commit version)))
2776        (file-name (git-file-name "unix-opts" version))
2777        (sha256
2778         (base32
2779          "08djdi1ard09fijb7w9bdmhmwd98b1hzmcnjw9fqjiqa0g3b44rr"))))
2780     (build-system asdf-build-system/sbcl)
2781     (home-page "https://github.com/hankhero/cl-json")
2782     (synopsis "Unix-style command line options parser")
2783     (description
2784      "This is a minimalistic parser of command line options.  The main
2785 advantage of the library is the ability to concisely define command line
2786 options once and then use this definition for parsing and extraction of
2787 command line arguments, as well as printing description of command line
2788 options (you get --help for free).  This way you don't need to repeat
2789 yourself.  Also, @command{unix-opts} doesn't depend on anything and
2790 precisely controls the behavior of the parser via Common Lisp restarts.")
2791     (license license:expat)))
2792
2793 (define-public cl-unix-opts
2794   (sbcl-package->cl-source-package sbcl-unix-opts))
2795
2796 (define-public ecl-unix-opts
2797   (sbcl-package->ecl-package sbcl-unix-opts))
2798
2799 (define-public sbcl-trivial-garbage
2800   (package
2801     (name "sbcl-trivial-garbage")
2802     (version "0.21")
2803     (source
2804      (origin
2805        (method git-fetch)
2806        (uri (git-reference
2807              (url "https://github.com/trivial-garbage/trivial-garbage.git")
2808              (commit (string-append "v" version))))
2809        (file-name (git-file-name "trivial-garbage" version))
2810        (sha256
2811         (base32 "0122jicfg7pca1wxw8zak1n92h5friqy60988ns0ysksj3fphw9n"))))
2812     (build-system asdf-build-system/sbcl)
2813     (native-inputs
2814      `(("rt" ,sbcl-rt)))
2815     (home-page "https://common-lisp.net/project/trivial-garbage/")
2816     (synopsis "Portable GC-related APIs for Common Lisp")
2817     (description "@command{trivial-garbage} provides a portable API to
2818 finalizers, weak hash-tables and weak pointers on all major implementations of
2819 the Common Lisp programming language.")
2820     (license license:public-domain)))
2821
2822 (define-public cl-trivial-garbage
2823   (sbcl-package->cl-source-package sbcl-trivial-garbage))
2824
2825 (define-public ecl-trivial-garbage
2826   (sbcl-package->ecl-package sbcl-trivial-garbage))
2827
2828 (define-public sbcl-closer-mop
2829   (let ((commit "fac29ce90e3a46e1fc6cf182190e193526fa9dbc"))
2830     (package
2831       (name "sbcl-closer-mop")
2832       (version (git-version  "1.0.0" "1" commit))
2833       (source
2834        (origin
2835          (method git-fetch)
2836          (uri (git-reference
2837                (url "https://github.com/pcostanza/closer-mop")
2838                (commit commit)))
2839          (sha256
2840           (base32 "0hvh77y869h8fg9di5snyg85fxq6fdh9gj1igmx1g6j6j5x915dl"))
2841          (file-name (git-file-name "closer-mop" version ))))
2842       (build-system asdf-build-system/sbcl)
2843       (home-page "https://github.com/pcostanza/closer-mop")
2844       (synopsis "Rectifies absent or incorrect CLOS MOP features")
2845       (description "Closer to MOP is a compatibility layer that rectifies many
2846 of the absent or incorrect CLOS MOP features across a broad range of Common
2847 Lisp implementations.")
2848       (license license:expat))))
2849
2850 (define-public cl-closer-mop
2851   (sbcl-package->cl-source-package sbcl-closer-mop))
2852
2853 (define-public ecl-closer-mop
2854   (sbcl-package->ecl-package sbcl-closer-mop))
2855
2856 (define sbcl-cl-cffi-gtk-boot0
2857   (let ((commit "29443c5aaca975709df8025c4649366d882033cb"))
2858     (package
2859       (name "sbcl-cl-cffi-gtk-boot0")
2860       (version (git-version "0.11.2" "1" commit))
2861       (source
2862        (origin
2863          (method git-fetch)
2864          (uri (git-reference
2865                (url "https://github.com/Ferada/cl-cffi-gtk/")
2866                (commit commit)))
2867          (file-name (git-file-name "cl-cffi-gtk" version))
2868          (sha256
2869           (base32
2870            "0f6s92sf8xyzh1yksqx8bsy1sv0zmy0c13j3b8bavaba5hlxpxah"))))
2871       (build-system asdf-build-system/sbcl)
2872       (inputs
2873        `(("iterate" ,sbcl-iterate)
2874          ("cffi" ,sbcl-cffi)
2875          ("trivial-features" ,sbcl-trivial-features)))
2876       (home-page "https://github.com/Ferada/cl-cffi-gtk/")
2877       (synopsis "Common Lisp binding for GTK+3")
2878       (description
2879        "@command{cl-cffi-gtk} is a Lisp binding to GTK+ 3 (GIMP Toolkit) which
2880 is a library for creating graphical user interfaces.")
2881       (license license:lgpl3))))
2882
2883 (define-public sbcl-cl-cffi-gtk-glib
2884   (package
2885     (inherit sbcl-cl-cffi-gtk-boot0)
2886     (name "sbcl-cl-cffi-gtk-glib")
2887     (inputs
2888      `(("glib" ,glib)
2889        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2890     (arguments
2891      `(#:asd-file "glib/cl-cffi-gtk-glib.asd"
2892        #:phases
2893        (modify-phases %standard-phases
2894          (add-after 'unpack 'fix-paths
2895            (lambda* (#:key inputs #:allow-other-keys)
2896              (substitute* "glib/glib.init.lisp"
2897                (("libglib|libgthread" all) (string-append
2898                                             (assoc-ref inputs "glib") "/lib/" all))))))))))
2899
2900 (define-public sbcl-cl-cffi-gtk-gobject
2901   (package
2902     (inherit sbcl-cl-cffi-gtk-boot0)
2903     (name "sbcl-cl-cffi-gtk-gobject")
2904     (inputs
2905      `(("glib" ,glib)
2906        ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
2907        ("trivial-garbage" ,sbcl-trivial-garbage)
2908        ("bordeaux-threads" ,sbcl-bordeaux-threads)
2909        ("closer-mop" ,sbcl-closer-mop)
2910        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2911     (arguments
2912      `(#:asd-file "gobject/cl-cffi-gtk-gobject.asd"
2913        #:phases
2914        (modify-phases %standard-phases
2915          (add-after 'unpack 'fix-paths
2916            (lambda* (#:key inputs #:allow-other-keys)
2917              (substitute* "gobject/gobject.init.lisp"
2918                (("libgobject" all) (string-append
2919                                     (assoc-ref inputs "glib") "/lib/" all)))))
2920          (add-after 'install 'link-source
2921            ;; Since source is particularly heavy (16MiB+), let's reuse it
2922            ;; across the different components of cl-ffi-gtk.
2923            (lambda* (#:key inputs outputs #:allow-other-keys)
2924              (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
2925                                                "/share/common-lisp/sbcl-source/"
2926                                                "cl-cffi-gtk-glib"))
2927                    (out-source (string-append (assoc-ref outputs "out")
2928                                               "/share/common-lisp/sbcl-source/"
2929                                               "cl-cffi-gtk-gobject")))
2930                (delete-file-recursively out-source)
2931                (symlink glib-source out-source)
2932                #t))))))))
2933
2934 (define-public sbcl-cl-cffi-gtk-gio
2935   (package
2936     (inherit sbcl-cl-cffi-gtk-boot0)
2937     (name "sbcl-cl-cffi-gtk-gio")
2938     (inputs
2939      `(("glib" ,glib)
2940        ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
2941        ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
2942        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2943     (arguments
2944      `(#:asd-file "gio/cl-cffi-gtk-gio.asd"
2945        #:phases
2946        (modify-phases %standard-phases
2947          (add-after 'unpack 'fix-paths
2948            (lambda* (#:key inputs #:allow-other-keys)
2949              (substitute* "gio/gio.init.lisp"
2950                (("libgio" all)
2951                 (string-append
2952                  (assoc-ref inputs "glib") "/lib/" all)))))
2953          (add-after 'install 'link-source
2954            ;; Since source is particularly heavy (16MiB+), let's reuse it
2955            ;; across the different components of cl-ffi-gtk.
2956            (lambda* (#:key inputs outputs #:allow-other-keys)
2957              (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
2958                                                "/share/common-lisp/sbcl-source/"
2959                                                "cl-cffi-gtk-glib"))
2960                    (out-source (string-append (assoc-ref outputs "out")
2961                                               "/share/common-lisp/sbcl-source/"
2962                                               "cl-cffi-gtk-gio")))
2963                (delete-file-recursively out-source)
2964                (symlink glib-source out-source)
2965                #t))))))))
2966
2967 (define-public sbcl-cl-cffi-gtk-cairo
2968   (package
2969     (inherit sbcl-cl-cffi-gtk-boot0)
2970     (name "sbcl-cl-cffi-gtk-cairo")
2971     (inputs
2972      `(("cairo" ,cairo)
2973        ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
2974        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2975     (arguments
2976      `(#:asd-file "cairo/cl-cffi-gtk-cairo.asd"
2977        #:phases
2978        (modify-phases %standard-phases
2979          (add-after 'unpack 'fix-paths
2980            (lambda* (#:key inputs #:allow-other-keys)
2981              (substitute* "cairo/cairo.init.lisp"
2982                (("libcairo" all)
2983                 (string-append
2984                  (assoc-ref inputs "cairo") "/lib/" all)))))
2985          (add-after 'install 'link-source
2986            ;; Since source is particularly heavy (16MiB+), let's reuse it
2987            ;; across the different components of cl-ffi-gtk.
2988            (lambda* (#:key inputs outputs #:allow-other-keys)
2989              (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
2990                                                "/share/common-lisp/sbcl-source/"
2991                                                "cl-cffi-gtk-glib"))
2992                    (out-source (string-append (assoc-ref outputs "out")
2993                                               "/share/common-lisp/sbcl-source/"
2994                                               "cl-cffi-gtk-cairo")))
2995                (delete-file-recursively out-source)
2996                (symlink glib-source out-source)
2997                #t))))))))
2998
2999 (define-public sbcl-cl-cffi-gtk-pango
3000   (package
3001     (inherit sbcl-cl-cffi-gtk-boot0)
3002     (name "sbcl-cl-cffi-gtk-pango")
3003     (inputs
3004      `(("pango" ,pango)
3005        ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
3006        ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
3007        ("cl-cffi-gtk-cairo" ,sbcl-cl-cffi-gtk-cairo)
3008        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
3009     (arguments
3010      `(#:asd-file "pango/cl-cffi-gtk-pango.asd"
3011        #:phases
3012        (modify-phases %standard-phases
3013          (add-after 'unpack 'fix-paths
3014            (lambda* (#:key inputs #:allow-other-keys)
3015              (substitute* "pango/pango.init.lisp"
3016                (("libpango" all)
3017                 (string-append
3018                  (assoc-ref inputs "pango") "/lib/" all)))))
3019          (add-after 'install 'link-source
3020            ;; Since source is particularly heavy (16MiB+), let's reuse it
3021            ;; across the different components of cl-ffi-gtk.
3022            (lambda* (#:key inputs outputs #:allow-other-keys)
3023              (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
3024                                                "/share/common-lisp/sbcl-source/"
3025                                                "cl-cffi-gtk-glib"))
3026                    (out-source (string-append (assoc-ref outputs "out")
3027                                               "/share/common-lisp/sbcl-source/"
3028                                               "cl-cffi-gtk-pango")))
3029                (delete-file-recursively out-source)
3030                (symlink glib-source out-source)
3031                #t))))))))
3032
3033 (define-public sbcl-cl-cffi-gtk-gdk-pixbuf
3034   (package
3035     (inherit sbcl-cl-cffi-gtk-boot0)
3036     (name "sbcl-cl-cffi-gtk-gdk-pixbuf")
3037     (inputs
3038      `(("gdk-pixbuf" ,gdk-pixbuf)
3039        ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
3040        ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
3041        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
3042     (arguments
3043      `(#:asd-file "gdk-pixbuf/cl-cffi-gtk-gdk-pixbuf.asd"
3044        #:phases
3045        (modify-phases %standard-phases
3046          (add-after 'unpack 'fix-paths
3047            (lambda* (#:key inputs #:allow-other-keys)
3048              (substitute* "gdk-pixbuf/gdk-pixbuf.init.lisp"
3049                (("libgdk_pixbuf" all)
3050                 (string-append
3051                  (assoc-ref inputs "gdk-pixbuf") "/lib/" all)))))
3052          (add-after 'install 'link-source
3053            ;; Since source is particularly heavy (16MiB+), let's reuse it
3054            ;; across the different components of cl-ffi-gtk.
3055            (lambda* (#:key inputs outputs #:allow-other-keys)
3056              (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
3057                                                "/share/common-lisp/sbcl-source/"
3058                                                "cl-cffi-gtk-glib"))
3059                    (out-source (string-append (assoc-ref outputs "out")
3060                                               "/share/common-lisp/sbcl-source/"
3061                                               "cl-cffi-gtk-gdk-pixbuf")))
3062                (delete-file-recursively out-source)
3063                (symlink glib-source out-source)
3064                #t))))))))
3065
3066 (define-public sbcl-cl-cffi-gtk-gdk
3067   (package
3068     (inherit sbcl-cl-cffi-gtk-boot0)
3069     (name "sbcl-cl-cffi-gtk-gdk")
3070     (inputs
3071      `(("gtk" ,gtk+)
3072        ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
3073        ("cl-cffi-gtk-gio" ,sbcl-cl-cffi-gtk-gio)
3074        ("cl-cffi-gtk-gdk-pixbuf" ,sbcl-cl-cffi-gtk-gdk-pixbuf)
3075        ("cl-cffi-gtk-cairo" ,sbcl-cl-cffi-gtk-cairo)
3076        ("cl-cffi-gtk-pango" ,sbcl-cl-cffi-gtk-pango)
3077        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
3078     (arguments
3079      `(#:asd-file "gdk/cl-cffi-gtk-gdk.asd"
3080        #:phases
3081        (modify-phases %standard-phases
3082          (add-after 'unpack 'fix-paths
3083            (lambda* (#:key inputs #:allow-other-keys)
3084              (substitute* "gdk/gdk.init.lisp"
3085                (("libgdk" all)
3086                 (string-append
3087                  (assoc-ref inputs "gtk") "/lib/" all)))
3088              (substitute* "gdk/gdk.package.lisp"
3089                (("libgtk" all)
3090                 (string-append
3091                  (assoc-ref inputs "gtk") "/lib/" all))))))))))
3092
3093 (define-public sbcl-cl-cffi-gtk
3094   (package
3095     (inherit sbcl-cl-cffi-gtk-boot0)
3096     (name "sbcl-cl-cffi-gtk")
3097     (inputs
3098      `(("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
3099        ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
3100        ("cl-cffi-gtk-gio" ,sbcl-cl-cffi-gtk-gio)
3101        ("cl-cffi-gtk-gdk" ,sbcl-cl-cffi-gtk-gdk)
3102        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
3103     (native-inputs
3104      `(("fiveam" ,sbcl-fiveam)))
3105     (arguments
3106      `(#:asd-file "gtk/cl-cffi-gtk.asd"
3107        #:test-asd-file "test/cl-cffi-gtk-test.asd"
3108        ;; TODO: Tests fail with memory fault.
3109        ;; See https://github.com/Ferada/cl-cffi-gtk/issues/24.
3110        #:tests? #f))))
3111
3112 (define-public cl-cffi-gtk
3113   (sbcl-package->cl-source-package sbcl-cl-cffi-gtk))
3114
3115 (define-public sbcl-cl-webkit
3116   (let ((commit "d97115ca601838dfa60ea7afbb88641d7a526dba"))
3117     (package
3118       (name "sbcl-cl-webkit")
3119       (version (git-version "2.4" "2" commit))
3120       (source
3121        (origin
3122          (method git-fetch)
3123          (uri (git-reference
3124                (url "https://github.com/joachifm/cl-webkit")
3125                (commit commit)))
3126          (file-name (git-file-name "cl-webkit" version))
3127          (sha256
3128           (base32
3129            "0sdb2l2h5xv5c1m2mfq31i9yl6zjf512fvwwzlvk9nvisyhc4xi3"))))
3130       (build-system asdf-build-system/sbcl)
3131       (inputs
3132        `(("cffi" ,sbcl-cffi)
3133          ("cl-cffi-gtk" ,sbcl-cl-cffi-gtk)
3134          ("webkitgtk" ,webkitgtk)))
3135       (arguments
3136        `(#:asd-file "webkit2/cl-webkit2.asd"
3137          #:asd-system-name "cl-webkit2"
3138          #:phases
3139          (modify-phases %standard-phases
3140            (add-after 'unpack 'fix-paths
3141              (lambda* (#:key inputs #:allow-other-keys)
3142                (substitute* "webkit2/webkit2.init.lisp"
3143                  (("libwebkit2gtk" all)
3144                   (string-append
3145                    (assoc-ref inputs "webkitgtk") "/lib/" all))))))))
3146       (home-page "https://github.com/joachifm/cl-webkit")
3147       (synopsis "Binding to WebKitGTK+ for Common Lisp")
3148       (description
3149        "@command{cl-webkit} is a binding to WebKitGTK+ for Common Lisp,
3150 currently targeting WebKit version 2.  The WebKitGTK+ library adds web
3151 browsing capabilities to an application, leveraging the full power of the
3152 WebKit browsing engine.")
3153       (license license:expat))))
3154
3155 (define-public cl-webkit
3156   (sbcl-package->cl-source-package sbcl-cl-webkit))
3157
3158 (define-public sbcl-lparallel
3159   (package
3160     (name "sbcl-lparallel")
3161     (version "2.8.4")
3162     (source
3163      (origin
3164        (method git-fetch)
3165        (uri (git-reference
3166              (url "https://github.com/lmj/lparallel/")
3167              (commit (string-append "lparallel-" version))))
3168        (file-name (git-file-name "lparallel" version))
3169        (sha256
3170         (base32
3171          "0g0aylrbbrqsz0ahmwhvnk4cmc2931fllbpcfgzsprwnqqd7vwq9"))))
3172     (build-system asdf-build-system/sbcl)
3173     (inputs
3174      `(("alexandria" ,sbcl-alexandria)
3175        ("bordeaux-threads" ,sbcl-bordeaux-threads)
3176        ("trivial-garbage" ,sbcl-trivial-garbage)))
3177     (home-page "https://lparallel.org/")
3178     (synopsis "Parallelism for Common Lisp")
3179     (description
3180      "@command{lparallel} is a library for parallel programming in Common
3181 Lisp, featuring:
3182
3183 @itemize
3184 @item a simple model of task submission with receiving queue,
3185 @item constructs for expressing fine-grained parallelism,
3186 @item asynchronous condition handling across thread boundaries,
3187 @item parallel versions of map, reduce, sort, remove, and many others,
3188 @item promises, futures, and delayed evaluation constructs,
3189 @item computation trees for parallelizing interconnected tasks,
3190 @item bounded and unbounded FIFO queues,
3191 @item high and low priority tasks,
3192 @item task killing by category,
3193 @item integrated timeouts.
3194 @end itemize\n")
3195     (license license:expat)))
3196
3197 (define-public cl-lparallel
3198   (sbcl-package->cl-source-package sbcl-lparallel))
3199
3200 (define-public ecl-lparallel
3201   (sbcl-package->ecl-package sbcl-lparallel))
3202
3203 (define-public sbcl-cl-markup
3204   (let ((commit "e0eb7debf4bdff98d1f49d0f811321a6a637b390"))
3205     (package
3206       (name "sbcl-cl-markup")
3207       (version (git-version "0.1" "1" commit))
3208       (source
3209        (origin
3210          (method git-fetch)
3211          (uri (git-reference
3212                (url "https://github.com/arielnetworks/cl-markup/")
3213                (commit commit)))
3214          (file-name (git-file-name "cl-markup" version))
3215          (sha256
3216           (base32
3217            "10l6k45971dl13fkdmva7zc6i453lmq9j4xax2ci6pjzlc6xjhp7"))))
3218       (build-system asdf-build-system/sbcl)
3219       (home-page "https://github.com/arielnetworks/cl-markup/")
3220       (synopsis "Markup generation library for Common Lisp")
3221       (description
3222        "A modern markup generation library for Common Lisp that features:
3223
3224 @itemize
3225 @item Fast (even faster through compiling the code)
3226 @item Safety
3227 @item Support for multiple document types (markup, xml, html, html5, xhtml)
3228 @item Output with doctype
3229 @item Direct output to stream
3230 @end itemize\n")
3231       (license license:lgpl3+))))
3232
3233 (define-public cl-markup
3234   (sbcl-package->cl-source-package sbcl-cl-markup))
3235
3236 (define-public ecl-cl-markup
3237   (sbcl-package->ecl-package sbcl-cl-markup))
3238
3239 (define-public sbcl-cl-css
3240   (let ((commit "8fe654c8f0cf95b300718101cce4feb517f78e2f"))
3241     (package
3242       (name "sbcl-cl-css")
3243       (version (git-version "0.1" "1" commit))
3244       (source
3245        (origin
3246          (method git-fetch)
3247          (uri (git-reference
3248                (url "https://github.com/inaimathi/cl-css/")
3249                (commit commit)))
3250          (file-name (git-file-name "cl-css" version))
3251          (sha256
3252           (base32
3253            "1lc42zi2sw11fl2589sc19nr5sd2p0wy7wgvgwaggxa5f3ajhsmd"))))
3254       (build-system asdf-build-system/sbcl)
3255       (home-page "https://github.com/inaimathi/cl-css/")
3256       (synopsis "Non-validating, inline CSS generator for Common Lisp")
3257       (description
3258        "This is a dead-simple, non validating, inline CSS generator for Common
3259 Lisp.  Its goals are axiomatic syntax, simple implementation to support
3260 portability, and boilerplate reduction in CSS.")
3261       (license license:expat))))
3262
3263 (define-public cl-css
3264   (sbcl-package->cl-source-package sbcl-cl-css))
3265
3266 (define-public ecl-cl-css
3267   (sbcl-package->ecl-package sbcl-cl-css))
3268
3269 (define-public sbcl-portable-threads
3270   (let ((commit "c0e61a1faeb0583c80fd3f20b16cc4c555226920"))
3271     (package
3272       (name "sbcl-portable-threads")
3273       (version (git-version "2.3" "1" commit))
3274       (source
3275        (origin
3276          (method git-fetch)
3277          (uri (git-reference
3278                (url "https://github.com/binghe/portable-threads/")
3279                (commit commit)))
3280          (file-name (git-file-name "portable-threads" version))
3281          (sha256
3282           (base32
3283            "03fmxyarc0xf4kavwkfa0a2spkyfrz6hbgbi9y4q7ny5aykdyfaq"))))
3284       (build-system asdf-build-system/sbcl)
3285       (arguments
3286        `(;; Tests seem broken.
3287          #:tests? #f))
3288       (home-page "https://github.com/binghe/portable-threads")
3289       (synopsis "Portable threads (and scheduled and periodic functions) API for Common Lisp")
3290       (description
3291        "Portable Threads (and Scheduled and Periodic Functions) API for Common
3292 Lisp (from GBBopen project).")
3293       (license license:asl2.0))))
3294
3295 (define-public cl-portable-threads
3296   (sbcl-package->cl-source-package sbcl-portable-threads))
3297
3298 (define-public ecl-portable-threada
3299   (sbcl-package->ecl-package sbcl-portable-threads))
3300
3301 (define sbcl-usocket-boot0
3302   ;; usocket's test rely on usocket-server which depends on usocket itself.
3303   ;; We break this cyclic dependency with -boot0 that packages usocket.
3304   (package
3305     (name "sbcl-usocket-boot0")
3306     (version "0.8.3")
3307     (source
3308      (origin
3309        (method git-fetch)
3310        (uri (git-reference
3311              (url "https://github.com/usocket/usocket/")
3312              (commit (string-append "v" version))))
3313        (file-name (git-file-name "usocket" version))
3314        (sha256
3315         (base32
3316          "0x746wr2324l6bn7skqzgkzcbj5kd0zp2ck0c8rldrw0rzabg826"))))
3317     (build-system asdf-build-system/sbcl)
3318     (inputs
3319      `(("split-sequence" ,sbcl-split-sequence)))
3320     (arguments
3321      `(#:tests? #f
3322        #:asd-system-name "usocket"))
3323     (home-page "https://common-lisp.net/project/usocket/")
3324     (synopsis "Universal socket library for Common Lisp (server side)")
3325     (description
3326      "This library strives to provide a portable TCP/IP and UDP/IP socket
3327 interface for as many Common Lisp implementations as possible, while keeping
3328 the abstraction and portability layer as thin as possible.")
3329     (license license:expat)))
3330
3331 (define-public sbcl-usocket-server
3332   (package
3333     (inherit sbcl-usocket-boot0)
3334     (name "sbcl-usocket-server")
3335     (inputs
3336      `(("bordeaux-threads" ,sbcl-bordeaux-threads)
3337        ("usocket" ,sbcl-usocket-boot0)))
3338     (arguments
3339      '(#:asd-system-name "usocket-server"))
3340     (synopsis "Universal socket library for Common Lisp (server side)")))
3341
3342 (define-public cl-usocket-server
3343   (sbcl-package->cl-source-package sbcl-usocket-server))
3344
3345 (define-public ecl-socket-server
3346   (sbcl-package->ecl-package sbcl-usocket-server))
3347
3348 (define-public sbcl-usocket
3349   (package
3350     (inherit sbcl-usocket-boot0)
3351     (name "sbcl-usocket")
3352     (arguments
3353      ;; FIXME: Tests need network access?
3354      `(#:tests? #f))
3355     (native-inputs
3356      ;; Testing only.
3357      `(("usocket-server" ,sbcl-usocket-server)
3358        ("rt" ,sbcl-rt)))))
3359
3360 (define-public cl-usocket
3361   (sbcl-package->cl-source-package sbcl-usocket))
3362
3363 (define-public ecl-usocket
3364   (sbcl-package->ecl-package sbcl-usocket))
3365
3366 (define-public sbcl-s-xml
3367   (package
3368     (name "sbcl-s-xml")
3369     (version "3")
3370     (source
3371      (origin
3372        (method url-fetch)
3373        (uri "https://common-lisp.net/project/s-xml/s-xml.tgz")
3374        (sha256
3375         (base32
3376          "061qcr0dzshsa38s5ma4ay924cwak2nq9gy59dw6v9p0qb58nzjf"))))
3377     (build-system asdf-build-system/sbcl)
3378     (home-page "https://common-lisp.net/project/s-xml/")
3379     (synopsis "Simple XML parser implemented in Common Lisp")
3380     (description
3381      "S-XML is a simple XML parser implemented in Common Lisp.  This XML
3382 parser implementation has the following features:
3383
3384 @itemize
3385 @item It works (handling many common XML usages).
3386 @item It is very small (the core is about 700 lines of code, including
3387 comments and whitespace).
3388 @item It has a core API that is simple, efficient and pure functional, much
3389 like that from SSAX (see also http://ssax.sourceforge.net).
3390 @item It supports different DOM models: an XSML-based one, an LXML-based one
3391 and a classic xml-element struct based one.
3392 @item It is reasonably time and space efficient (internally avoiding garbage
3393 generatation as much as possible).
3394 @item It does support CDATA.
3395 @item It should support the same character sets as your Common Lisp
3396 implementation.
3397 @item It does support XML name spaces.
3398 @end itemize
3399
3400 This XML parser implementation has the following limitations:
3401
3402 @itemize
3403 @item It does not support any special tags (like processing instructions).
3404 @item It is not validating, even skips DTD's all together.
3405 @end itemize\n")
3406     (license license:lgpl3+)))
3407
3408 (define-public cl-s-xml
3409   (sbcl-package->cl-source-package sbcl-s-xml))
3410
3411 (define-public ecl-s-xml
3412   (sbcl-package->ecl-package sbcl-s-xml))
3413
3414 (define-public sbcl-s-xml-rpc
3415   (package
3416     (name "sbcl-s-xml-rpc")
3417     (version "7")
3418     (source
3419      (origin
3420        (method url-fetch)
3421        (uri "https://common-lisp.net/project/s-xml-rpc/s-xml-rpc.tgz")
3422        (sha256
3423         (base32
3424          "02z7k163d51v0pzk8mn1xb6h5s6x64gjqkslhwm3a5x26k2gfs11"))))
3425     (build-system asdf-build-system/sbcl)
3426     (inputs
3427      `(("s-xml" ,sbcl-s-xml)))
3428     (home-page "https://common-lisp.net/project/s-xml-rpc/")
3429     (synopsis "Implementation of XML-RPC in Common Lisp for both client and server")
3430     (description
3431      "S-XML-RPC is an implementation of XML-RPC in Common Lisp for both
3432 client and server.")
3433     (license license:lgpl3+)))
3434
3435 (define-public cl-s-xml-rpc
3436   (sbcl-package->cl-source-package sbcl-s-xml-rpc))
3437
3438 (define-public ecl-s-xml-rpc
3439   (sbcl-package->ecl-package sbcl-s-xml-rpc))
3440
3441 (define-public sbcl-trivial-clipboard
3442   (let ((commit "5af3415d1484e6d69a1b5c178f24680d9fd01796"))
3443     (package
3444       (name "sbcl-trivial-clipboard")
3445       (version (git-version "0.0.0.0" "2" commit))
3446       (source
3447        (origin
3448          (method git-fetch)
3449          (uri (git-reference
3450                (url "https://github.com/snmsts/trivial-clipboard")
3451                (commit commit)))
3452          (file-name (git-file-name "trivial-clipboard" version))
3453          (sha256
3454           (base32
3455            "1gb515z5yq6h5548pb1fwhmb0hhq1ssyb78pvxh4alq799xipxs9"))))
3456       (build-system asdf-build-system/sbcl)
3457       (inputs
3458        `(("xclip" ,xclip)))
3459       (native-inputs
3460        `(("fiveam" ,sbcl-fiveam)))
3461       (arguments
3462        `(#:phases
3463          (modify-phases %standard-phases
3464            (add-after 'unpack 'fix-paths
3465              (lambda* (#:key inputs #:allow-other-keys)
3466                (substitute* "src/text.lisp"
3467                  (("\\(executable-find \"xclip\"\\)")
3468                   (string-append "(executable-find \""
3469                                  (assoc-ref inputs "xclip")
3470                                  "/bin/xclip\")"))))))))
3471       (home-page "https://github.com/snmsts/trivial-clipboard")
3472       (synopsis "Access system clipboard in Common Lisp")
3473       (description
3474        "@command{trivial-clipboard} gives access to the system clipboard.")
3475       (license license:expat))))
3476
3477 (define-public cl-trivial-clipboard
3478   (sbcl-package->cl-source-package sbcl-trivial-clipboard))
3479
3480 (define-public ecl-trivial-clipboard
3481   (sbcl-package->ecl-package sbcl-trivial-clipboard))
3482
3483 (define-public sbcl-trivial-backtrace
3484   (let ((commit "ca81c011b86424a381a7563cea3b924f24e6fbeb")
3485         (revision "1"))
3486     (package
3487      (name "sbcl-trivial-backtrace")
3488      (version (git-version "0.0.0" revision commit))
3489      (source
3490       (origin
3491        (method git-fetch)
3492        (uri (git-reference
3493              (url "https://github.com/gwkkwg/trivial-backtrace.git")
3494              (commit commit)))
3495        (file-name (git-file-name "trivial-backtrace" version))
3496        (sha256
3497         (base32 "10p41p43skj6cimdg8skjy7372s8v2xpkg8djjy0l8rm45i654k1"))))
3498      (build-system asdf-build-system/sbcl)
3499      (inputs
3500       `(("sbcl-lift" ,sbcl-lift)))
3501      (arguments
3502       `(#:phases
3503         (modify-phases %standard-phases
3504           (add-after 'check 'delete-test-results
3505             (lambda* (#:key outputs #:allow-other-keys)
3506               (let ((test-results (string-append (assoc-ref outputs "out")
3507                                                  "/share/common-lisp/"
3508                                                  (%lisp-type) "-source"
3509                                                  "/trivial-backtrace"
3510                                                  "/test-results")))
3511                 (when (file-exists? test-results)
3512                   (delete-file-recursively test-results)))
3513               #t)))))
3514      (home-page "https://common-lisp.net/project/trivial-backtrace/")
3515      (synopsis "Portable simple API to work with backtraces in Common Lisp")
3516      (description
3517       "On of the many things that didn't quite get into the Common Lisp
3518 standard was how to get a Lisp to output its call stack when something has
3519 gone wrong.  As such, each Lisp has developed its own notion of what to
3520 display, how to display it, and what sort of arguments can be used to
3521 customize it.  @code{trivial-backtrace} is a simple solution to generating a
3522 backtrace portably.")
3523      (license license:expat))))
3524
3525 (define-public cl-trivial-backtrace
3526   (sbcl-package->cl-source-package sbcl-trivial-backtrace))
3527
3528 (define-public sbcl-rfc2388
3529   (let ((commit "591bcf7e77f2c222c43953a80f8c297751dc0c4e")
3530         (revision "1"))
3531     (package
3532      (name "sbcl-rfc2388")
3533      (version (git-version "0.0.0" revision commit))
3534      (source
3535       (origin
3536        (method git-fetch)
3537        (uri (git-reference
3538              (url "https://github.com/jdz/rfc2388.git")
3539              (commit commit)))
3540        (file-name (git-file-name "rfc2388" version))
3541        (sha256
3542         (base32 "0phh5n3clhl9ji8jaxrajidn22d3f0aq87mlbfkkxlnx2pnw694k"))))
3543      (build-system asdf-build-system/sbcl)
3544      (home-page "https://github.com/jdz/rfc2388/")
3545      (synopsis "An implementation of RFC 2388 in Common Lisp")
3546      (description
3547       "This package contains an implementation of RFC 2388, which is used to
3548 process form data posted with HTTP POST method using enctype
3549 \"multipart/form-data\".")
3550      (license license:bsd-2))))
3551
3552 (define-public cl-rfc2388
3553   (sbcl-package->cl-source-package sbcl-rfc2388))
3554
3555 (define-public sbcl-md5
3556   (package
3557     (name "sbcl-md5")
3558     (version "2.0.4")
3559     (source
3560      (origin
3561        (method url-fetch)
3562        (uri (string-append
3563              "https://github.com/pmai/md5/archive/release-" version ".tar.gz"))
3564        (sha256
3565         (base32 "19yl9n0pjdz5gw4qi711lka97xcd9f81ylg434hk7jwn9f2s6w11"))))
3566     (build-system asdf-build-system/sbcl)
3567     (home-page "https://github.com/pmai/md5")
3568     (synopsis
3569      "Common Lisp implementation of the MD5 Message-Digest Algorithm (RFC 1321)")
3570     (description
3571      "This package implements The MD5 Message-Digest Algorithm, as defined in
3572 RFC 1321 by R. Rivest, published April 1992.")
3573     (license license:public-domain)))
3574
3575 (define-public cl-md5
3576   (sbcl-package->cl-source-package sbcl-md5))
3577
3578 (define-public sbcl-cl+ssl
3579   (let ((commit "141ae91416bc40f1618dc07e48429b84388aa599")
3580         (revision "1"))
3581     (package
3582       (name "sbcl-cl+ssl")
3583       (version (git-version "0.0.0" revision commit))
3584       (source
3585        (origin
3586          (method git-fetch)
3587          (uri (git-reference
3588                (url "https://github.com/cl-plus-ssl/cl-plus-ssl.git")
3589                (commit commit)))
3590          (file-name (git-file-name "cl+ssl" version))
3591          (sha256
3592           (base32 "1s0hg1h9sf8q89v0yrxmzg5f5sng29rgx3n21r9h9yql8351myan"))))
3593       (build-system asdf-build-system/sbcl)
3594       (arguments
3595        '(#:phases
3596          (modify-phases %standard-phases
3597            (add-after 'unpack 'fix-paths
3598              (lambda* (#:key inputs #:allow-other-keys)
3599                (substitute* "src/reload.lisp"
3600                  (("libssl.so" all)
3601                   (string-append
3602                    (assoc-ref inputs "openssl") "/lib/" all))))))))
3603       (inputs
3604        `(("openssl" ,openssl)
3605          ("sbcl-cffi" ,sbcl-cffi)
3606          ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)
3607          ("sbcl-flexi-streams" ,sbcl-flexi-streams)
3608          ("sbcl-bordeaux-threads" ,sbcl-bordeaux-threads)
3609          ("sbcl-trivial-garbage" ,sbcl-trivial-garbage)
3610          ("sbcl-alexandria" ,sbcl-alexandria)
3611          ("sbcl-trivial-features" ,sbcl-trivial-features)))
3612       (home-page "https://common-lisp.net/project/cl-plus-ssl/")
3613       (synopsis "Common Lisp bindings to OpenSSL")
3614       (description
3615        "This library is a fork of SSL-CMUCL.  The original SSL-CMUCL source
3616 code was written by Eric Marsden and includes contributions by Jochen Schmidt.
3617 Development into CL+SSL was done by David Lichteblau.")
3618       (license license:expat))))
3619
3620 (define-public cl-cl+ssl
3621   (sbcl-package->cl-source-package sbcl-cl+ssl))
3622
3623 (define-public sbcl-kmrcl
3624   (let ((version "1.109.0")
3625         (commit "5260068b2eb735af6796740c2db4955afac21636")
3626         (revision "1"))
3627     (package
3628       (name "sbcl-kmrcl")
3629       (version (git-version version revision commit))
3630       (source
3631        (origin
3632          (method git-fetch)
3633          (uri (git-reference
3634                (url "http://git.kpe.io/kmrcl.git/")
3635                (commit commit)))
3636          (file-name (git-file-name name version))
3637          (sha256
3638           (base32 "1va7xjgzfv674bpsli674i7zj3f7wg5kxic41kz18r6hh4n52dfv"))))
3639       (build-system asdf-build-system/sbcl)
3640       (arguments
3641        ;; Tests fail with: :FORCE and :FORCE-NOT arguments not allowed in a
3642        ;; nested call to ASDF/OPERATE:OPERATE unless identically to toplevel
3643        '(#:tests? #f))
3644       (inputs
3645        `(("sbcl-rt" ,sbcl-rt)))
3646       (home-page "http://files.kpe.io/kmrcl/")
3647       (synopsis "General utilities for Common Lisp programs")
3648       (description
3649        "KMRCL is a collection of utilities used by a number of Kevin
3650 Rosenberg's CL packages.")
3651       (license license:llgpl))))
3652
3653 (define-public cl-kmrcl
3654   (sbcl-package->cl-source-package sbcl-kmrcl))
3655
3656 (define-public sbcl-cl-base64
3657   (let ((version "3.3.3"))
3658     (package
3659       (name "sbcl-cl-base64")
3660       (version version)
3661       (source
3662        (origin
3663          (method git-fetch)
3664          (uri (git-reference
3665                (url "http://git.kpe.io/cl-base64.git")
3666                (commit (string-append "v" version))))
3667          (file-name (git-file-name "cl-base64" version))
3668          (sha256
3669           (base32 "1dw6j7n6gsd2qa0p0rbsjxj00acxx3i9ca1qkgl0liy8lpnwkypl"))))
3670       (build-system asdf-build-system/sbcl)
3671       (arguments
3672        ;; Tests fail with: :FORCE and :FORCE-NOT arguments not allowed
3673        ;; in a nested call to ASDF/OPERATE:OPERATE unless identically
3674        ;; to toplevel
3675        '(#:tests? #f))
3676       (inputs
3677        `(("sbcl-ptester" ,sbcl-ptester)
3678          ("sbcl-kmrcl" ,sbcl-kmrcl)))
3679       (home-page "http://files.kpe.io/cl-base64/")
3680       (synopsis
3681        "Common Lisp package to encode and decode base64 with URI support")
3682       (description
3683        "This package provides highly optimized base64 encoding and decoding.
3684 Besides conversion to and from strings, integer conversions are supported.
3685 Encoding with Uniform Resource Identifiers is supported by using a modified
3686 encoding table that uses only URI-compatible characters.")
3687       (license license:bsd-3))))
3688
3689 (define-public cl-base64
3690   (sbcl-package->cl-source-package sbcl-cl-base64))
3691
3692 (define-public sbcl-chunga
3693   (package
3694     (name "sbcl-chunga")
3695     (version "1.1.7")
3696     (source
3697      (origin
3698        (method git-fetch)
3699        (uri (git-reference
3700               (url "https://github.com/edicl/chunga.git")
3701               (commit (string-append "v" version))))
3702        (file-name (git-file-name name version))
3703        (sha256
3704         (base32 "0jzn3nyb3f22gm983rfk99smqs3mhb9ivjmasvhq9qla5cl9pyhd"))))
3705     (build-system asdf-build-system/sbcl)
3706     (inputs
3707      `(("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)))
3708     (home-page "https://edicl.github.io/chunga/")
3709     (synopsis "Portable chunked streams for Common Lisp")
3710     (description
3711      "Chunga implements streams capable of chunked encoding on demand as
3712 defined in RFC 2616.")
3713     (license license:bsd-2)))
3714
3715 (define-public cl-chunga
3716   (sbcl-package->cl-source-package sbcl-chunga))
3717
3718 (define-public sbcl-cl-who
3719   (let ((version "1.1.4")
3720         (commit "2c08caa4bafba720409af9171feeba3f32e86d32")
3721         (revision "1"))
3722     (package
3723       (name "sbcl-cl-who")
3724       (version (git-version version revision commit))
3725       (source
3726        (origin
3727          (method git-fetch)
3728          (uri (git-reference
3729                (url "https://github.com/edicl/cl-who.git")
3730                (commit commit)))
3731          (file-name (git-file-name name version))
3732          (sha256
3733           (base32
3734            "0yjb6sr3yazm288m318kqvj9xk8rm9n1lpimgf65ymqv0i5agxsb"))))
3735       (build-system asdf-build-system/sbcl)
3736       (native-inputs
3737        `(("sbcl-flexi-streams" ,sbcl-flexi-streams)))
3738       (home-page "https://edicl.github.io/cl-who/")
3739       (synopsis "Yet another Lisp markup language")
3740       (description
3741        "There are plenty of Lisp Markup Languages out there - every Lisp
3742 programmer seems to write at least one during his career - and CL-WHO (where
3743 WHO means \"with-html-output\" for want of a better acronym) is probably just
3744 as good or bad as the next one.")
3745       (license license:bsd-2))))
3746
3747 (define-public cl-cl-who
3748   (sbcl-package->cl-source-package sbcl-cl-who))
3749
3750 (define-public sbcl-chipz
3751   (let ((version "0.8")
3752         (commit "75dfbc660a5a28161c57f115adf74c8a926bfc4d")
3753         (revision "1"))
3754     (package
3755       (name "sbcl-chipz")
3756       (version (git-version version revision commit))
3757       (source
3758        (origin
3759          (method git-fetch)
3760          (uri (git-reference
3761                (url "https://github.com/froydnj/chipz.git")
3762                (commit commit)))
3763          (file-name (git-file-name name version))
3764          (sha256
3765           (base32
3766            "0plx4rs39zbs4gjk77h4a2q11zpy75fh9v8hnxrvsf8fnakajhwg"))))
3767       (build-system asdf-build-system/sbcl)
3768       (native-inputs
3769        `(("sbcl-flexi-streams" ,sbcl-flexi-streams)))
3770       (home-page "http://method-combination.net/lisp/chipz/")
3771       (synopsis
3772        "Common Lisp library for decompressing deflate, zlib, gzip, and bzip2
3773 data")
3774       (description
3775        "DEFLATE data, defined in RFC1951, forms the core of popular
3776 compression formats such as zlib (RFC 1950) and gzip (RFC 1952).  As such,
3777 Chipz also provides for decompressing data in those formats as well.  BZIP2 is
3778 the format used by the popular compression tool bzip2.")
3779       ;; The author describes it as "MIT-like"
3780       (license license:expat))))
3781
3782 (define-public cl-chipz
3783   (sbcl-package->cl-source-package sbcl-chipz))
3784
3785 (define-public sbcl-drakma
3786   (package
3787     (name "sbcl-drakma")
3788     (version "2.0.7")
3789     (source
3790      (origin
3791        (method git-fetch)
3792        (uri (git-reference
3793              (url "https://github.com/edicl/drakma.git")
3794              (commit (string-append "v" version))))
3795        (file-name (git-file-name name version))
3796        (sha256
3797         (base32
3798          "1441idnyif9xzx3ln1p3fg36k2v9h4wasjqrzc8y52j61420qpci"))))
3799     (build-system asdf-build-system/sbcl)
3800     (inputs
3801      `(("sbcl-puri" ,sbcl-puri)
3802        ("sbcl-cl-base64" ,sbcl-cl-base64)
3803        ("sbcl-chunga" ,sbcl-chunga)
3804        ("sbcl-flexi-streams" ,sbcl-flexi-streams)
3805        ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
3806        ("sbcl-chipz" ,sbcl-chipz)
3807        ("sbcl-usocket" ,sbcl-usocket)
3808        ("sbcl-cl+ssl" ,sbcl-cl+ssl)))
3809     (native-inputs
3810      `(("sbcl-fiveam" ,sbcl-fiveam)))
3811     (home-page "https://edicl.github.io/drakma/")
3812     (synopsis "HTTP client written in Common Lisp")
3813     (description
3814      "Drakma is a full-featured HTTP client implemented in Common Lisp.  It
3815 knows how to handle HTTP/1.1 chunking, persistent connections, re-usable
3816 sockets, SSL, continuable uploads, file uploads, cookies, and more.")
3817     (license license:bsd-2)))
3818
3819 (define-public cl-drakma
3820   (sbcl-package->cl-source-package sbcl-drakma))
3821
3822 (define-public ecl-drakma
3823   (sbcl-package->ecl-package sbcl-drakma))
3824
3825 (define-public sbcl-hunchentoot
3826   (package
3827     (name "sbcl-hunchentoot")
3828     (version "1.2.38")
3829     (source
3830      (origin
3831        (method git-fetch)
3832        (uri (git-reference
3833              (url "https://github.com/edicl/hunchentoot.git")
3834              (commit (string-append "v" version))))
3835        (file-name (git-file-name "hunchentoot" version))
3836        (sha256
3837         (base32 "1anpcad7w045m4rsjs1f3xdhjwx5cppq1h0vlb3q7dz81fi3i6yq"))))
3838     (build-system asdf-build-system/sbcl)
3839     (native-inputs
3840      `(("sbcl-cl-who" ,sbcl-cl-who)
3841        ("sbcl-drakma" ,sbcl-drakma)))
3842     (inputs
3843      `(("sbcl-chunga" ,sbcl-chunga)
3844        ("sbcl-cl-base64" ,sbcl-cl-base64)
3845        ("sbcl-cl-fad" ,sbcl-cl-fad)
3846        ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
3847        ("sbcl-flexi-streams" ,sbcl-flexi-streams)
3848        ("sbcl-cl+ssl" ,sbcl-cl+ssl)
3849        ("sbcl-md5" ,sbcl-md5)
3850        ("sbcl-rfc2388" ,sbcl-rfc2388)
3851        ("sbcl-trivial-backtrace" ,sbcl-trivial-backtrace)
3852        ("sbcl-usocket" ,sbcl-usocket)))
3853     (home-page "https://edicl.github.io/hunchentoot/")
3854     (synopsis "Web server written in Common Lisp")
3855     (description
3856      "Hunchentoot is a web server written in Common Lisp and at the same
3857 time a toolkit for building dynamic websites.  As a stand-alone web server,
3858 Hunchentoot is capable of HTTP/1.1 chunking (both directions), persistent
3859 connections (keep-alive), and SSL.")
3860     (license license:bsd-2)))
3861
3862 (define-public cl-hunchentoot
3863   (sbcl-package->cl-source-package sbcl-hunchentoot))
3864
3865 (define-public sbcl-trivial-types
3866   (package
3867     (name "sbcl-trivial-types")
3868     (version "0.0.1")
3869     (source
3870      (origin
3871        (method git-fetch)
3872        (uri (git-reference
3873              (url "https://github.com/m2ym/trivial-types.git")
3874              (commit "ee869f2b7504d8aa9a74403641a5b42b16f47d88")))
3875        (file-name (git-file-name name version))
3876        (sha256
3877         (base32 "1s4cp9bdlbn8447q7w7f1wkgwrbvfzp20mgs307l5pxvdslin341"))))
3878     (build-system asdf-build-system/sbcl)
3879     (home-page "https://github.com/m2ym/trivial-types")
3880     (synopsis "Trivial type definitions for Common Lisp")
3881     (description
3882      "TRIVIAL-TYPES provides missing but important type definitions such as
3883 PROPER-LIST, ASSOCIATION-LIST, PROPERTY-LIST and TUPLE.")
3884     (license license:llgpl)))
3885
3886 (define-public cl-trivial-types
3887   (sbcl-package->cl-source-package sbcl-trivial-types))
3888
3889 (define-public sbcl-cl-syntax
3890   (package
3891     (name "sbcl-cl-syntax")
3892     (version "0.0.3")
3893     (source
3894      (origin
3895        (method git-fetch)
3896        (uri (git-reference
3897              (url "https://github.com/m2ym/cl-syntax.git")
3898              (commit "03f0c329bbd55b8622c37161e6278366525e2ccc")))
3899        (file-name (git-file-name "cl-syntax" version))
3900        (sha256
3901         (base32 "17ran8xp77asagl31xv8w819wafh6whwfc9p6dgx22ca537gyl4y"))))
3902     (build-system asdf-build-system/sbcl)
3903     (arguments
3904      '(#:asd-file "cl-syntax.asd"
3905        #:asd-system-name "cl-syntax"))
3906     (inputs `(("sbcl-trivial-types" ,sbcl-trivial-types)
3907               ("sbcl-named-readtables" ,sbcl-named-readtables)))
3908     (home-page "https://github.com/m2ym/cl-syntax")
3909     (synopsis "Reader Syntax Coventions for Common Lisp and SLIME")
3910     (description
3911      "CL-SYNTAX provides Reader Syntax Coventions for Common Lisp and SLIME.")
3912     (license license:llgpl)))
3913
3914 (define-public cl-syntax
3915   (sbcl-package->cl-source-package sbcl-cl-syntax))
3916
3917 (define-public sbcl-cl-annot
3918   (let ((commit "c99e69c15d935eabc671b483349a406e0da9518d")
3919         (revision "1"))
3920     (package
3921       (name "sbcl-cl-annot")
3922       (version (git-version "0.0.0" revision commit))
3923       (source
3924        (origin
3925          (method git-fetch)
3926          (uri (git-reference
3927                (url "https://github.com/m2ym/cl-annot.git")
3928                (commit commit)))
3929          (file-name (git-file-name name version))
3930          (sha256
3931           (base32 "1wq1gs9jjd5m6iwrv06c2d7i5dvqsfjcljgbspfbc93cg5xahk4n"))))
3932       (build-system asdf-build-system/sbcl)
3933     (arguments
3934      '(#:asd-file "cl-annot.asd"
3935        #:asd-system-name "cl-annot"))
3936       (inputs
3937        `(("sbcl-alexandria" ,sbcl-alexandria)))
3938       (home-page "https://github.com/m2ym/cl-annot")
3939       (synopsis "Python-like Annotation Syntax for Common Lisp.")
3940       (description
3941        "@code{cl-annot} is an general annotation library for Common Lisp.")
3942       (license license:llgpl))))
3943
3944 (define-public cl-annot
3945   (sbcl-package->cl-source-package sbcl-cl-annot))
3946
3947 (define-public sbcl-cl-syntax-annot
3948   (package
3949     (name "sbcl-cl-syntax-annot")
3950     (version "0.0.3")
3951     (source
3952      (origin
3953        (method git-fetch)
3954        (uri (git-reference
3955              (url "https://github.com/m2ym/cl-syntax.git")
3956              (commit "03f0c329bbd55b8622c37161e6278366525e2ccc")))
3957        (file-name (git-file-name name version))
3958        (sha256
3959         (base32 "17ran8xp77asagl31xv8w819wafh6whwfc9p6dgx22ca537gyl4y"))))
3960     (build-system asdf-build-system/sbcl)
3961     (arguments
3962      '(#:asd-file "cl-syntax-annot.asd"
3963        #:asd-system-name "cl-syntax-annot"))
3964     (inputs
3965      `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
3966        ("sbcl-cl-annot" ,sbcl-cl-annot)))
3967     (home-page "https://github.com/m2ym/cl-syntax")
3968     (synopsis "Reader Syntax Coventions for Common Lisp and SLIME")
3969     (description
3970      "CL-SYNTAX provides Reader Syntax Coventions for Common Lisp and
3971 SLIME.")
3972     (license license:llgpl)))
3973
3974 (define-public cl-syntax-annot
3975   (sbcl-package->cl-source-package sbcl-cl-syntax-annot))
3976
3977 (define-public sbcl-cl-utilities
3978   (let ((commit "dce2d2f6387091ea90357a130fa6d13a6776884b")
3979         (revision "1"))
3980     (package
3981       (name "sbcl-cl-utilities")
3982       (version (git-version "0.0.0" revision commit))
3983       (source
3984        (origin
3985          (method url-fetch)
3986          (uri
3987           (string-append
3988            "https://gitlab.common-lisp.net/cl-utilities/cl-utilities/-/"
3989            "archive/" commit "/cl-utilities-" commit ".tar.gz"))
3990          (sha256
3991           (base32 "1r46v730yf96nk2vb24qmagv9x96xvd08abqwhf02ghgydv1a7z2"))))
3992       (build-system asdf-build-system/sbcl)
3993       (arguments
3994        '(#:asd-file "cl-utilities.asd"
3995          #:asd-system-name "cl-utilities"
3996          #:phases
3997          (modify-phases %standard-phases
3998            (add-after 'unpack 'fix-paths
3999              (lambda* (#:key inputs #:allow-other-keys)
4000                (substitute* "rotate-byte.lisp"
4001                  (("in-package :cl-utilities)" all)
4002                   "in-package :cl-utilities)\n\n#+sbcl\n(require :sb-rotate-byte)")))))))
4003       (home-page "http://common-lisp.net/project/cl-utilities")
4004       (synopsis "A collection of semi-standard utilities")
4005       (description
4006        "On Cliki.net <http://www.cliki.net/Common%20Lisp%20Utilities>, there
4007 is a collection of Common Lisp Utilities, things that everybody writes since
4008 they're not part of the official standard.  There are some very useful things
4009 there; the only problems are that they aren't implemented as well as you'd
4010 like (some aren't implemented at all) and they aren't conveniently packaged
4011 and maintained.  It takes quite a bit of work to carefully implement utilities
4012 for common use, commented and documented, with error checking placed
4013 everywhere some dumb user might make a mistake.")
4014       (license license:public-domain))))
4015
4016 (define-public cl-utilities
4017   (sbcl-package->cl-source-package sbcl-cl-utilities))
4018
4019 (define-public sbcl-map-set
4020   (let ((commit "7b4b545b68b8")
4021         (revision "1"))
4022     (package
4023       (name "sbcl-map-set")
4024       (version (git-version "0.0.0" revision commit))
4025       (source
4026        (origin
4027          (method url-fetch)
4028          (uri (string-append
4029                "https://bitbucket.org/tarballs_are_good/map-set/get/"
4030                commit ".tar.gz"))
4031          (sha256
4032           (base32 "1sx5j5qdsy5fklspfammwb16kjrhkggdavm922a9q86jm5l0b239"))))
4033       (build-system asdf-build-system/sbcl)
4034       (home-page "https://bitbucket.org/tarballs_are_good/map-set")
4035       (synopsis "Set-like data structure")
4036       (description
4037        "Implementation of a set-like data structure with constant time
4038 addition, removal, and random selection.")
4039       (license license:bsd-3))))
4040
4041 (define-public cl-map-set
4042   (sbcl-package->cl-source-package sbcl-map-set))
4043
4044 (define-public sbcl-quri
4045   (let ((commit "76b75103f21ead092c9f715512fa82441ef61185")
4046         (revision "1"))
4047     (package
4048       (name "sbcl-quri")
4049       (version (git-version "0.1.0" revision commit))
4050       (source
4051        (origin
4052          (method git-fetch)
4053          (uri (git-reference
4054                (url "https://github.com/fukamachi/quri.git")
4055                (commit commit)))
4056          (file-name (git-file-name name version))
4057          (sha256
4058           (base32 "1ccbxsgzdibmzq33mmbmmz9vwl6l03xh6nbpsh1hkdvdcl7q0a60"))))
4059       (build-system asdf-build-system/sbcl)
4060       (arguments
4061        ;; Tests fail with: Component QURI-ASD::QURI-TEST not found,
4062        ;; required by #<SYSTEM "quri">. Why?
4063        '(#:tests? #f))
4064       (native-inputs `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4065                        ("sbcl-prove" ,sbcl-prove)))
4066       (inputs `(("sbcl-babel" ,sbcl-babel)
4067                 ("sbcl-split-sequence" ,sbcl-split-sequence)
4068                 ("sbcl-cl-utilities" ,sbcl-cl-utilities)
4069                 ("sbcl-alexandria" ,sbcl-alexandria)))
4070       (home-page "https://github.com/fukamachi/quri")
4071       (synopsis "Yet another URI library for Common Lisp")
4072       (description
4073        "QURI (pronounced \"Q-ree\") is yet another URI library for Common
4074 Lisp. It is intended to be a replacement of PURI.")
4075       (license license:bsd-3))))
4076
4077 (define-public cl-quri
4078   (sbcl-package->cl-source-package sbcl-quri))
4079
4080 (define-public sbcl-myway
4081   (let ((commit "286230082a11f879c18b93f17ca571c5f676bfb7")
4082         (revision "1"))
4083     (package
4084      (name "sbcl-myway")
4085      (version (git-version "0.1.0" revision commit))
4086      (source
4087       (origin
4088        (method git-fetch)
4089        (uri (git-reference
4090              (url "https://github.com/fukamachi/myway.git")
4091              (commit commit)))
4092        (file-name (git-file-name "myway" version))
4093        (sha256
4094         (base32 "0briia9bk3lbr0frnx39d1qg6i38dm4j6z9w3yga3d40k6df4a90"))))
4095      (build-system asdf-build-system/sbcl)
4096      (arguments
4097       ;; Tests fail with: Component MYWAY-ASD::MYWAY-TEST not found, required
4098       ;; by #<SYSTEM "myway">. Why?
4099       '(#:tests? #f))
4100      (native-inputs
4101       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4102         ("sbcl-prove" ,sbcl-prove)))
4103      (inputs
4104       `(("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
4105         ("sbcl-quri" ,sbcl-quri)
4106         ("sbcl-map-set" ,sbcl-map-set)))
4107      (home-page "https://github.com/fukamachi/myway")
4108      (synopsis "Sinatra-compatible URL routing library for Common Lisp")
4109      (description "My Way is a Sinatra-compatible URL routing library.")
4110      (license license:llgpl))))
4111
4112 (define-public cl-myway
4113   (sbcl-package->cl-source-package sbcl-myway))
4114
4115 (define-public sbcl-xsubseq
4116   (let ((commit "5ce430b3da5cda3a73b9cf5cee4df2843034422b")
4117         (revision "1"))
4118     (package
4119      (name "sbcl-xsubseq")
4120      (version (git-version "0.0.1" revision commit))
4121      (source
4122       (origin
4123        (method git-fetch)
4124        (uri (git-reference
4125              (url "https://github.com/fukamachi/xsubseq")
4126              (commit commit)))
4127        (file-name (git-file-name name version))
4128        (sha256
4129         (base32 "1xz79q0p2mclf3sqjiwf6izdpb6xrsr350bv4mlmdlm6rg5r99px"))))
4130      (build-system asdf-build-system/sbcl)
4131      (arguments
4132       ;; Tests fail with: Component XSUBSEQ-ASD::XSUBSEQ-TEST not found,
4133       ;; required by #<SYSTEM "xsubseq">. Why?
4134       '(#:tests? #f))
4135      (native-inputs
4136       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4137         ("sbcl-prove" ,sbcl-prove)))
4138      (home-page "https://github.com/fukamachi/xsubseq")
4139      (synopsis "Efficient way to use \"subseq\"s in Common Lisp")
4140      (description
4141       "XSubseq provides functions to be able to handle \"subseq\"s more
4142 effieiently.")
4143      (license license:bsd-2))))
4144
4145 (define-public cl-xsubseq
4146   (sbcl-package->cl-source-package sbcl-xsubseq))
4147
4148 (define-public sbcl-smart-buffer
4149   (let ((commit "09b9a9a0b3abaa37abe9a730f5aac2643dca4e62")
4150         (revision "1"))
4151     (package
4152       (name "sbcl-smart-buffer")
4153       (version (git-version "0.0.1" revision commit))
4154       (source
4155        (origin
4156          (method git-fetch)
4157          (uri (git-reference
4158                (url "https://github.com/fukamachi/smart-buffer")
4159                (commit commit)))
4160          (file-name (git-file-name name version))
4161          (sha256
4162           (base32 "0qz1zzxx0wm5ff7gpgsq550a59p0qj594zfmm2rglj97dahj54l7"))))
4163       (build-system asdf-build-system/sbcl)
4164       (arguments
4165        ;; Tests fail with: Component SMART-BUFFER-ASD::SMART-BUFFER-TEST not
4166        ;; found, required by #<SYSTEM "smart-buffer">. Why?
4167        `(#:tests? #f))
4168       (native-inputs
4169        `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4170          ("sbcl-prove" ,sbcl-prove)))
4171       (inputs
4172        `(("sbcl-xsubseq" ,sbcl-xsubseq)
4173          ("sbcl-flexi-streams" ,sbcl-flexi-streams)))
4174       (home-page "https://github.com/fukamachi/smart-buffer")
4175       (synopsis "Smart octets buffer")
4176       (description
4177        "Smart-buffer provides an output buffer which changes the destination
4178 depending on content size.")
4179       (license license:bsd-3))))
4180
4181 (define-public cl-smart-buffer
4182   (sbcl-package->cl-source-package sbcl-smart-buffer))
4183
4184 (define-public sbcl-fast-http
4185   (let ((commit "f9e7597191bae380503e20724fd493a24d024935")
4186         (revision "1"))
4187     (package
4188       (name "sbcl-fast-http")
4189       (version (git-version "0.2.0" revision commit))
4190       (source
4191        (origin
4192          (method git-fetch)
4193          (uri (git-reference
4194                (url "https://github.com/fukamachi/fast-http")
4195                (commit commit)))
4196          (file-name (git-file-name name version))
4197          (sha256
4198           (base32 "0qdmwv2zm0sizxdb8nnclgwl0nfjcbjaimbakavikijw7lr9b4jp"))))
4199       (build-system asdf-build-system/sbcl)
4200       (arguments
4201        ;; Tests fail with: Component FAST-HTTP-ASD::FAST-HTTP-TEST not found,
4202        ;; required by #<SYSTEM "fast-http">. Why?
4203        `(#:tests? #f))
4204       (native-inputs
4205        `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4206          ("sbcl-prove" ,sbcl-prove)))
4207       (inputs
4208        `(("sbcl-alexandria" ,sbcl-alexandria)
4209          ("sbcl-proc-parse" ,sbcl-proc-parse)
4210          ("sbcl-xsubseq" ,sbcl-xsubseq)
4211          ("sbcl-smart-buffer" ,sbcl-smart-buffer)
4212          ("sbcl-cl-utilities" ,sbcl-cl-utilities)))
4213       (home-page "https://github.com/fukamachi/fast-http")
4214       (synopsis "HTTP request/response parser for Common Lisp")
4215       (description
4216        "@code{fast-http} is a HTTP request/response protocol parser for Common
4217 Lisp.")
4218       ;; Author specified the MIT license
4219       (license license:expat))))
4220
4221 (define-public cl-fast-http
4222   (sbcl-package->cl-source-package sbcl-fast-http))
4223
4224 (define-public sbcl-static-vectors
4225   (package
4226     (name "sbcl-static-vectors")
4227     (version "1.8.4")
4228     (source
4229      (origin
4230        (method git-fetch)
4231        (uri (git-reference
4232              (url "https://github.com/sionescu/static-vectors.git")
4233              (commit (string-append "v" version))))
4234        (file-name (git-file-name name version))
4235        (sha256
4236         (base32 "0qvf9z6bhwhm8n45fjwkm7j8dcb58szfvndky65cyn4lpdval7m1"))))
4237     (native-inputs
4238      `(("sbcl-fiveam" ,sbcl-fiveam)))
4239     (inputs
4240      `(("sbcl-cffi-grovel" ,sbcl-cffi-grovel)
4241        ("sbcl-cffi" ,sbcl-cffi)))
4242     (build-system asdf-build-system/sbcl)
4243     (home-page "https://github.com/sionescu/static-vectors")
4244     (synopsis "Allocate SIMPLE-ARRAYs in static memory")
4245     (description
4246      "With @code{static-vectors}, you can create vectors allocated in static
4247 memory.")
4248     (license license:expat)))
4249
4250 (define-public cl-static-vectors
4251   (sbcl-package->cl-source-package sbcl-static-vectors))
4252
4253 (define-public ecl-static-vectors
4254   (sbcl-package->ecl-package sbcl-static-vectors))
4255
4256 (define-public sbcl-marshal
4257   (let ((commit "eff1b15f2b0af2f26f71ad6a4dd5c4beab9299ec")
4258         (revision "1"))
4259     (package
4260      (name "sbcl-marshal")
4261      (version (git-version "1.3.0" revision commit))
4262      (source
4263       (origin
4264        (method git-fetch)
4265        (uri (git-reference
4266              (url "https://github.com/wlbr/cl-marshal.git")
4267              (commit commit)))
4268        (file-name (git-file-name name version))
4269        (sha256
4270         (base32 "08qs6fhk38xpkkjkpcj92mxx0lgy4ygrbbzrmnivdx281syr0gwh"))))
4271      (build-system asdf-build-system/sbcl)
4272      (home-page "https://github.com/wlbr/cl-marshal")
4273      (synopsis "Simple (de)serialization of Lisp datastructures")
4274      (description
4275       "Simple and fast marshalling of Lisp datastructures.  Convert any object
4276 into a string representation, put it on a stream an revive it from there.
4277 Only minimal changes required to make your CLOS objects serializable.")
4278      (license license:expat))))
4279
4280 (define-public cl-marshal
4281   (sbcl-package->cl-source-package sbcl-marshal))
4282
4283 (define-public sbcl-checkl
4284   (let ((commit "80328800d047fef9b6e32dfe6bdc98396aee3cc9")
4285         (revision "1"))
4286     (package
4287       (name "sbcl-checkl")
4288       (version (git-version "0.0.0" revision commit))
4289       (source
4290        (origin
4291          (method git-fetch)
4292          (uri (git-reference
4293                (url "https://github.com/rpav/CheckL.git")
4294                (commit commit)))
4295          (file-name (git-file-name name version))
4296          (sha256
4297           (base32 "0bpisihx1gay44xmyr1dmhlwh00j0zzi04rp9fy35i95l2r4xdlx"))))
4298       (build-system asdf-build-system/sbcl)
4299       (arguments
4300        ;; Error while trying to load definition for system checkl-test from
4301        ;; pathname [...]/checkl-test.asd: The function CHECKL:DEFINE-TEST-OP
4302        ;; is undefined.
4303        '(#:tests? #f))
4304       (native-inputs
4305        `(("sbcl-fiveam" ,sbcl-fiveam)))
4306       (inputs
4307        `(("sbcl-marshal" ,sbcl-marshal)))
4308       (home-page "https://github.com/rpav/CheckL/")
4309       (synopsis "Dynamic testing for Common Lisp")
4310       (description
4311        "CheckL lets you write tests dynamically, it checks resulting values
4312 against the last run.")
4313       ;; The author specifies both LLGPL and "BSD", but the "BSD" license
4314       ;; isn't specified anywhere, so I don't know which kind.  LLGPL is the
4315       ;; stronger of the two and so I think only listing this should suffice.
4316       (license license:llgpl))))
4317
4318 (define-public cl-checkl
4319   (sbcl-package->cl-source-package sbcl-checkl))
4320
4321 (define-public sbcl-fast-io
4322   (let ((commit "dc3a71db7e9b756a88781ae9c342fe9d4bbab51c")
4323         (revision "1"))
4324     (package
4325      (name "sbcl-fast-io")
4326      (version (git-version "1.0.0" revision commit))
4327      (source
4328       (origin
4329        (method git-fetch)
4330        (uri (git-reference
4331              (url "https://github.com/rpav/fast-io.git")
4332              (commit commit)))
4333        (file-name (git-file-name name version))
4334        (sha256
4335         (base32 "1jsp6xvi26ln6fdy5j5zi05xvan8jsqdhisv552dy6xg6ws8i1yq"))))
4336      (build-system asdf-build-system/sbcl)
4337      (arguments
4338       ;; Error while trying to load definition for system fast-io-test from
4339       ;; pathname [...]/fast-io-test.asd: The function CHECKL:DEFINE-TEST-OP
4340       ;; is undefined.
4341       '(#:tests? #f))
4342      (native-inputs
4343       `(("sbcl-fiveam" ,sbcl-fiveam)
4344         ("sbcl-checkl" ,sbcl-checkl)))
4345      (inputs
4346       `(("sbcl-alexandria" ,sbcl-alexandria)
4347         ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)
4348         ("sbcl-static-vectors" ,sbcl-static-vectors)))
4349      (home-page "https://github.com/rpav/fast-io")
4350      (synopsis "Fast octet-vector/stream I/O for Common Lisp")
4351      (description
4352       "Fast-io is about improving performance to octet-vectors and octet
4353 streams (though primarily the former, while wrapping the latter).")
4354      ;; Author specifies this as NewBSD which is an alias
4355      (license license:bsd-3))))
4356
4357 (define-public cl-fast-io
4358   (sbcl-package->cl-source-package sbcl-fast-io))
4359
4360 (define-public sbcl-jonathan
4361   (let ((commit "1f448b4f7ac8265e56e1c02b32ce383e65316300")
4362         (revision "1"))
4363     (package
4364      (name "sbcl-jonathan")
4365      (version (git-version "0.1.0" revision commit))
4366      (source
4367       (origin
4368        (method git-fetch)
4369        (uri (git-reference
4370              (url "https://github.com/Rudolph-Miller/jonathan.git")
4371              (commit commit)))
4372        (file-name (git-file-name name version))
4373        (sha256
4374         (base32 "14x4iwz3mbag5jzzzr4sb6ai0m9r4q4kyypbq32jmsk2dx1hi807"))))
4375      (build-system asdf-build-system/sbcl)
4376      (arguments
4377       ;; Tests fail with: Component JONATHAN-ASD::JONATHAN-TEST not found,
4378       ;; required by #<SYSTEM "jonathan">. Why?
4379       `(#:tests? #f))
4380      (native-inputs
4381       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4382         ("sbcl-prove" ,sbcl-prove)))
4383      (inputs
4384       `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
4385         ("sbcl-cl-syntax-annot" ,sbcl-cl-syntax-annot)
4386         ("sbcl-fast-io" ,sbcl-fast-io)
4387         ("sbcl-proc-parse" ,sbcl-proc-parse)
4388         ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)))
4389      (home-page "https://rudolph-miller.github.io/jonathan/overview.html")
4390      (synopsis "JSON encoder and decoder")
4391      (description
4392       "High performance JSON encoder and decoder.  Currently support: SBCL,
4393 CCL.")
4394      ;; Author specifies the MIT license
4395      (license license:expat))))
4396
4397 (define-public cl-jonathan
4398   (sbcl-package->cl-source-package sbcl-jonathan))
4399
4400 (define-public sbcl-http-body
4401   (let ((commit "dd01dc4f5842e3d29728552e5163acce8386eb73")
4402         (revision "1"))
4403     (package
4404      (name "sbcl-http-body")
4405      (version (git-version "0.1.0" revision commit))
4406      (source
4407       (origin
4408        (method git-fetch)
4409        (uri (git-reference
4410              (url "https://github.com/fukamachi/http-body")
4411              (commit commit)))
4412        (file-name (git-file-name name version))
4413        (sha256
4414         (base32 "1jd06snjvxcprhapgfq8sx0y5lrldkvhf206ix6d5a23dd6zcmr0"))))
4415      (build-system asdf-build-system/sbcl)
4416      (arguments
4417       ;; Tests fail with: Component HTTP-BODY-ASD::HTTP-BODY-TEST not
4418       ;; found, required by #<SYSTEM "http-body">. Why?
4419       `(#:tests? #f))
4420      (native-inputs
4421       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4422         ("sbcl-prove" ,sbcl-prove)))
4423      (inputs
4424       `(("sbcl-fast-http" ,sbcl-fast-http)
4425         ("sbcl-jonathan" ,sbcl-jonathan)
4426         ("sbcl-quri" ,sbcl-quri)))
4427      (home-page "https://github.com/fukamachi/http-body")
4428      (synopsis "HTTP POST data parser")
4429      (description
4430       "HTTP-Body parses HTTP POST data and returns POST parameters.  It
4431 supports application/x-www-form-urlencoded, application/json, and
4432 multipart/form-data.")
4433      (license license:bsd-2))))
4434
4435 (define-public cl-http-body
4436   (sbcl-package->cl-source-package sbcl-http-body))
4437
4438 (define-public sbcl-circular-streams
4439   (let ((commit "e770bade1919c5e8533dd2078c93c3d3bbeb38df")
4440         (revision "1"))
4441     (package
4442      (name "sbcl-circular-streams")
4443      (version (git-version "0.1.0" revision commit))
4444      (source
4445       (origin
4446        (method git-fetch)
4447        (uri (git-reference
4448              (url "https://github.com/fukamachi/circular-streams")
4449              (commit commit)))
4450        (file-name (git-file-name name version))
4451        (sha256
4452         (base32 "1wpw6d5cciyqcf92f7mvihak52pd5s47kk4qq6f0r2z2as68p5rs"))))
4453      (build-system asdf-build-system/sbcl)
4454      (arguments
4455       ;; The tests depend on cl-test-more which is now prove. Prove
4456       ;; tests aren't working for some reason.
4457       `(#:tests? #f))
4458      (inputs
4459       `(("sbcl-fast-io" ,sbcl-fast-io)
4460         ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)))
4461      (home-page "https://github.com/fukamachi/circular-streams")
4462      (synopsis "Circularly readable streams for Common Lisp")
4463      (description
4464       "Circular-Streams allows you to read streams circularly by wrapping real
4465 streams. Once you reach end-of-file of a stream, it's file position will be
4466 reset to 0 and you're able to read it again.")
4467      (license license:llgpl))))
4468
4469 (define-public cl-circular-streams
4470   (sbcl-package->cl-source-package sbcl-circular-streams))
4471
4472 (define-public sbcl-lack-request
4473   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4474         (revision "1"))
4475     (package
4476      (name "sbcl-lack-request")
4477      (version (git-version "0.1.0" revision commit))
4478      (source
4479       (origin
4480        (method git-fetch)
4481        (uri (git-reference
4482              (url "https://github.com/fukamachi/lack.git")
4483              (commit commit)))
4484        (file-name (git-file-name "lack-request" version))
4485        (sha256
4486         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4487      (build-system asdf-build-system/sbcl)
4488      (arguments
4489       '(#:asd-file "lack-request.asd"
4490         #:asd-system-name "lack-request"
4491         #:test-asd-file "t-lack-request.asd"
4492         ;; XXX: Component :CLACK-TEST not found
4493         #:tests? #f))
4494      (native-inputs
4495       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4496         ("sbcl-prove" ,sbcl-prove)))
4497      (inputs
4498       `(("sbcl-quri" ,sbcl-quri)
4499         ("sbcl-http-body" ,sbcl-http-body)
4500         ("sbcl-circular-streams" ,sbcl-circular-streams)))
4501      (home-page "https://github.com/fukamachi/lack")
4502      (synopsis "Lack, the core of Clack")
4503      (description
4504       "Lack is a Common Lisp library which allows web applications to be
4505 constructed of modular components.  It was originally a part of Clack, however
4506 it's going to be rewritten as an individual project since Clack v2 with
4507 performance and simplicity in mind.")
4508      (license license:llgpl))))
4509
4510 (define-public cl-lack-request
4511   (sbcl-package->cl-source-package sbcl-lack-request))
4512
4513 (define-public sbcl-local-time
4514   (let ((commit "beac054eef428552b63d4ae7820c32ffef9a3015")
4515         (revision "1"))
4516     (package
4517      (name "sbcl-local-time")
4518      (version (git-version "1.0.6" revision commit))
4519      (source
4520       (origin
4521        (method git-fetch)
4522        (uri (git-reference
4523              (url "https://github.com/dlowe-net/local-time.git")
4524              (commit commit)))
4525        (file-name (git-file-name name version))
4526        (sha256
4527         (base32 "0xhkmgxh41dg2wwlsp0h2l41jp144xn4gpxhh0lna6kh0560w2cc"))))
4528      (build-system asdf-build-system/sbcl)
4529      (arguments
4530       ;; TODO: Component :STEFIL not found, required by #<SYSTEM
4531       ;; "local-time/test">
4532       '(#:tests? #f))
4533      (native-inputs
4534       `(("stefil" ,sbcl-hu.dwim.stefil)))
4535      (inputs
4536       `(("sbcl-cl-fad" ,sbcl-cl-fad)))
4537      (home-page "https://common-lisp.net/project/local-time/")
4538      (synopsis "Time manipulation library for Common Lisp")
4539      (description
4540       "The LOCAL-TIME library is a Common Lisp library for the manipulation of
4541 dates and times.  It is based almost entirely upon Erik Naggum's paper \"The
4542 Long Painful History of Time\".")
4543      (license license:expat))))
4544
4545 (define-public cl-local-time
4546   (sbcl-package->cl-source-package sbcl-local-time))
4547
4548 (define-public sbcl-lack-response
4549   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4550         (revision "1"))
4551     (package
4552      (name "sbcl-lack-response")
4553      (version (git-version "0.1.0" revision commit))
4554      (source
4555       (origin
4556        (method git-fetch)
4557        (uri (git-reference
4558              (url "https://github.com/fukamachi/lack.git")
4559              (commit commit)))
4560        (file-name (git-file-name name version))
4561        (sha256
4562         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4563      (build-system asdf-build-system/sbcl)
4564      (arguments
4565       '(#:asd-file "lack-response.asd"
4566         #:asd-system-name "lack-response"
4567         ;; XXX: no tests for lack-response.
4568         #:tests? #f))
4569      (native-inputs
4570       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4571         ("sbcl-prove" ,sbcl-prove)))
4572      (inputs
4573       `(("sbcl-quri" ,sbcl-quri)
4574         ("sbcl-http-body" ,sbcl-http-body)
4575         ("sbcl-circular-streams" ,sbcl-circular-streams)
4576         ("sbcl-local-time" ,sbcl-local-time)))
4577      (home-page "https://github.com/fukamachi/lack")
4578      (synopsis "Lack, the core of Clack")
4579      (description
4580       "Lack is a Common Lisp library which allows web applications to be
4581 constructed of modular components.  It was originally a part of Clack, however
4582 it's going to be rewritten as an individual project since Clack v2 with
4583 performance and simplicity in mind.")
4584      (license license:llgpl))))
4585
4586 (define-public cl-lack-response
4587   (sbcl-package->cl-source-package sbcl-lack-response))
4588
4589 (define-public sbcl-lack-component
4590   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4591         (revision "1"))
4592     (package
4593      (name "sbcl-lack-component")
4594      (version (git-version "0.0.0" revision commit))
4595      (source
4596       (origin
4597        (method git-fetch)
4598        (uri (git-reference
4599              (url "https://github.com/fukamachi/lack.git")
4600              (commit commit)))
4601        (file-name (git-file-name "lack-component" version))
4602        (sha256
4603         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4604      (build-system asdf-build-system/sbcl)
4605      (arguments
4606       '(#:asd-file "lack-component.asd"
4607         #:asd-system-name "lack-component"
4608         #:test-asd-file "t-lack-component.asd"
4609         ;; XXX: Component :LACK-TEST not found
4610         #:tests? #f))
4611      (native-inputs
4612       `(("prove-asdf" ,sbcl-prove-asdf)))
4613      (home-page "https://github.com/fukamachi/lack")
4614      (synopsis "Lack, the core of Clack")
4615      (description
4616       "Lack is a Common Lisp library which allows web applications to be
4617 constructed of modular components.  It was originally a part of Clack, however
4618 it's going to be rewritten as an individual project since Clack v2 with
4619 performance and simplicity in mind.")
4620      (license license:llgpl))))
4621
4622 (define-public cl-lack-component
4623   (sbcl-package->cl-source-package sbcl-lack-component))
4624
4625 (define-public sbcl-lack-util
4626   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4627         (revision "1"))
4628     (package
4629      (name "sbcl-lack-util")
4630      (version (git-version "0.1.0" revision commit))
4631      (source
4632       (origin
4633        (method git-fetch)
4634        (uri (git-reference
4635              (url "https://github.com/fukamachi/lack.git")
4636              (commit commit)))
4637        (file-name (git-file-name "lack-util" version))
4638        (sha256
4639         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4640      (build-system asdf-build-system/sbcl)
4641      (arguments
4642       '(#:asd-file "lack-util.asd"
4643         #:asd-system-name "lack-util"
4644         #:test-asd-file "t-lack-util.asd"
4645         ;; XXX: Component :LACK-TEST not found
4646         #:tests? #f))
4647      (native-inputs
4648       `(("prove-asdf" ,sbcl-prove-asdf)))
4649      (inputs
4650       `(("sbcl-ironclad" ,sbcl-ironclad)))
4651      (home-page "https://github.com/fukamachi/lack")
4652      (synopsis "Lack, the core of Clack")
4653      (description
4654       "Lack is a Common Lisp library which allows web applications to be
4655 constructed of modular components.  It was originally a part of Clack, however
4656 it's going to be rewritten as an individual project since Clack v2 with
4657 performance and simplicity in mind.")
4658      (license license:llgpl))))
4659
4660 (define-public cl-lack-util
4661   (sbcl-package->cl-source-package sbcl-lack-util))
4662
4663 (define-public sbcl-lack-middleware-backtrace
4664   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4665         (revision "1"))
4666     (package
4667      (name "sbcl-lack-middleware-backtrace")
4668      (version (git-version "0.1.0" revision commit))
4669      (source
4670       (origin
4671        (method git-fetch)
4672        (uri (git-reference
4673              (url "https://github.com/fukamachi/lack.git")
4674              (commit commit)))
4675        (file-name (git-file-name "lack-middleware-backtrace" version))
4676        (sha256
4677         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4678      (build-system asdf-build-system/sbcl)
4679      (arguments
4680       '(#:asd-file "lack-middleware-backtrace.asd"
4681         #:asd-system-name "lack-middleware-backtrace"
4682         #:test-asd-file "t-lack-middleware-backtrace.asd"
4683         ;; XXX: Component :LACK not found
4684         #:tests? #f))
4685      (native-inputs
4686       `(("prove-asdf" ,sbcl-prove-asdf)))
4687      (home-page "https://github.com/fukamachi/lack")
4688      (synopsis "Lack, the core of Clack")
4689      (description
4690       "Lack is a Common Lisp library which allows web applications to be
4691 constructed of modular components.  It was originally a part of Clack, however
4692 it's going to be rewritten as an individual project since Clack v2 with
4693 performance and simplicity in mind.")
4694      (license license:llgpl))))
4695
4696 (define-public cl-lack-middleware-backtrace
4697   (sbcl-package->cl-source-package sbcl-lack-middleware-backtrace))
4698
4699 (define-public sbcl-trivial-mimes
4700   (let ((commit "303f8ac0aa6ca0bc139aa3c34822e623c3723fab")
4701         (revision "1"))
4702     (package
4703       (name "sbcl-trivial-mimes")
4704       (version (git-version "1.1.0" revision commit))
4705       (source
4706        (origin
4707          (method git-fetch)
4708          (uri (git-reference
4709                (url "https://github.com/Shinmera/trivial-mimes.git")
4710                (commit commit)))
4711          (file-name (git-file-name name version))
4712          (sha256
4713           (base32 "17jxgl47r695bvsb7wi3n2ws5rp1zzgvw0zii8cy5ggw4b4ayv6m"))))
4714       (build-system asdf-build-system/sbcl)
4715       (arguments
4716        '(#:phases
4717          (modify-phases %standard-phases
4718            (add-after
4719                'unpack 'fix-paths
4720              (lambda* (#:key inputs #:allow-other-keys)
4721                (let ((anchor "#p\"/etc/mime.types\""))
4722                  (substitute* "mime-types.lisp"
4723                    ((anchor all)
4724                     (string-append
4725                      anchor "\n"
4726                      "(asdf:system-relative-pathname :trivial-mimes "
4727                      "\"../../share/common-lisp/" (%lisp-type)
4728                      "-source/trivial-mimes/mime.types\")")))))))))
4729       (native-inputs
4730        `(("stefil" ,sbcl-hu.dwim.stefil)))
4731       (inputs
4732        `(("sbcl-cl-fad" ,sbcl-cl-fad)))
4733       (home-page "https://shinmera.github.io/trivial-mimes/")
4734       (synopsis "Tiny Common Lisp library to detect mime types in files")
4735       (description
4736        "This is a teensy library that provides some functions to determine the
4737 mime-type of a file.")
4738       (license license:artistic2.0))))
4739
4740 (define-public cl-trivial-mimes
4741   (sbcl-package->cl-source-package sbcl-trivial-mimes))
4742
4743 (define-public ecl-trivial-mimes
4744   (sbcl-package->ecl-package sbcl-trivial-mimes))
4745
4746 (define-public sbcl-lack-middleware-static
4747   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4748         (revision "1"))
4749     (package
4750      (name "sbcl-lack-middleware-static")
4751      (version (git-version "0.1.0" revision commit))
4752      (source
4753       (origin
4754        (method git-fetch)
4755        (uri (git-reference
4756              (url "https://github.com/fukamachi/lack.git")
4757              (commit commit)))
4758        (file-name (git-file-name "lack-middleware-static" version))
4759        (sha256
4760         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4761      (build-system asdf-build-system/sbcl)
4762      (arguments
4763       '(#:asd-file "lack-middleware-static.asd"
4764         #:asd-system-name "lack-middleware-static"
4765         #:test-asd-file "t-lack-middleware-static.asd"
4766         ;; XXX: Component :LACK not found
4767         #:tests? #f))
4768      (native-inputs
4769       `(("prove-asdf" ,sbcl-prove-asdf)))
4770      (inputs
4771       `(("sbcl-ironclad" ,sbcl-ironclad)
4772         ("sbcl-trivial-mimes" ,sbcl-trivial-mimes)
4773         ("sbcl-local-time" ,sbcl-local-time)))
4774      (home-page "https://github.com/fukamachi/lack")
4775      (synopsis "Lack, the core of Clack")
4776      (description
4777       "Lack is a Common Lisp library which allows web applications to be
4778 constructed of modular components.  It was originally a part of Clack, however
4779 it's going to be rewritten as an individual project since Clack v2 with
4780 performance and simplicity in mind.")
4781      (license license:llgpl))))
4782
4783 (define-public cl-lack-middleware-static
4784   (sbcl-package->cl-source-package sbcl-lack-middleware-static))
4785
4786 (define-public sbcl-lack
4787   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4788         (revision "1"))
4789     (package
4790      (name "sbcl-lack")
4791      (version (git-version "0.1.0" revision commit))
4792      (source
4793       (origin
4794        (method git-fetch)
4795        (uri (git-reference
4796              (url "https://github.com/fukamachi/lack.git")
4797              (commit commit)))
4798        (file-name (git-file-name "lack" version))
4799        (sha256
4800         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4801      (build-system asdf-build-system/sbcl)
4802      (arguments
4803       '(#:test-asd-file "t-lack.asd"
4804         ;; XXX: Component :CLACK not found
4805         #:tests? #f))
4806      (native-inputs
4807       `(("prove-asdf" ,sbcl-prove-asdf)))
4808      (inputs
4809       `(("sbcl-lack-component" ,sbcl-lack-component)
4810         ("sbcl-lack-util" ,sbcl-lack-util)))
4811      (home-page "https://github.com/fukamachi/lack")
4812      (synopsis "Lack, the core of Clack")
4813      (description
4814       "Lack is a Common Lisp library which allows web applications to be
4815 constructed of modular components.  It was originally a part of Clack, however
4816 it's going to be rewritten as an individual project since Clack v2 with
4817 performance and simplicity in mind.")
4818      (license license:llgpl))))
4819
4820 (define-public cl-lack
4821   (sbcl-package->cl-source-package sbcl-lack))
4822
4823 (define-public sbcl-ningle
4824   (let ((commit "50bd4f09b5a03a7249bd4d78265d6451563b25ad")
4825         (revision "1"))
4826     (package
4827       (name "sbcl-ningle")
4828       (version (git-version "0.3.0" revision commit))
4829       (source
4830        (origin
4831          (method git-fetch)
4832          (uri (git-reference
4833                (url "https://github.com/fukamachi/ningle.git")
4834                (commit commit)))
4835          (file-name (git-file-name name version))
4836          (sha256
4837           (base32 "1bsl8cnxhacb8p92z9n89vhk1ikmij5zavk0m2zvmj7iqm79jzgw"))))
4838       (build-system asdf-build-system/sbcl)
4839       (arguments
4840        ;; TODO: pull in clack-test
4841        '(#:tests? #f
4842          #:phases
4843          (modify-phases %standard-phases
4844            (delete 'cleanup-files)
4845            (delete 'cleanup)
4846            (add-before 'cleanup 'combine-fasls
4847              (lambda* (#:key outputs #:allow-other-keys)
4848                (let* ((out (assoc-ref outputs "out"))
4849                       (lib (string-append out "/lib/sbcl"))
4850                       (ningle-path (string-append lib "/ningle"))
4851                       (fasl-files (find-files out "\\.fasl$")))
4852                  (mkdir-p ningle-path)
4853                  (let ((fasl-path (lambda (name)
4854                                     (string-append ningle-path
4855                                                    "/"
4856                                                    (basename name)
4857                                                    "--system.fasl"))))
4858                    (for-each (lambda (file)
4859                                (rename-file file
4860                                             (fasl-path
4861                                              (basename file ".fasl"))))
4862                              fasl-files))
4863                  fasl-files)
4864                #t)))))
4865       (native-inputs
4866        `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4867          ("sbcl-prove" ,sbcl-prove)))
4868       (inputs
4869        `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
4870          ("sbcl-cl-syntax-annot" ,sbcl-cl-syntax-annot)
4871          ("sbcl-myway" ,sbcl-myway)
4872          ("sbcl-lack-request" ,sbcl-lack-request)
4873          ("sbcl-lack-response" ,sbcl-lack-response)
4874          ("sbcl-lack-component" ,sbcl-lack-component)
4875          ("sbcl-alexandria" ,sbcl-alexandria)
4876          ("sbcl-babel" ,sbcl-babel)))
4877       (home-page "https://8arrow.org/ningle/")
4878       (synopsis "Super micro framework for Common Lisp")
4879       (description
4880        "Ningle is a lightweight web application framework for Common Lisp.")
4881       (license license:llgpl))))
4882
4883 (define-public cl-ningle
4884   (sbcl-package->cl-source-package sbcl-ningle))
4885
4886 (define-public sbcl-clack
4887   (let ((commit "e3e032843bb1220ab96263c411aa7f2feb4746e0")
4888         (revision "1"))
4889     (package
4890      (name "sbcl-clack")
4891      (version (git-version "2.0.0" revision commit))
4892      (source
4893       (origin
4894        (method git-fetch)
4895        (uri (git-reference
4896              (url "https://github.com/fukamachi/clack.git")
4897              (commit commit)))
4898        (file-name (git-file-name name version))
4899        (sha256
4900         (base32 "1ymzs6qyrwhlj6cgqsnpyn6g5cbp7a3s1vgxwna20y2q7y4iacy0"))))
4901      (build-system asdf-build-system/sbcl)
4902      (inputs
4903       `(("sbcl-lack" ,sbcl-lack)
4904         ("sbcl-lack-middleware-backtrace" ,sbcl-lack-middleware-backtrace)
4905         ("sbcl-bordeaux-threads" ,sbcl-bordeaux-threads)))
4906      (home-page "https://github.com/fukamachi/clack")
4907      (synopsis "Web Application Environment for Common Lisp")
4908      (description
4909       "Clack is a web application environment for Common Lisp inspired by
4910 Python's WSGI and Ruby's Rack.")
4911      (license license:llgpl))))
4912
4913 (define-public cl-clack
4914   (sbcl-package->cl-source-package sbcl-clack))
4915
4916 (define-public sbcl-log4cl
4917   (let ((commit "611e094458504b938d49de904eab141285328c7c")
4918         (revision "1"))
4919     (package
4920       (name "sbcl-log4cl")
4921       (build-system asdf-build-system/sbcl)
4922       (version "1.1.2")
4923       (source
4924        (origin
4925          (method git-fetch)
4926          (uri (git-reference
4927                (url "https://github.com/sharplispers/log4cl")
4928                (commit commit)))
4929          (file-name (git-file-name name version))
4930          (sha256
4931           (base32
4932            "08jly0s0g26b56hhpfizxsb4j0yvbh946sd205gr42dkzv8l7dsc"))))
4933       ;; FIXME: tests require stefil, sbcl-hu.dwim.stefil wont work
4934       (arguments
4935        `(#:tests? #f))
4936       (inputs `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
4937       (synopsis "Common Lisp logging framework, modeled after Log4J")
4938       (home-page "https://github.com/7max/log4cl")
4939       (description "This is a Common Lisp logging framework that can log at
4940 various levels and mix text with expressions.")
4941       (license license:asl2.0))))
4942
4943 (define-public cl-log4cl
4944   (sbcl-package->cl-source-package sbcl-log4cl))
4945
4946 (define-public ecl-log4cl
4947   (sbcl-package->ecl-package sbcl-log4cl))
4948
4949 (define-public sbcl-find-port
4950   (let ((commit "00c96a25af93a0f8681d34ec548861f2d7485478")
4951         (revision "1"))
4952     (package
4953       (name "sbcl-find-port")
4954       (build-system asdf-build-system/sbcl)
4955       (version "0.1")
4956       (home-page "https://github.com/eudoxia0/find-port")
4957       (source
4958        (origin
4959          (method git-fetch)
4960          (uri (git-reference
4961                (url home-page)
4962                (commit commit)))
4963          (file-name (git-file-name name version))
4964          (sha256
4965           (base32
4966            "0d6dzbb45jh0rx90wgs6v020k2xa87mvzas3mvfzvivjvqqlpryq"))))
4967       (native-inputs
4968        `(("fiveam" ,sbcl-fiveam)))
4969       (inputs
4970        `(("sbcl-usocket" ,sbcl-usocket)))
4971       (synopsis "Find open ports programmatically in Common Lisp")
4972       (description "This is a small Common Lisp library that finds an open
4973 port within a range.")
4974       (license license:expat))))
4975
4976 (define-public cl-find-port
4977   (sbcl-package->cl-source-package sbcl-find-port))
4978
4979 (define-public ecl-find-port
4980   (sbcl-package->ecl-package sbcl-find-port))
4981
4982 (define-public sbcl-clunit
4983   (let ((commit "6f6d72873f0e1207f037470105969384f8380628")
4984         (revision "1"))
4985     (package
4986       (name "sbcl-clunit")
4987       (version (git-version "0.2.3" revision commit))
4988       (source
4989        (origin
4990          (method git-fetch)
4991          (uri (git-reference
4992                (url "https://github.com/tgutu/clunit.git")
4993                (commit commit)))
4994          (file-name (git-file-name name version))
4995          (sha256
4996           (base32
4997            "1idf2xnqzlhi8rbrqmzpmb3i1l6pbdzhhajkmhwbp6qjkmxa4h85"))))
4998       (build-system asdf-build-system/sbcl)
4999       (synopsis "CLUnit is a Common Lisp unit testing framework")
5000       (description
5001        "CLUnit is a Common Lisp unit testing framework.  It is designed
5002 to be easy to use so that you can quickly start testing.  CLUnit
5003 provides a rich set of features aimed at improving your unit testing
5004 experience.")
5005       (home-page "https://tgutu.github.io/clunit/")
5006       ;; MIT License
5007       (license license:expat))))
5008
5009 (define-public cl-clunit
5010   (sbcl-package->cl-source-package sbcl-clunit))
5011
5012 (define-public ecl-clunit
5013   (sbcl-package->ecl-package sbcl-clunit))
5014
5015 (define-public sbcl-py4cl
5016   (let ((commit "4c8a2b0814fd311f978964f825ce012290f60136")
5017         (revision "1"))
5018     (package
5019       (name "sbcl-py4cl")
5020       (version (git-version "0.0.0" revision commit))
5021       (source
5022        (origin
5023          (method git-fetch)
5024          (uri (git-reference
5025                (url "https://github.com/bendudson/py4cl.git")
5026                (commit commit)))
5027          (file-name (git-file-name name version))
5028          (sha256
5029           (base32
5030            "15mk7qdqjkj56gdnbyrdyz6r7m1h26ldvn6ch96pmvg5vmr1m45r"))
5031          (modules '((guix build utils)))))
5032       (build-system asdf-build-system/sbcl)
5033       (native-inputs
5034        `(("sbcl-clunit" ,sbcl-clunit)))
5035       (inputs
5036        `(("sbcl-trivial-garbage" ,sbcl-trivial-garbage)))
5037       (propagated-inputs
5038        ;; This package doesn't do anything without python available
5039        `(("python" ,python)
5040          ;; For multi-dimensional array support
5041          ("python-numpy" ,python-numpy)))
5042       (arguments
5043        '(#:phases
5044          (modify-phases %standard-phases
5045            (add-after 'unpack 'replace-*base-directory*-var
5046              (lambda* (#:key outputs #:allow-other-keys)
5047                ;; In the ASD, the author makes an attempt to
5048                ;; programatically determine the location of the
5049                ;; source-code so lisp can call into "py4cl.py". We can
5050                ;; hard-code this since we know where this file will
5051                ;; reside.
5052                (substitute* "src/callpython.lisp"
5053                  (("py4cl/config:\\*base-directory\\*")
5054                   (string-append
5055                    "\""
5056                    (assoc-ref outputs "out")
5057                    "/share/common-lisp/sbcl-source/py4cl/"
5058                    "\""))))))))
5059       (synopsis "Call python from Common Lisp")
5060       (description
5061        "Py4CL is a bridge between Common Lisp and Python, which enables Common
5062 Lisp to interact with Python code.  It uses streams to communicate with a
5063 separate python process, the approach taken by cl4py.  This is different to
5064 the CFFI approach used by burgled-batteries, but has the same goal.")
5065       (home-page "https://github.com/bendudson/py4cl")
5066       ;; MIT License
5067       (license license:expat))))
5068
5069 (define-public cl-py4cl
5070   (sbcl-package->cl-source-package sbcl-py4cl))
5071
5072 (define-public ecl-py4cl
5073   (sbcl-package->ecl-package sbcl-py4cl))
5074
5075 (define-public sbcl-parse-declarations
5076   (let ((commit "549aebbfb9403a7fe948654126b9c814f443f4f2")
5077         (revision "1"))
5078     (package
5079       (name "sbcl-parse-declarations")
5080       (version (git-version "1.0.0" revision commit))
5081       (source
5082        (origin
5083          (method git-fetch)
5084          (uri (git-reference
5085                (url (string-append
5086                      "https://gitlab.common-lisp.net/parse-declarations/"
5087                      "parse-declarations.git"))
5088                (commit commit)))
5089          (file-name (git-file-name name version))
5090          (sha256
5091           (base32 "03g5qks4c59nmxa48pbslxkfh77h8hn8566jddp6m9pl15dzzpxd"))))
5092       (build-system asdf-build-system/sbcl)
5093       (arguments
5094        `(#:asd-file "parse-declarations-1.0.asd"
5095          #:asd-system-name "parse-declarations-1.0"))
5096       (home-page "https://common-lisp.net/project/parse-declarations/")
5097       (synopsis "Parse, filter, and build declarations")
5098       (description
5099        "Parse-Declarations is a Common Lisp library to help writing
5100 macros which establish bindings.  To be semantically correct, such
5101 macros must take user declarations into account, as these may affect
5102 the bindings they establish.  Yet the ANSI standard of Common Lisp does
5103 not provide any operators to work with declarations in a convenient,
5104 high-level way.  This library provides such operators.")
5105       ;; MIT License
5106       (license license:expat))))
5107
5108 (define-public cl-parse-declarations
5109   (sbcl-package->cl-source-package sbcl-parse-declarations))
5110
5111 (define-public ecl-parse-declarations
5112   (sbcl-package->ecl-package sbcl-parse-declarations))
5113
5114 (define-public sbcl-cl-quickcheck
5115   (let ((commit "807b2792a30c883a2fbecea8e7db355b50ba662f")
5116         (revision "1"))
5117     (package
5118       (name "sbcl-cl-quickcheck")
5119       (version (git-version "0.0.4" revision commit))
5120       (source
5121        (origin
5122          (method git-fetch)
5123          (uri (git-reference
5124                (url "https://github.com/mcandre/cl-quickcheck.git")
5125                (commit commit)))
5126          (file-name (git-file-name name version))
5127          (sha256
5128           (base32
5129            "165lhypq5xkcys6hvzb3jq7ywnmqvzaflda29qk2cbs3ggas4767"))))
5130       (build-system asdf-build-system/sbcl)
5131       (synopsis
5132        "Common Lisp port of the QuickCheck unit test framework")
5133       (description
5134        "Common Lisp port of the QuickCheck unit test framework")
5135       (home-page "https://github.com/mcandre/cl-quickcheck")
5136       ;; MIT
5137       (license license:expat))))
5138
5139 (define-public cl-cl-quickcheck
5140   (sbcl-package->cl-source-package sbcl-cl-quickcheck))
5141
5142 (define-public ecl-cl-quickcheck
5143   (sbcl-package->ecl-package sbcl-cl-quickcheck))
5144
5145 (define-public sbcl-burgled-batteries3
5146   (let ((commit "f65f454d13bb6c40e17e9ec62e41eb5069e09760")
5147         (revision "2"))
5148     (package
5149       (name "sbcl-burgled-batteries3")
5150       (version (git-version "0.0.0" revision commit))
5151       (source
5152        (origin
5153          (method git-fetch)
5154          (uri (git-reference
5155                (url "https://github.com/snmsts/burgled-batteries3.git")
5156                (commit commit)))
5157          (file-name (git-file-name name version))
5158          (sha256
5159           (base32
5160            "1nzn7jawrfajyzwfnzrg2cmn9xxadcqh4szbpg0jggkhdkdzz4wa"))))
5161       (build-system asdf-build-system/sbcl)
5162       (arguments
5163        `(#:tests? #f
5164          #:modules (((guix build python-build-system) #:select (python-version))
5165                     ,@%asdf-build-system-modules)
5166          #:imported-modules ((guix build python-build-system)
5167                              ,@%asdf-build-system-modules)
5168          #:phases
5169          (modify-phases (@ (guix build asdf-build-system) %standard-phases)
5170            (add-after 'unpack 'set-*cpython-include-dir*-var
5171              (lambda* (#:key inputs #:allow-other-keys)
5172                (let ((python (assoc-ref inputs "python")))
5173                  (setenv "BB_PYTHON3_INCLUDE_DIR"
5174                          (string-append python "/include/python"
5175                                         (python-version python)
5176                                         "m"))
5177                  (setenv "BB_PYTHON3_DYLIB"
5178                          (string-append python "/lib/libpython3.so"))
5179                  #t))))))
5180       (native-inputs
5181        `(("sbcl-cl-fad" ,sbcl-cl-fad)
5182          ("sbcl-lift" ,sbcl-lift)
5183          ("sbcl-cl-quickcheck" ,sbcl-cl-quickcheck)))
5184       (inputs
5185        `(("python" ,python)
5186          ("sbcl-cffi" ,sbcl-cffi)
5187          ("sbcl-cffi-grovel" ,sbcl-cffi-grovel)
5188          ("sbcl-alexandria" , sbcl-alexandria)
5189          ("sbcl-parse-declarations-1.0" ,sbcl-parse-declarations)
5190          ("sbcl-trivial-garbage" ,sbcl-trivial-garbage)))
5191       (synopsis "Bridge between Python and Lisp (FFI bindings, etc.)")
5192       (description
5193        "This package provides a shim between Python3 (specifically, the
5194 CPython implementation of Python) and Common Lisp.")
5195       (home-page "https://github.com/snmsts/burgled-batteries3")
5196       (license license:expat))))
5197
5198 (define-public cl-burgled-batteries3
5199   (sbcl-package->cl-source-package sbcl-burgled-batteries3))
5200
5201 (define-public ecl-burgled-batteries3
5202   (sbcl-package->ecl-package sbcl-burgled-batteries3))
5203
5204 (define-public sbcl-metabang-bind
5205   (let ((commit "c93b7f7e1c18c954c2283efd6a7fdab36746ab5e")
5206         (revision "1"))
5207     (package
5208       (name "sbcl-metabang-bind")
5209       (version (git-version "0.8.0" revision commit))
5210       (source
5211        (origin
5212          (method git-fetch)
5213          (uri (git-reference
5214                (url "https://github.com/gwkkwg/metabang-bind.git")
5215                (commit commit)))
5216          (file-name (git-file-name name version))
5217          (sha256
5218           (base32
5219            "0hd0kr91795v77akpbcyqiss9p0p7ypa9dznrllincnmgvsxlmf0"))))
5220       (build-system asdf-build-system/sbcl)
5221       (native-inputs
5222        `(("sbcl-lift" ,sbcl-lift)))
5223       (synopsis "Macro that generalizes @code{multiple-value-bind} etc.")
5224       (description
5225        "Bind extends the idea of of let and destructing to provide a uniform
5226 syntax for all your accessor needs.  It combines @code{let},
5227 @code{destructuring-bind}, @code{with-slots}, @code{with-accessors}, structure
5228 editing, property or association-lists, and @code{multiple-value-bind} and a
5229 whole lot more into a single form.")
5230       (home-page "https://common-lisp.net/project/metabang-bind/")
5231       ;; MIT License
5232       (license license:expat))))
5233
5234 (define-public cl-metabang-bind
5235   (sbcl-package->cl-source-package sbcl-metabang-bind))
5236
5237 (define-public ecl-metabang-bind
5238   (sbcl-package->ecl-package sbcl-metabang-bind))
5239
5240 (define-public sbcl-fare-utils
5241   (let ((commit "66e9c6f1499140bc00ccc22febf2aa528cbb5724")
5242         (revision "1"))
5243     (package
5244       (name "sbcl-fare-utils")
5245       (version (git-version "1.0.0.5" revision commit))
5246       (source
5247        (origin
5248          (method git-fetch)
5249          (uri
5250           (git-reference
5251            (url
5252             "https://gitlab.common-lisp.net/frideau/fare-utils.git")
5253            (commit commit)))
5254          (file-name (git-file-name name version))
5255          (sha256
5256           (base32
5257            "01wsr1aap3jdzhn4hrqjbhsjx6qci9dbd3gh4gayv1p49rbg8aqr"))))
5258       (build-system asdf-build-system/sbcl)
5259       (arguments
5260        `(#:test-asd-file "test/fare-utils-test.asd"))
5261       (native-inputs
5262        `(("sbcl-hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
5263       (synopsis "Collection of utilities and data structures")
5264       (description
5265        "fare-utils is a small collection of utilities.  It contains a lot of
5266 basic everyday functions and macros.")
5267       (home-page "https://gitlab.common-lisp.net/frideau/fare-utils")
5268       ;; MIT License
5269       (license license:expat))))
5270
5271 (define-public cl-fare-utils
5272   (sbcl-package->cl-source-package sbcl-fare-utils))
5273
5274 (define-public ecl-fare-utils
5275   (sbcl-package->ecl-package sbcl-fare-utils))
5276
5277 (define-public sbcl-trivial-utf-8
5278   (let ((commit "4d427cfbb1c452436a0efb71c3205c9da67f718f")
5279         (revision "1"))
5280     (package
5281       (name "sbcl-trivial-utf-8")
5282       (version (git-version "0.0.0" revision commit))
5283       (source
5284        (origin
5285          (method git-fetch)
5286          (uri
5287           (git-reference
5288            (url (string-append "https://gitlab.common-lisp.net/"
5289                                "trivial-utf-8/trivial-utf-8.git"))
5290            (commit commit)))
5291          (file-name (git-file-name name version))
5292          (sha256
5293           (base32
5294            "1jz27gz8gvqdmvp3k9bxschs6d5b3qgk94qp2bj6nv1d0jc3m1l1"))))
5295       (arguments
5296        ;; Guix incorrectly assumes the "8" is part of the version
5297        ;; number and lobs it off.
5298        `(#:asd-file "trivial-utf-8.asd"
5299          #:asd-system-name "trivial-utf-8"))
5300       (build-system asdf-build-system/sbcl)
5301       (synopsis "UTF-8 input/output library")
5302       (description
5303        "The Babel library solves a similar problem while understanding more
5304 encodings.  Trivial UTF-8 was written before Babel existed, but for new
5305 projects you might be better off going with Babel.  The one plus that Trivial
5306 UTF-8 has is that it doesn't depend on any other libraries.")
5307       (home-page "https://common-lisp.net/project/trivial-utf-8/")
5308       (license license:bsd-3))))
5309
5310 (define-public cl-trivial-utf-8
5311   (sbcl-package->cl-source-package sbcl-trivial-utf-8))
5312
5313 (define-public ecl-trivial-utf-8
5314   (sbcl-package->ecl-package sbcl-trivial-utf-8))
5315
5316 (define-public sbcl-idna
5317   (package
5318     (name "sbcl-idna")
5319     (build-system asdf-build-system/sbcl)
5320     (version "0.2.2")
5321     (home-page "https://github.com/antifuchs/idna")
5322     (source
5323      (origin
5324        (method git-fetch)
5325        (uri (git-reference
5326              (url home-page)
5327              (commit version)))
5328        (file-name (git-file-name name version))
5329        (sha256
5330         (base32
5331          "00nbr3mffxhlq14gg9d16pa6691s4qh35inyw76v906s77khm5a2"))))
5332     (inputs
5333      `(("split-sequence" ,sbcl-split-sequence)))
5334     (synopsis "IDNA string encoding and decoding routines for Common Lisp")
5335     (description "This Common Lisp library provides string encoding and
5336 decoding routines for IDNA, the International Domain Names in Applications.")
5337     (license license:expat)))
5338
5339 (define-public cl-idna
5340   (sbcl-package->cl-source-package sbcl-idna))
5341
5342 (define-public ecl-idna
5343   (sbcl-package->ecl-package sbcl-idna))
5344
5345 (define-public sbcl-swap-bytes
5346   (package
5347     (name "sbcl-swap-bytes")
5348     (build-system asdf-build-system/sbcl)
5349     (version "1.2")
5350     (home-page "https://github.com/sionescu/swap-bytes")
5351     (source
5352      (origin
5353        (method git-fetch)
5354        (uri (git-reference
5355              (url home-page)
5356              (commit (string-append "v" version))))
5357        (file-name (git-file-name name version))
5358        (sha256
5359         (base32
5360          "1hw1v1lw26rifyznpnj1csphha9jgzwpiic16ni3pvs6hcsni9rz"))))
5361     (inputs
5362      `(("trivial-features" ,sbcl-trivial-features)))
5363     (native-inputs
5364      `(("fiveam" ,sbcl-fiveam)))
5365     (synopsis "Efficient endianness conversion for Common Lisp")
5366     (description "This Common Lisp library provides optimized byte-swapping
5367 primitives.  The library can change endianness of unsigned integers of length
5368 1/2/4/8.  Very useful in implementing various network protocols and file
5369 formats.")
5370     (license license:expat)))
5371
5372 (define-public cl-swap-bytes
5373   (sbcl-package->cl-source-package sbcl-swap-bytes))
5374
5375 (define-public ecl-swap-bytes
5376   (sbcl-package->ecl-package sbcl-swap-bytes))
5377
5378 (define-public sbcl-iolib.asdf
5379   ;; Latest release is from June 2017.
5380   (let ((commit "81e20614c0d27f9605bf9766214e236fd31b99b4")
5381         (revision "1"))
5382     (package
5383       (name "sbcl-iolib.asdf")
5384       (build-system asdf-build-system/sbcl)
5385       (version "0.8.3")
5386       (home-page "https://github.com/sionescu/iolib")
5387       (source
5388        (origin
5389          (method git-fetch)
5390          (uri (git-reference
5391                (url home-page)
5392                (commit commit)))
5393          (file-name (git-file-name name version))
5394          (sha256
5395           (base32
5396            "1j81r0wm7nfbwl991f26s4npcy7kybzybd3m47rbxy31h0cfcmdm"))))
5397       (inputs
5398        `(("alexandria" ,sbcl-alexandria)))
5399       (arguments
5400        '(#:asd-file "iolib.asdf.asd"))
5401       (synopsis "ASDF component classes for IOLib, a Common Lisp I/O library")
5402       (description "IOlib is to be a better and more modern I/O library than
5403 the standard Common Lisp library.  It contains a socket library, a DNS
5404 resolver, an I/O multiplexer(which supports @code{select(2)}, @code{epoll(4)}
5405 and @code{kqueue(2)}), a pathname library and file-system utilities.")
5406       (license license:expat))))
5407
5408 (define-public sbcl-iolib.conf
5409   (package
5410     (inherit sbcl-iolib.asdf)
5411     (name "sbcl-iolib.conf")
5412     (inputs
5413      `(("iolib.asdf" ,sbcl-iolib.asdf)))
5414     (arguments
5415      '(#:asd-file "iolib.conf.asd"))
5416     (synopsis "Compile-time configuration for IOLib, a Common Lisp I/O library")))
5417
5418 (define-public sbcl-iolib.common-lisp
5419   (package
5420     (inherit sbcl-iolib.asdf)
5421     (name "sbcl-iolib.common-lisp")
5422     (inputs
5423      `(("iolib.asdf" ,sbcl-iolib.asdf)
5424        ("iolib.conf" ,sbcl-iolib.conf)))
5425     (arguments
5426      '(#:asd-file "iolib.common-lisp.asd"))
5427     (synopsis "Slightly modified Common Lisp for IOLib, a Common Lisp I/O library")))
5428
5429 (define-public sbcl-iolib.base
5430   (package
5431     (inherit sbcl-iolib.asdf)
5432     (name "sbcl-iolib.base")
5433     (inputs
5434      `(("iolib.asdf" ,sbcl-iolib.asdf)
5435        ("iolib.conf" ,sbcl-iolib.conf)
5436        ("iolib.common-lisp" ,sbcl-iolib.common-lisp)
5437        ("split-sequence" ,sbcl-split-sequence)))
5438     (arguments
5439      '(#:asd-file "iolib.base.asd"))
5440     (synopsis "Base package for IOLib, a Common Lisp I/O library")))
5441
5442 (define-public sbcl-iolib.grovel
5443   (package
5444     (inherit sbcl-iolib.asdf)
5445     (name "sbcl-iolib.grovel")
5446     (inputs
5447      `(("iolib.asdf" ,sbcl-iolib.asdf)
5448        ("iolib.conf" ,sbcl-iolib.conf)
5449        ("iolib.base", sbcl-iolib.base)
5450        ("cffi", sbcl-cffi)))
5451     (arguments
5452      '(#:asd-file "iolib.grovel.asd"
5453        #:phases
5454        (modify-phases %standard-phases
5455          (add-after 'install 'install-header
5456            (lambda* (#:key outputs #:allow-other-keys)
5457              ;; This header is required by sbcl-iolib.
5458              (install-file "src/grovel/grovel-common.h"
5459                            (string-append (assoc-ref outputs "out")
5460                                           "/lib/sbcl"))
5461              #t)))))
5462     (synopsis "CFFI Groveller for IOLib, a Common Lisp I/O library")))
5463
5464 (define sbcl-iolib+syscalls
5465   (package
5466     (inherit sbcl-iolib.asdf)
5467     (name "sbcl-iolib+syscalls")
5468     (inputs
5469      `(("iolib.asdf" ,sbcl-iolib.asdf)
5470        ("iolib.conf" ,sbcl-iolib.conf)
5471        ("iolib.grovel" ,sbcl-iolib.grovel)
5472        ("iolib.base" ,sbcl-iolib.base)
5473        ("bordeaux-threads" ,sbcl-bordeaux-threads)
5474        ("idna" ,sbcl-idna)
5475        ("swap-bytes" ,sbcl-swap-bytes)
5476        ("libfixposix" ,libfixposix)
5477        ("cffi" ,sbcl-cffi)))
5478     (native-inputs
5479      `(("fiveam" ,sbcl-fiveam)))
5480     (arguments
5481      '(#:asd-file "iolib.asd"
5482        #:asd-system-name "iolib/syscalls"
5483        #:test-asd-file "iolib.tests.asd"
5484        #:phases
5485        (modify-phases %standard-phases
5486          (add-after 'unpack 'fix-paths
5487            (lambda* (#:key inputs #:allow-other-keys)
5488              (substitute* "src/syscalls/ffi-functions-unix.lisp"
5489                (("\\(:default \"libfixposix\"\\)")
5490                 (string-append
5491                  "(:default \""
5492                  (assoc-ref inputs "libfixposix") "/lib/libfixposix\")")))
5493              ;; Socket tests need Internet access, disable them.
5494              (substitute* "iolib.tests.asd"
5495                (("\\(:file \"sockets\" :depends-on \\(\"pkgdcl\" \"defsuites\"\\)\\)")
5496                 "")))))))
5497     (synopsis "Common Lisp I/O library")))
5498
5499 (define sbcl-iolib+multiplex
5500   (package
5501     (inherit sbcl-iolib+syscalls)
5502     (name "sbcl-iolib+multiplex")
5503     (inputs
5504      `(("iolib+syscalls" ,sbcl-iolib+syscalls)
5505        ,@(package-inputs sbcl-iolib+syscalls)))
5506     (arguments
5507      (substitute-keyword-arguments (package-arguments sbcl-iolib+syscalls)
5508        ((#:asd-system-name _) "iolib/multiplex")))))
5509
5510
5511
5512 (define sbcl-iolib+streams
5513   (package
5514     (inherit sbcl-iolib+syscalls)
5515     (name "sbcl-iolib+streams")
5516     (inputs
5517      `(("iolib+multiplex" ,sbcl-iolib+multiplex)
5518        ,@(package-inputs sbcl-iolib+syscalls)))
5519     (arguments
5520      (substitute-keyword-arguments (package-arguments sbcl-iolib+syscalls)
5521        ((#:asd-system-name _) "iolib/streams")))))
5522
5523 (define sbcl-iolib+sockets
5524   (package
5525     (inherit sbcl-iolib+syscalls)
5526     (name "sbcl-iolib+sockets")
5527     (inputs
5528      `(("iolib+syscalls" ,sbcl-iolib+syscalls)
5529        ("iolib+streams" ,sbcl-iolib+streams)
5530        ,@(package-inputs sbcl-iolib+syscalls)))
5531     (arguments
5532      (substitute-keyword-arguments (package-arguments sbcl-iolib+syscalls)
5533        ((#:asd-system-name _) "iolib/sockets")))))
5534
5535 (define-public sbcl-iolib
5536   (package
5537     (inherit sbcl-iolib+syscalls)
5538     (name "sbcl-iolib")
5539     (inputs
5540      `(("iolib+multiplex" ,sbcl-iolib+multiplex)
5541        ("iolib+streams" ,sbcl-iolib+streams)
5542        ("iolib+sockets" ,sbcl-iolib+sockets)
5543        ,@(package-inputs sbcl-iolib+syscalls)))
5544     (arguments
5545      (substitute-keyword-arguments (package-arguments sbcl-iolib+syscalls)
5546        ((#:asd-system-name _) "iolib")))))
5547
5548 (define-public cl-iolib
5549   (sbcl-package->cl-source-package sbcl-iolib))
5550
5551 (define-public sbcl-ieee-floats
5552   (let ((commit "566b51a005e81ff618554b9b2f0b795d3b29398d")
5553         (revision "1"))
5554     (package
5555       (name "sbcl-ieee-floats")
5556       (build-system asdf-build-system/sbcl)
5557       (version (git-version "20170924" revision commit))
5558       (home-page "https://github.com/marijnh/ieee-floats/")
5559       (source
5560        (origin
5561          (method git-fetch)
5562          (uri (git-reference
5563                (url home-page)
5564                (commit commit)))
5565          (file-name (git-file-name name version))
5566          (sha256
5567           (base32
5568            "1xyj49j9x3lc84cv3dhbf9ja34ywjk1c46dklx425fxw9mkwm83m"))))
5569       (native-inputs
5570        `(("fiveam" ,sbcl-fiveam)))
5571       (synopsis "IEEE 754 binary representation for floats in Common Lisp")
5572       (description "This is a Common Lisp library that converts
5573 floating point values to IEEE 754 binary representation.")
5574       (license license:bsd-3))))
5575
5576 (define-public cl-ieee-floats
5577   (sbcl-package->cl-source-package sbcl-ieee-floats))
5578
5579 (define sbcl-closure-common
5580   (let ((commit "e3c5f5f454b72b01b89115e581c3c52a7e201e5c")
5581         (revision "1"))
5582     (package
5583       (name "sbcl-closure-common")
5584       (build-system asdf-build-system/sbcl)
5585       (version (git-version "20101006" revision commit))
5586       (home-page "https://common-lisp.net/project/cxml/")
5587       (source
5588        (origin
5589          (method git-fetch)
5590          (uri (git-reference
5591                (url "https://github.com/sharplispers/closure-common")
5592                (commit commit)))
5593          (file-name (git-file-name name version))
5594          (sha256
5595           (base32
5596            "0k5r2qxn122pxi301ijir3nayi9sg4d7yiy276l36qmzwhp4mg5n"))))
5597       (inputs
5598        `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)
5599          ("babel" ,sbcl-babel)))
5600       (synopsis "Support Common Lisp library for CXML")
5601       (description "Closure-common is an internal helper library.  The name
5602 Closure is a reference to the web browser it was originally written for.")
5603       ;; TODO: License?
5604       (license #f))))
5605
5606 (define-public sbcl-cxml+xml
5607   (let ((commit "00b22bf4c4cf11c993d5866fae284f95ab18e6bf")
5608         (revision "1"))
5609     (package
5610       (name "sbcl-cxml+xml")
5611       (build-system asdf-build-system/sbcl)
5612       (version (git-version "0.0.0" revision commit))
5613       (home-page "https://common-lisp.net/project/cxml/")
5614       (source
5615        (origin
5616          (method git-fetch)
5617          (uri (git-reference
5618                (url "https://github.com/sharplispers/cxml")
5619                (commit commit)))
5620          (file-name (git-file-name name version))
5621          (sha256
5622           (base32
5623            "13kif7rf3gqdycsk9zq0d7y0g9y81krkl0z87k0p2fkbjfgrph37"))))
5624       (inputs
5625        `(("closure-common" ,sbcl-closure-common)
5626          ("puri" ,sbcl-puri)
5627          ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
5628       (arguments
5629        `(#:asd-file "cxml.asd"
5630          #:asd-system-name "cxml/xml"))
5631       (synopsis "Common Lisp XML parser")
5632       (description "CXML implements a namespace-aware, validating XML 1.0
5633 parser as well as the DOM Level 2 Core interfaces.  Two parser interfaces are
5634 offered, one SAX-like, the other similar to StAX.")
5635       (license license:llgpl))))
5636
5637 (define sbcl-cxml+dom
5638   (package
5639     (inherit sbcl-cxml+xml)
5640     (name "sbcl-cxml+dom")
5641     (inputs
5642      `(("closure-common" ,sbcl-closure-common)
5643        ("puri" ,sbcl-puri)
5644        ("cxml+xml" ,sbcl-cxml+xml)))
5645     (arguments
5646      `(#:asd-file "cxml.asd"
5647        #:asd-system-name "cxml/dom"))))
5648
5649 (define sbcl-cxml+klacks
5650   (package
5651     (inherit sbcl-cxml+xml)
5652     (name "sbcl-cxml+klacks")
5653     (inputs
5654      `(("closure-common" ,sbcl-closure-common)
5655        ("puri" ,sbcl-puri)
5656        ("cxml+xml" ,sbcl-cxml+xml)))
5657     (arguments
5658      `(#:asd-file "cxml.asd"
5659        #:asd-system-name "cxml/klacks"))))
5660
5661 (define sbcl-cxml+test
5662   (package
5663     (inherit sbcl-cxml+xml)
5664     (name "sbcl-cxml+test")
5665     (inputs
5666      `(("closure-common" ,sbcl-closure-common)
5667        ("puri" ,sbcl-puri)
5668        ("cxml+xml" ,sbcl-cxml+xml)))
5669     (arguments
5670      `(#:asd-file "cxml.asd"
5671        #:asd-system-name "cxml/test"))))
5672
5673 (define-public sbcl-cxml
5674   (package
5675     (inherit sbcl-cxml+xml)
5676     (name "sbcl-cxml")
5677     (inputs
5678      `(("closure-common" ,sbcl-closure-common)
5679        ("puri" ,sbcl-puri)
5680        ("trivial-gray-streams" ,sbcl-trivial-gray-streams)
5681        ("cxml+dom" ,sbcl-cxml+dom)
5682        ("cxml+klacks" ,sbcl-cxml+klacks)
5683        ("cxml+test" ,sbcl-cxml+test)))
5684     (arguments
5685      `(#:asd-file "cxml.asd"
5686        #:asd-system-name "cxml"
5687        #:phases
5688        (modify-phases %standard-phases
5689          (add-after 'build 'install-dtd
5690            (lambda* (#:key outputs #:allow-other-keys)
5691              (install-file "catalog.dtd"
5692                            (string-append
5693                             (assoc-ref outputs "out")
5694                             "/lib/" (%lisp-type)))))
5695          (add-after 'create-asd 'remove-component
5696            ;; XXX: The original .asd has no components, but our build system
5697            ;; creates an entry nonetheless.  We need to remove it for the
5698            ;; generated .asd to load properly.  See trivia.trivial for a
5699            ;; similar problem.
5700            (lambda* (#:key outputs #:allow-other-keys)
5701              (let* ((out (assoc-ref outputs "out"))
5702                     (asd (string-append out "/lib/sbcl/cxml.asd")))
5703                (substitute* asd
5704                  (("  :components
5705 ")
5706                   ""))
5707                (substitute* asd
5708                  ((" *\\(\\(:compiled-file \"cxml--system\"\\)\\)")
5709                   ""))))))))))
5710
5711 (define-public cl-cxml
5712   (sbcl-package->cl-source-package sbcl-cxml))
5713
5714 (define-public sbcl-cl-reexport
5715   (let ((commit "312f3661bbe187b5f28536cd7ec2956e91366c3b")
5716         (revision "1"))
5717     (package
5718       (name "sbcl-cl-reexport")
5719       (build-system asdf-build-system/sbcl)
5720       (version (git-version "0.1" revision commit))
5721       (home-page "https://github.com/takagi/cl-reexport")
5722       (source
5723        (origin
5724          (method git-fetch)
5725          (uri (git-reference
5726                (url home-page)
5727                (commit commit)))
5728          (file-name (git-file-name name version))
5729          (sha256
5730           (base32
5731            "1cwpn1m3wrl0fl9plznn7p464db646gnfc8zkyk97dyxski2aq0x"))))
5732       (inputs
5733        `(("alexandria" ,sbcl-alexandria)))
5734       (arguments
5735        ;; TODO: Tests fail because cl-test-more is missing, but I can't find it online.
5736        `(#:tests? #f))
5737       (synopsis "HTTP cookie manager for Common Lisp")
5738       (description "cl-cookie is a Common Lisp library featuring parsing of
5739 cookie headers, cookie creation, cookie jar creation and more.")
5740       (license license:llgpl))))
5741
5742 (define-public cl-reexport
5743   (sbcl-package->cl-source-package sbcl-cl-reexport))
5744
5745 (define-public sbcl-cl-cookie
5746   (let ((commit "cea55aed8b9ad25fafd13defbcb9fe8f41b29546")
5747         (revision "1"))
5748     (package
5749       (name "sbcl-cl-cookie")
5750       (build-system asdf-build-system/sbcl)
5751       (version (git-version "0.9.10" revision commit))
5752       (home-page "https://github.com/fukamachi/cl-cookie")
5753       (source
5754        (origin
5755          (method git-fetch)
5756          (uri (git-reference
5757                (url home-page)
5758                (commit commit)))
5759          (file-name (git-file-name name version))
5760          (sha256
5761           (base32
5762            "090g7z75h98zvc1ldx0vh4jn4086dhjm2w30jcwkq553qmyxwl8h"))))
5763       (inputs
5764        `(("proc-parse" ,sbcl-proc-parse)
5765          ("alexandria" ,sbcl-alexandria)
5766          ("quri" ,sbcl-quri)
5767          ("cl-ppcre" ,sbcl-cl-ppcre)
5768          ("local-time" ,sbcl-local-time)))
5769       (native-inputs
5770        `(("prove-asdf" ,sbcl-prove-asdf)
5771          ("prove" ,sbcl-prove)))
5772       (arguments
5773        ;; TODO: Tests fail because cl-cookie depends on cl-cookie-test.
5774        `(#:tests? #f))
5775       (synopsis "HTTP cookie manager for Common Lisp")
5776       (description "cl-cookie is a Common Lisp library featuring parsing of
5777 cookie headers, cookie creation, cookie jar creation and more.")
5778       (license license:bsd-2))))
5779
5780 (define-public cl-cookie
5781   (sbcl-package->cl-source-package sbcl-cl-cookie))
5782
5783 (define-public sbcl-dexador
5784   (let ((commit "a2714d126cc94bc7a9a6e1e3c08de455b3a66378")
5785         (revision "1"))
5786     (package
5787       (name "sbcl-dexador")
5788       (build-system asdf-build-system/sbcl)
5789       (version (git-version "0.9.10" revision commit))
5790       (home-page "https://github.com/fukamachi/dexador")
5791       (source
5792        (origin
5793          (method git-fetch)
5794          (uri (git-reference
5795                (url home-page)
5796                (commit commit)))
5797          (file-name (git-file-name name version))
5798          (sha256
5799           (base32
5800            "0nbqgn4v3l2z6m1k1bdxfnqpfrk84nxdmz7csz11zzcfs4flkv79"))))
5801       (inputs
5802        `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)
5803          ("babel" ,sbcl-babel)
5804          ("usocket" ,sbcl-usocket)
5805          ("fast-http" ,sbcl-fast-http)
5806          ("quri" ,sbcl-quri)
5807          ("fast-io" ,sbcl-fast-io)
5808          ("chunga" ,sbcl-chunga)
5809          ("cl-ppcre" ,sbcl-cl-ppcre)
5810          ("cl-cookie" ,sbcl-cl-cookie)
5811          ("trivial-mimes" ,sbcl-trivial-mimes)
5812          ("chipz" ,sbcl-chipz)
5813          ("cl-base64" ,sbcl-cl-base64)
5814          ("cl-reexport" ,sbcl-cl-reexport)
5815          ("cl+ssl" ,sbcl-cl+ssl)
5816          ("bordeaux-threads" ,sbcl-bordeaux-threads)
5817          ("alexandria" ,sbcl-alexandria)))
5818       (native-inputs
5819        `(("prove" ,sbcl-prove)
5820          ("prove-asdf" ,sbcl-prove-asdf)
5821          ("lack-request" ,sbcl-lack-request)
5822          ("clack" ,sbcl-clack)
5823          ("babel" ,sbcl-babel)
5824          ("alexandria" ,sbcl-alexandria)
5825          ("cl-ppcre" ,sbcl-cl-ppcre)
5826          ("local-time" ,sbcl-local-time)))
5827       (arguments
5828        ;; TODO: Circular dependency: tests depend on clack-test which depends on dexador.
5829        `(#:tests? #f
5830          #:phases
5831          (modify-phases %standard-phases
5832            (add-after 'unpack 'fix-permissions
5833              (lambda _ (make-file-writable "t/data/test.gz") #t)))))
5834       (synopsis "Yet another HTTP client for Common Lisp")
5835       (description "Dexador is yet another HTTP client for Common Lisp with
5836 neat APIs and connection-pooling.  It is meant to supersede Drakma.")
5837       (license license:expat))))
5838
5839 (define-public cl-dexador
5840   (package
5841     (inherit (sbcl-package->cl-source-package sbcl-dexador))
5842     (arguments
5843      `(#:phases
5844        ;; asdf-build-system/source has its own phases and does not inherit
5845        ;; from asdf-build-system/sbcl phases.
5846        (modify-phases %standard-phases/source
5847          (add-after 'unpack 'fix-permissions
5848            (lambda _ (make-file-writable "t/data/test.gz") #t)))))))
5849
5850 (define-public ecl-dexador
5851   (sbcl-package->ecl-package sbcl-dexador))
5852
5853 (define-public sbcl-lisp-namespace
5854   (let ((commit "28107cafe34e4c1c67490fde60c7f92dc610b2e0")
5855         (revision "1"))
5856     (package
5857       (name "sbcl-lisp-namespace")
5858       (build-system asdf-build-system/sbcl)
5859       (version (git-version "0.1" revision commit))
5860       (home-page "https://github.com/guicho271828/lisp-namespace")
5861       (source
5862        (origin
5863          (method git-fetch)
5864          (uri (git-reference
5865                (url home-page)
5866                (commit commit)))
5867          (file-name (git-file-name name version))
5868          (sha256
5869           (base32
5870            "1jw2wykp06z2afb9nm1lgfzll5cjlj36pnknjx614057zkkxq4iy"))))
5871       (inputs
5872        `(("alexandria" ,sbcl-alexandria)))
5873       (native-inputs
5874        `(("fiveam" ,sbcl-fiveam)))
5875       (arguments
5876        `(#:test-asd-file "lisp-namespace.test.asd"
5877         ;; XXX: Component LISP-NAMESPACE-ASD::LISP-NAMESPACE.TEST not found
5878          #:tests? #f))
5879       (synopsis "LISP-N, or extensible namespaces in Common Lisp")
5880       (description "Common Lisp already has major 2 namespaces, function
5881 namespace and value namespace (or variable namespace), but there are actually
5882 more — e.g., class namespace.
5883 This library offers macros to deal with symbols from any namespace.")
5884       (license license:llgpl))))
5885
5886 (define-public cl-lisp-namespace
5887   (sbcl-package->cl-source-package sbcl-lisp-namespace))
5888
5889 (define-public sbcl-trivial-cltl2
5890   (let ((commit "8eec8407df833e8f27df8a388bc10913f16d9e83")
5891         (revision "1"))
5892     (package
5893       (name "sbcl-trivial-cltl2")
5894       (build-system asdf-build-system/sbcl)
5895       (version (git-version "0.1.1" revision commit))
5896       (home-page "https://github.com/Zulu-Inuoe/trivial-cltl2")
5897       (source
5898        (origin
5899          (method git-fetch)
5900          (uri (git-reference
5901                (url home-page)
5902                (commit commit)))
5903          (file-name (git-file-name name version))
5904          (sha256
5905           (base32
5906            "1dyyxz17vqv8hlfwq287gl8xxbvcnq798ajb7p5jdjz91wqf4bgk"))))
5907       (synopsis "Simple CLtL2 compatibility layer for Common Lisp")
5908       (description "This library is a portable compatibility layer around
5909 \"Common Lisp the Language, 2nd
5910 Edition\" (@url{https://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node102.html})
5911 and it exports symbols from implementation-specific packages.")
5912       (license license:llgpl))))
5913
5914 (define-public cl-trivial-cltl2
5915   (sbcl-package->cl-source-package sbcl-trivial-cltl2))
5916
5917 (define-public sbcl-introspect-environment
5918   (let ((commit "fff42f8f8fd0d99db5ad6c5812e53de7d660020b")
5919         (revision "1"))
5920     (package
5921       (name "sbcl-introspect-environment")
5922       (build-system asdf-build-system/sbcl)
5923       (version (git-version "0.1" revision commit))
5924       (home-page "https://github.com/Bike/introspect-environment")
5925       (source
5926        (origin
5927          (method git-fetch)
5928          (uri (git-reference
5929                (url home-page)
5930                (commit commit)))
5931          (file-name (git-file-name name version))
5932          (sha256
5933           (base32
5934            "1i305n0wfmpac63ni4i3vixnnkl8daw5ncxy0k3dv92krgx6qzhp"))))
5935       (native-inputs
5936        `(("fiveam" ,sbcl-fiveam)))
5937       (synopsis "Common Lisp environment introspection portability layer")
5938       (description "This library is a small interface to portable but
5939 nonstandard introspection of Common Lisp environments.  It is intended to
5940 allow a bit more compile-time introspection of environments in Common Lisp.
5941
5942 Quite a bit of information is available at the time a macro or compiler-macro
5943 runs; inlining info, type declarations, that sort of thing.  This information
5944 is all standard - any Common Lisp program can @code{(declare (integer x))} and
5945 such.
5946
5947 This info ought to be accessible through the standard @code{&environment}
5948 parameters, but it is not.  Several implementations keep the information for
5949 their own purposes but do not make it available to user programs, because
5950 there is no standard mechanism to do so.
5951
5952 This library uses implementation-specific hooks to make information available
5953 to users.  This is currently supported on SBCL, CCL, and CMUCL.  Other
5954 implementations have implementations of the functions that do as much as they
5955 can and/or provide reasonable defaults.")
5956       (license license:wtfpl2))))
5957
5958 (define-public cl-introspect-environment
5959   (sbcl-package->cl-source-package sbcl-introspect-environment))
5960
5961 (define-public sbcl-type-i
5962   (let ((commit "dea233f45f94064105ec09f0767de338f67dcbe2")
5963         (revision "1"))
5964     (package
5965       (name "sbcl-type-i")
5966       (build-system asdf-build-system/sbcl)
5967       (version (git-version "0.1" revision commit))
5968       (home-page "https://github.com/guicho271828/type-i")
5969       (source
5970        (origin
5971          (method git-fetch)
5972          (uri (git-reference
5973                (url home-page)
5974                (commit commit)))
5975          (file-name (git-file-name name version))
5976          (sha256
5977           (base32
5978            "039g5pbrhh65s0bhr9314gmd2nwc2y5lp2377c5qrc2lxky89qs3"))))
5979       (inputs
5980        `(("alexandria" ,sbcl-alexandria)
5981          ("introspect-environment" ,sbcl-introspect-environment)
5982          ("trivia.trivial" ,sbcl-trivia.trivial)))
5983       (native-inputs
5984        `(("fiveam" ,sbcl-fiveam)))
5985       (arguments
5986        `(#:test-asd-file "type-i.test.asd"))
5987       (synopsis "Type inference utility on unary predicates for Common Lisp")
5988       (description "This library tries to provide a way to detect what kind of
5989 type the given predicate is trying to check.  This is different from inferring
5990 the return type of a function.")
5991       (license license:llgpl))))
5992
5993 (define-public cl-type-i
5994   (sbcl-package->cl-source-package sbcl-type-i))
5995
5996 (define-public sbcl-optima
5997   (let ((commit "373b245b928c1a5cce91a6cb5bfe5dd77eb36195")
5998         (revision "1"))
5999     (package
6000       (name "sbcl-optima")
6001       (build-system asdf-build-system/sbcl)
6002       (version (git-version "1.0" revision commit))
6003       (home-page "https://github.com/m2ym/optima")
6004       (source
6005        (origin
6006          (method git-fetch)
6007          (uri (git-reference
6008                (url home-page)
6009                (commit commit)))
6010          (file-name (git-file-name name version))
6011          (sha256
6012           (base32
6013            "1yw4ymq7ms89342kkvb3aqxgv0w38m9kd8ikdqxxzyybnkjhndal"))))
6014       (inputs
6015        `(("alexandria" ,sbcl-alexandria)
6016          ("closer-mop" ,sbcl-closer-mop)))
6017       (native-inputs
6018        `(("eos" ,sbcl-eos)))
6019       (arguments
6020        ;; XXX: Circular dependencies: tests depend on optima.ppcre which depends on optima.
6021        `(#:tests? #f
6022          #:test-asd-file "optima.test.asd"))
6023       (synopsis "Optimized pattern matching library for Common Lisp")
6024       (description "Optima is a fast pattern matching library which uses
6025 optimizing techniques widely used in the functional programming world.")
6026       (license license:expat))))
6027
6028 (define-public cl-optima
6029   (sbcl-package->cl-source-package sbcl-optima))
6030
6031 (define-public sbcl-fare-quasiquote
6032   (let ((commit "640d39a0451094071b3e093c97667b3947f43639")
6033         (revision "1"))
6034     (package
6035       (name "sbcl-fare-quasiquote")
6036       (build-system asdf-build-system/sbcl)
6037       (version (git-version "1.0.1" revision commit))
6038       (home-page "https://gitlab.common-lisp.net/frideau/fare-quasiquote")
6039       (source
6040        (origin
6041          (method git-fetch)
6042          (uri (git-reference
6043                (url (string-append "https://gitlab.common-lisp.net/frideau/"
6044                                    "fare-quasiquote.git"))
6045                (commit commit)))
6046          (file-name (git-file-name name version))
6047          (sha256
6048           (base32 "1g6q11l50kgija9f55lzqpcwvaq0ljiw8v1j265hnyg6nahjwjvg"))))
6049       (inputs
6050        `(("fare-utils" ,sbcl-fare-utils)))
6051       (arguments
6052        ;; XXX: Circular dependencies: Tests depend on subsystems,
6053        ;; which depend on the main systems.
6054        `(#:tests? #f
6055          #:phases
6056          (modify-phases %standard-phases
6057            ;; XXX: Require 1.0.0 version of fare-utils, and we package some
6058            ;; commits after 1.0.0.5, but ASDF fails to read the
6059            ;; "-REVISION-COMMIT" part generated by Guix.
6060            (add-after 'unpack 'patch-requirement
6061              (lambda _
6062                (substitute* "fare-quasiquote.asd"
6063                  (("\\(:version \"fare-utils\" \"1.0.0\"\\)")
6064                   "\"fare-utils\"")))))))
6065       (synopsis "Pattern-matching friendly implementation of quasiquote")
6066       (description "The main purpose of this n+2nd reimplementation of
6067 quasiquote is enable matching of quasiquoted patterns, using Optima or
6068 Trivia.")
6069       (license license:expat))))
6070
6071 (define-public cl-fare-quasiquote
6072   (sbcl-package->cl-source-package sbcl-fare-quasiquote))
6073
6074 (define-public sbcl-fare-quasiquote-optima
6075   (package
6076     (inherit sbcl-fare-quasiquote)
6077     (name "sbcl-fare-quasiquote-optima")
6078     (inputs
6079      `(("optima" ,sbcl-optima)
6080        ("fare-quasiquote" ,sbcl-fare-quasiquote)))
6081     (arguments
6082      '(#:phases
6083        (modify-phases %standard-phases
6084          (add-after 'unpack 'patch-requirement
6085            (lambda _
6086              (substitute* "fare-quasiquote-optima.asd"
6087                (("\\(:version \"optima\" \"1\\.0\"\\)")
6088                 "\"optima\""))
6089              #t)))))))
6090
6091 (define-public cl-fare-quasiquote-optima
6092   (sbcl-package->cl-source-package sbcl-fare-quasiquote-optima))
6093
6094 (define-public sbcl-fare-quasiquote-readtable
6095   (package
6096     (inherit sbcl-fare-quasiquote)
6097     (name "sbcl-fare-quasiquote-readtable")
6098     (inputs
6099      `(("fare-quasiquote" ,sbcl-fare-quasiquote)
6100        ("named-readtables" ,sbcl-named-readtables)))
6101     (description "The main purpose of this n+2nd reimplementation of
6102 quasiquote is enable matching of quasiquoted patterns, using Optima or
6103 Trivia.
6104
6105 This package uses fare-quasiquote with named-readtable.")))
6106
6107 (define-public cl-fare-quasiquote-readtable
6108   (sbcl-package->cl-source-package sbcl-fare-quasiquote-readtable))
6109
6110 ;; TODO: Add support for component-less system in asdf-build-system/sbcl.
6111 (define-public sbcl-fare-quasiquote-extras
6112   (package
6113     (inherit sbcl-fare-quasiquote)
6114     (name "sbcl-fare-quasiquote-extras")
6115     (build-system asdf-build-system/sbcl)
6116     (inputs
6117      `(("fare-quasiquote-optima" ,sbcl-fare-quasiquote-optima)
6118        ("fare-quasiquote-readtable" ,sbcl-fare-quasiquote-readtable)))
6119     (arguments
6120      `(#:phases
6121        (modify-phases %standard-phases
6122          (replace 'build
6123            (lambda* (#:key outputs #:allow-other-keys)
6124              (let* ((out (assoc-ref outputs "out"))
6125                     (lib (string-append out "/lib/" (%lisp-type))))
6126                (mkdir-p lib)
6127                (install-file "fare-quasiquote-extras.asd" lib)
6128                (make-file-writable
6129                 (string-append lib "/fare-quasiquote-extras.asd"))
6130                #t)))
6131          (add-after 'create-asd-file 'fix-asd-file
6132            (lambda* (#:key outputs #:allow-other-keys)
6133              (let* ((out (assoc-ref outputs "out"))
6134                     (lib (string-append out "/lib/" (%lisp-type)))
6135                     (asd (string-append lib "/fare-quasiquote-extras.asd")))
6136                (substitute* asd
6137                  ((":class")
6138                   "")
6139                  (("asdf/bundle:prebuilt-system")
6140                   "")
6141                  ((":components")
6142                   "")
6143                  (("\\(\\(:compiled-file \"fare-quasiquote-extras--system\"\\)\\)")
6144                   "")))
6145              #t)))))
6146     (description "This library combines @code{fare-quasiquote-readtable} and
6147 @code{fare-quasiquote-optima}.")))
6148
6149 (define-public cl-fare-quasiquote-extras
6150   (package
6151     (inherit cl-fare-quasiquote)
6152     (name "cl-fare-quasiquote-extras")
6153     (build-system asdf-build-system/source)
6154     (propagated-inputs
6155      `(("fare-quasiquote" ,cl-fare-quasiquote)
6156        ("fare-quasiquote-optima" ,cl-fare-quasiquote-optima)
6157        ("fare-quasiquote-readtable" ,cl-fare-quasiquote-readtable)))
6158     (description "This library combines @code{fare-quasiquote-readtable} and
6159 @code{fare-quasiquote-optima}.")))
6160
6161 (define-public sbcl-trivia.level0
6162   (let ((commit "574901ac376ae54c9d37169fd5efab9b3b8fcc63")
6163         (revision "1"))
6164     (package
6165       (name "sbcl-trivia.level0")
6166       (build-system asdf-build-system/sbcl)
6167       (version (git-version "0.0.0" revision commit))
6168       (home-page "https://github.com/guicho271828/trivia")
6169       (source
6170        (origin
6171          (method git-fetch)
6172          (uri (git-reference
6173                (url home-page)
6174                (commit commit)))
6175          (file-name (git-file-name name version))
6176          (sha256
6177           (base32
6178            "0hf53n71xzr9sjwrxis5fivx3drclf4s39h5ck8vh21ndqj9zvdk"))))
6179       (inputs
6180        `(("alexandria" ,sbcl-alexandria)))
6181       (synopsis "Pattern matching in Common Lisp")
6182       (description "Trivia is a pattern matching compiler that is compatible
6183 with Optima, another pattern matching library for Common Lisp.  It is meant to
6184 be faster and more extensible than Optima.")
6185       (license license:llgpl))))
6186
6187 (define-public sbcl-trivia.level1
6188   (package
6189     (inherit sbcl-trivia.level0)
6190     (name "sbcl-trivia.level1")
6191     (inputs
6192      `(("trivia.level0" ,sbcl-trivia.level0)))
6193     (description "Trivia is a pattern matching compiler that is compatible
6194 with Optima, another pattern matching library for Common Lisp.  It is meant to
6195 be faster and more extensible than Optima.
6196
6197 This system contains the core patterns of Trivia.")))
6198
6199 (define-public sbcl-trivia.level2
6200   (package
6201     (inherit sbcl-trivia.level0)
6202     (name "sbcl-trivia.level2")
6203     (inputs
6204      `(("trivia.level1" ,sbcl-trivia.level1)
6205        ("lisp-namespace" ,sbcl-lisp-namespace)
6206        ("trivial-cltl2" ,sbcl-trivial-cltl2)
6207        ("closer-mop" ,sbcl-closer-mop)))
6208     (description "Trivia is a pattern matching compiler that is compatible
6209 with Optima, another pattern matching library for Common Lisp.  It is meant to
6210 be faster and more extensible than Optima.
6211
6212 This system contains a non-optimized pattern matcher compatible with Optima,
6213 with extensible optimizer interface.")))
6214
6215 (define-public sbcl-trivia.trivial
6216   (package
6217     (inherit sbcl-trivia.level0)
6218     (name "sbcl-trivia.trivial")
6219     (inputs
6220      `(("trivia.level2" ,sbcl-trivia.level2)))
6221     (arguments
6222      `(#:phases
6223        (modify-phases %standard-phases
6224          (replace 'create-asd-file
6225            (lambda* (#:key outputs inputs #:allow-other-keys)
6226              (let* ((out (assoc-ref outputs "out"))
6227                     (lib (string-append out "/lib/" (%lisp-type)))
6228                     (level2 (assoc-ref inputs "trivia.level2")))
6229                (mkdir-p lib)
6230                (install-file "trivia.trivial.asd" lib)
6231                ;; XXX: This .asd does not have any component and the build
6232                ;; system fails to work in this case.  We should update the
6233                ;; build system to handle component-less .asd.
6234                ;; TODO: How do we append to file in Guile?  It seems that
6235                ;; (open-file ... "a") gets a "Permission denied".
6236                (substitute* (string-append lib "/trivia.trivial.asd")
6237                  (("\"\\)")
6238                   (string-append "\")
6239
6240 (progn (asdf/source-registry:ensure-source-registry)
6241        (setf (gethash
6242                \"trivia.level2\"
6243                asdf/source-registry:*source-registry*)
6244              #p\""
6245                                  level2
6246                                  "/share/common-lisp/sbcl-bundle-systems/trivia.level2.asd\"))")))))))))
6247     (description "Trivia is a pattern matching compiler that is compatible
6248 with Optima, another pattern matching library for Common Lisp.  It is meant to
6249 be faster and more extensible than Optima.
6250
6251 This system contains the base level system of Trivia with a trivial optimizer.")))
6252
6253 (define-public sbcl-trivia.balland2006
6254   (package
6255     (inherit sbcl-trivia.level0)
6256     (name "sbcl-trivia.balland2006")
6257     (inputs
6258      `(("trivia.trivial" ,sbcl-trivia.trivial)
6259        ("iterate" ,sbcl-iterate)
6260        ("type-i" ,sbcl-type-i)
6261        ("alexandria" ,sbcl-alexandria)))
6262     (arguments
6263      ;; Tests are done in trivia itself.
6264      `(#:tests? #f))
6265     (description "Trivia is a pattern matching compiler that is compatible
6266 with Optima, another pattern matching library for Common Lisp.  It is meant to
6267 be faster and more extensible than Optima.
6268
6269 This system contains the base level system of Trivia with a trivial optimizer.")))
6270
6271 (define-public sbcl-trivia.ppcre
6272   (package
6273     (inherit sbcl-trivia.level0)
6274     (name "sbcl-trivia.ppcre")
6275     (inputs
6276      `(("trivia.trivial" ,sbcl-trivia.trivial)
6277        ("cl-ppcre" ,sbcl-cl-ppcre)))
6278     (description "Trivia is a pattern matching compiler that is compatible
6279 with Optima, another pattern matching library for Common Lisp.  It is meant to
6280 be faster and more extensible than Optima.
6281
6282 This system contains the PPCRE extension.")))
6283
6284 (define-public sbcl-trivia.quasiquote
6285   (package
6286     (inherit sbcl-trivia.level0)
6287     (name "sbcl-trivia.quasiquote")
6288     (inputs
6289      `(("trivia.trivial" ,sbcl-trivia.trivial)
6290        ("fare-quasiquote" ,sbcl-fare-quasiquote)
6291        ("fare-quasiquote-readtable" ,sbcl-fare-quasiquote-readtable)))
6292     (description "Trivia is a pattern matching compiler that is compatible
6293 with Optima, another pattern matching library for Common Lisp.  It is meant to
6294 be faster and more extensible than Optima.
6295
6296 This system contains the fare-quasiquote extension.")))
6297
6298 (define-public sbcl-trivia.cffi
6299   (package
6300     (inherit sbcl-trivia.level0)
6301     (name "sbcl-trivia.cffi")
6302     (inputs
6303      `(("cffi" ,sbcl-cffi)
6304        ("trivia.trivial" ,sbcl-trivia.trivial)))
6305     (description "Trivia is a pattern matching compiler that is compatible
6306 with Optima, another pattern matching library for Common Lisp.  It is meant to
6307 be faster and more extensible than Optima.
6308
6309 This system contains the CFFI foreign slot access extension.")))
6310
6311 (define-public sbcl-trivia
6312   (package
6313     (inherit sbcl-trivia.level0)
6314     (name "sbcl-trivia")
6315     (inputs
6316      `(("trivia.balland2006" ,sbcl-trivia.balland2006)))
6317     (native-inputs
6318      `(("fiveam" ,sbcl-fiveam)
6319        ("trivia.ppcre" ,sbcl-trivia.ppcre)
6320        ("trivia.quasiquote" ,sbcl-trivia.quasiquote)
6321        ("trivia.cffi" ,sbcl-trivia.cffi)
6322        ("optima" ,sbcl-optima)))
6323     (arguments
6324      `(#:test-asd-file "trivia.test.asd"
6325        #:phases
6326        (modify-phases %standard-phases
6327          (add-after 'create-asd 'remove-component
6328            ;; XXX: The original .asd has no components, but our build system
6329            ;; creates an entry nonetheless.  We need to remove it for the
6330            ;; generated .asd to load properly.  See trivia.trivial for a
6331            ;; similar problem.
6332            (lambda* (#:key outputs #:allow-other-keys)
6333              (let* ((out (assoc-ref outputs "out"))
6334                     (asd (string-append out "/lib/" (%lisp-type) "/trivia.asd")))
6335                (substitute* asd
6336                  (("  :components
6337 ")
6338                   ""))
6339                (substitute* asd
6340                  ((" *\\(\\(:compiled-file \"trivia--system\"\\)\\)")
6341                   ""))))))))
6342     (description "Trivia is a pattern matching compiler that is compatible
6343 with Optima, another pattern matching library for Common Lisp.  It is meant to
6344 be faster and more extensible than Optima.")))
6345
6346 (define-public cl-trivia
6347   (sbcl-package->cl-source-package sbcl-trivia))
6348
6349 (define-public sbcl-mk-string-metrics
6350   (package
6351     (name "sbcl-mk-string-metrics")
6352     (version "0.1.2")
6353     (home-page "https://github.com/cbaggers/mk-string-metrics/")
6354     (source (origin
6355               (method git-fetch)
6356               (uri (git-reference
6357                     (url home-page)
6358                     (commit version)))
6359               (sha256
6360                (base32 "0bg0bv2mfd4k0g3x72x563hvmrx18xavaffr6xk5rh4if5j7kcf6"))
6361               (file-name (git-file-name name version))))
6362     (build-system asdf-build-system/sbcl)
6363     (synopsis "Calculate various string metrics efficiently in Common Lisp")
6364     (description "This library implements efficient algorithms that calculate
6365 various string metrics in Common Lisp:
6366
6367 @itemize
6368 @item Damerau-Levenshtein distance
6369 @item Hamming distance
6370 @item Jaccard similarity coefficient
6371 @item Jaro distance
6372 @item Jaro-Winkler distance
6373 @item Levenshtein distance
6374 @item Normalized Damerau-Levenshtein distance
6375 @item Normalized Levenshtein distance
6376 @item Overlap coefficient
6377 @end itemize\n")
6378     (license license:x11)))
6379
6380 (define-public cl-mk-string-metrics
6381   (sbcl-package->cl-source-package sbcl-mk-string-metrics))
6382
6383 (define-public sbcl-cl-str
6384   (let ((commit "eb480f283e28802d67b35bf916506701152f9a2a"))
6385     (package
6386       (name "sbcl-cl-str")
6387       (version (git-version "0.17" "1" commit))
6388       (home-page "https://github.com/vindarel/cl-str")
6389       (source (origin
6390                 (method git-fetch)
6391                 (uri (git-reference
6392                       (url home-page)
6393                       (commit commit)))
6394                 (sha256
6395                  (base32 "1hpq5m8zjjnzns370zy27z2vcm1p8n2ka5ij2x67gyc9amz9vla0"))
6396                 (file-name (git-file-name name version))))
6397       (build-system asdf-build-system/sbcl)
6398       (inputs
6399        `(("cl-ppcre" ,sbcl-cl-ppcre)
6400          ("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)
6401          ("cl-change-case" ,sbcl-cl-change-case)))
6402       (native-inputs
6403        `(("prove" ,sbcl-prove)
6404          ("prove-asdf" ,sbcl-prove-asdf)))
6405       (arguments
6406        `(#:asd-file "str.asd"
6407          #:asd-system-name "str"
6408          #:test-asd-file "str.test.asd"))
6409       (synopsis "Modern, consistent and terse Common Lisp string manipulation library")
6410       (description "A modern and consistent Common Lisp string manipulation
6411 library that focuses on modernity, simplicity and discoverability:
6412 @code{(str:trim s)} instead of @code{(string-trim '(#\\Space ...) s)}), or
6413 @code{str:concat strings} instead of an unusual format construct; one
6414 discoverable library instead of many; consistency and composability, where
6415 @code{s} is always the last argument, which makes it easier to feed pipes and
6416 arrows.")
6417       (license license:expat))))
6418
6419 (define-public cl-str
6420   (sbcl-package->cl-source-package sbcl-cl-str))
6421
6422 (define-public sbcl-cl-xmlspam
6423   (let ((commit "ea06abcca2a73a9779bcfb09081e56665f94e22a"))
6424     (package
6425       (name "sbcl-cl-xmlspam")
6426       (build-system asdf-build-system/sbcl)
6427       (version (git-version "0.0.0" "1" commit))
6428       (home-page "https://github.com/rogpeppe/cl-xmlspam")
6429       (source
6430        (origin
6431          (method git-fetch)
6432          (uri (git-reference
6433                (url home-page)
6434                (commit commit)))
6435          (file-name (string-append name "-" version))
6436          (sha256
6437           (base32
6438            "0w4rqvrgdgk3fwfq3kx4r7wwdr2bv3b6n3bdqwsiriw9psqzpz2s"))))
6439       (inputs
6440        `(("cxml" ,sbcl-cxml)
6441          ("cl-ppcre" ,sbcl-cl-ppcre)))
6442       (synopsis "Concise, regexp-like pattern matching on streaming XML for Common Lisp")
6443       (description "CXML does an excellent job at parsing XML elements, but what
6444 do you do when you have a XML file that's larger than you want to fit in
6445 memory, and you want to extract some information from it?  Writing code to deal
6446 with SAX events, or even using Klacks, quickly becomes tedious.
6447 @code{cl-xmlspam} (for XML Stream PAttern Matcher) is designed to make it easy
6448 to write code that mirrors the structure of the XML that it's parsing.  It
6449 also makes it easy to shift paradigms when necessary - the usual Lisp control
6450 constructs can be used interchangeably with pattern matching, and the full
6451 power of CXML is available when necessary.")
6452       (license license:bsd-3))))
6453
6454 ;; TODO: dbus uses ASDF's package-inferred-system which is not supported by
6455 ;; asdf-build-system/sbcl as of 2019-08-02.  We should fix
6456 ;; asdf-build-system/sbcl.
6457 (define-public cl-dbus
6458   (let ((commit "24b452df3a45ca5dc95015500f34baad175c981a")
6459         (revision "1"))
6460     (package
6461       (name "cl-dbus")
6462       (build-system asdf-build-system/source)
6463       (version (git-version "20190408" revision commit))
6464       (home-page "https://github.com/death/dbus")
6465       (source
6466        (origin
6467          (method git-fetch)
6468          (uri (git-reference
6469                (url home-page)
6470                (commit commit)))
6471          (file-name (git-file-name name version))
6472          (sha256
6473           (base32
6474            "0fw2q866yddbf23nk9pxphm9gsasx35vjyss82xzvndnjmzlqfl5"))))
6475       ;; Inputs must be propagated or else packages depending on this won't
6476       ;; have the necessary packages.
6477       (propagated-inputs
6478        `(("alexandria" ,sbcl-alexandria)
6479          ("trivial-garbage" ,sbcl-trivial-garbage)
6480          ("babel" ,sbcl-babel)
6481          ("iolib" ,sbcl-iolib)
6482          ("ieee-floats" ,sbcl-ieee-floats)
6483          ("flexi-streams" ,sbcl-flexi-streams)
6484          ("cl-xmlspam" ,sbcl-cl-xmlspam)
6485          ("ironclad" ,sbcl-ironclad)))
6486       (synopsis "D-Bus client library for Common Lisp")
6487       (description "This is a Common Lisp library that publishes D-Bus
6488 objects as well as send and notify other objects connected to a bus.")
6489       (license license:bsd-2))))
6490
6491 (define-public sbcl-cl-hooks
6492   (let ((commit "5b638083f3b4f1221a52631d9c8a0a265565cac7")
6493         (revision "1"))
6494     (package
6495       (name "sbcl-cl-hooks")
6496       (build-system asdf-build-system/sbcl)
6497       (version (git-version "0.2.1" revision commit))
6498       (home-page "https://github.com/scymtym/architecture.hooks")
6499       (source
6500        (origin
6501          (method git-fetch)
6502          (uri (git-reference
6503                (url home-page)
6504                (commit commit)))
6505          (file-name (git-file-name name version))
6506          (sha256
6507           (base32
6508            "0bg3l0a28lw5gqqjp6p6b5nhwqk46sgkb7184w5qbfngw1hk8x9y"))))
6509       (inputs
6510        `(("alexandria" ,sbcl-alexandria)
6511          ("let-plus" ,sbcl-let-plus)
6512          ("trivial-garbage" ,sbcl-trivial-garbage)
6513          ("closer-mop" ,sbcl-closer-mop)))
6514       (native-inputs
6515        `(("fiveam" ,sbcl-fiveam)))
6516       (synopsis "Hooks extension point mechanism (as in Emacs) for Common Lisp")
6517       (description "A hook, in the present context, is a certain kind of
6518 extension point in a program that allows interleaving the execution of
6519 arbitrary code with the execution of a the program without introducing any
6520 coupling between the two.  Hooks are used extensively in the extensible editor
6521 Emacs.
6522
6523 In the Common LISP Object System (CLOS), a similar kind of extensibility is
6524 possible using the flexible multi-method dispatch mechanism.  It may even seem
6525 that the concept of hooks does not provide any benefits over the possibilities
6526 of CLOS.  However, there are some differences:
6527
6528 @itemize
6529
6530 @item There can be only one method for each combination of specializers and
6531 qualifiers.  As a result this kind of extension point cannot be used by
6532 multiple extensions independently.
6533 @item Removing code previously attached via a @code{:before}, @code{:after} or
6534 @code{:around} method can be cumbersome.
6535 @item There could be other or even multiple extension points besides @code{:before}
6536 and @code{:after} in a single method.
6537 @item Attaching codes to individual objects using eql specializers can be
6538 cumbersome.
6539 @item Introspection of code attached a particular extension point is
6540 cumbersome since this requires enumerating and inspecting the methods of a
6541 generic function.
6542 @end itemize
6543
6544 This library tries to complement some of these weaknesses of method-based
6545 extension-points via the concept of hooks.")
6546       (license license:llgpl))))
6547
6548 (define-public cl-hooks
6549   (sbcl-package->cl-source-package sbcl-cl-hooks))
6550
6551 (define-public ecl-cl-hooks
6552   (sbcl-package->ecl-package sbcl-cl-hooks))
6553
6554 (define-public sbcl-s-sysdeps
6555   (let ((commit "d28246b5dffef9e73a0e0e6cfbc4e878006fe34d")
6556         (revision "1"))
6557     (package
6558       (name "sbcl-s-sysdeps")
6559       (build-system asdf-build-system/sbcl)
6560       (version (git-version "1" revision commit))
6561       (home-page "https://github.com/svenvc/s-sysdeps")
6562       (source
6563        (origin
6564          (method git-fetch)
6565          (uri (git-reference
6566                (url home-page)
6567                (commit commit)))
6568          (file-name (git-file-name name version))
6569          (sha256
6570           (base32
6571            "14b69b81yrxmjlvmm3lfxk04x5v7hqz4fql121334wh72czznfh9"))))
6572       (synopsis "Common Lisp abstraction layer over platform dependent functionality")
6573       (description "@code{s-sysdeps} is an abstraction layer over platform
6574 dependent functionality.  This simple package is used as a building block in a
6575 number of other open source projects.
6576
6577 @code{s-sysdeps} abstracts:
6578
6579 @itemize
6580 @item managing processes,
6581 @item implementing a standard TCP/IP server,
6582 @item opening a client TCP/IP socket stream,
6583 @item working with process locks.
6584 @end itemize\n")
6585       (license license:llgpl))))
6586
6587 (define-public cl-s-sysdeps
6588   (sbcl-package->cl-source-package sbcl-s-sysdeps))
6589
6590 (define-public ecl-s-sysdeps
6591   (sbcl-package->ecl-package sbcl-s-sysdeps))
6592
6593 (define-public sbcl-cl-prevalence
6594   (let ((commit "c163c227ed85d430b82cb1e3502f72d4f88e3cfa")
6595         (revision "1"))
6596     (package
6597       (name "sbcl-cl-prevalence")
6598       (build-system asdf-build-system/sbcl)
6599       (version (git-version "5" revision commit))
6600       (home-page "https://github.com/40ants/cl-prevalence")
6601       (source
6602        (origin
6603          (method git-fetch)
6604          (uri (git-reference
6605                (url home-page)
6606                (commit commit)))
6607          (file-name (git-file-name name version))
6608          (sha256
6609           (base32
6610            "1i9zj1q2ahgwch56an21yzbgkynz0kab9fyxkq9mg8p3xrv38jjn"))))
6611       (inputs
6612        `(("s-sysdeps" ,sbcl-s-sysdeps)
6613          ("s-xml" ,sbcl-s-xml)))
6614       (synopsis "Implementation of object prevalence for Common Lisp")
6615       (description "This Common Lisp library implements object prevalence (see
6616 @url{https://en.wikipedia.org/wiki/System_prevalence}).  It allows
6617 for (de)serializing to and from s-exps as well as XML.  Serialization of arbitrary
6618 classes and cyclic data structures are supported.")
6619       (license license:llgpl))))
6620
6621 (define-public cl-prevalence
6622   (sbcl-package->cl-source-package sbcl-cl-prevalence))
6623
6624 (define-public ecl-cl-prevalence
6625   (sbcl-package->ecl-package sbcl-cl-prevalence))
6626
6627 (define-public sbcl-series
6628   (let ((commit "da9061b336119d1e5214aff9117171d494d5a58a")
6629         (revision "1"))
6630     (package
6631       (name "sbcl-series")
6632       (version (git-version "2.2.11" revision commit))
6633       (source
6634        (origin
6635          (method git-fetch)
6636          (uri (git-reference
6637                (url "git://git.code.sf.net/p/series/series")
6638                (commit commit)))
6639          (file-name (git-file-name name version))
6640          (sha256
6641           (base32
6642            "07hk2lhfx42zk018pxqvn4gs77vd4n4g8m4xxbqaxgca76mifwfw"))))
6643       (build-system asdf-build-system/sbcl)
6644       (arguments
6645        ;; Disable the tests, they are apparently buggy and I didn't find
6646        ;; a simple way to make them run and pass.
6647        '(#:tests? #f))
6648       (synopsis "Series data structure for Common Lisp")
6649       (description
6650        "This Common Lisp library provides a series data structure much like
6651 a sequence, with similar kinds of operations.  The difference is that in many
6652 situations, operations on series may be composed functionally and yet execute
6653 iteratively, without the need to construct intermediate series values
6654 explicitly.  In this manner, series provide both the clarity of a functional
6655 programming style and the efficiency of an iterative programming style.")
6656       (home-page "http://series.sourceforge.net/")
6657       (license license:expat))))
6658
6659 (define-public cl-series
6660   (sbcl-package->cl-source-package sbcl-series))
6661
6662 (define-public ecl-series
6663   (sbcl-package->ecl-package sbcl-series))
6664
6665 (define-public sbcl-periods
6666   (let ((commit "983d4a57325db3c8def942f163133cec5391ec28")
6667         (revision "1"))
6668     (package
6669       (name "sbcl-periods")
6670       (version (git-version "0.0.2" revision commit))
6671       (source
6672        (origin
6673          (method git-fetch)
6674          (uri (git-reference
6675                (url "https://github.com/jwiegley/periods.git")
6676                (commit commit)))
6677          (file-name (git-file-name name version))
6678          (sha256
6679           (base32
6680            "0z30jr3lxz3cmi019fsl4lgcgwf0yqpn95v9zkkkwgymdrkd4lga"))))
6681       (build-system asdf-build-system/sbcl)
6682       (inputs
6683        `(("local-time" ,sbcl-local-time)))
6684       (synopsis "Common Lisp library for manipulating date/time objects")
6685       (description
6686        "Periods is a Common Lisp library providing a set of utilities for
6687 manipulating times, distances between times, and both contiguous and
6688 discontiguous ranges of time.")
6689       (home-page "https://github.com/jwiegley/periods")
6690       (license license:bsd-3))))
6691
6692 (define-public cl-periods
6693   (sbcl-package->cl-source-package sbcl-periods))
6694
6695 (define-public ecl-periods
6696   (sbcl-package->ecl-package sbcl-periods))
6697
6698 (define-public sbcl-periods-series
6699   (package
6700     (inherit sbcl-periods)
6701     (name "sbcl-periods-series")
6702     (inputs
6703      `(("periods" ,sbcl-periods)
6704        ("series" ,sbcl-series)))
6705     (arguments
6706      '(#:asd-file "periods-series.asd"
6707        #:asd-system-name "periods-series"))
6708     (description
6709      "Periods-series is an extension of the periods Common Lisp library
6710 providing functions compatible with the series Common Lisp library.")))
6711
6712 (define-public cl-periods-series
6713   (sbcl-package->cl-source-package sbcl-periods-series))
6714
6715 (define-public ecl-periods-series
6716   (sbcl-package->ecl-package sbcl-periods-series))
6717
6718 (define-public sbcl-metatilities-base
6719   (let ((commit "6eaa9e3ff0939a93a92109dd0fcd218de85417d5")
6720         (revision "1"))
6721     (package
6722       (name "sbcl-metatilities-base")
6723       (version (git-version "0.6.6" revision commit))
6724       (source
6725        (origin
6726          (method git-fetch)
6727          (uri (git-reference
6728                (url "https://github.com/gwkkwg/metatilities-base.git")
6729                (commit commit)))
6730          (file-name (git-file-name name version))
6731          (sha256
6732           (base32
6733            "0xpa86pdzlnf4v5g64j3ifaplx71sx2ha8b7vvakswi652679ma0"))))
6734       (build-system asdf-build-system/sbcl)
6735       (native-inputs
6736        `(("lift" ,sbcl-lift)))
6737       (synopsis "Core of the metatilities Common Lisp library")
6738       (description
6739        "Metatilities-base is the core of the metatilities Common Lisp library
6740 which implements a set of utilities.")
6741       (home-page "https://common-lisp.net/project/metatilities-base/")
6742       (license license:expat))))
6743
6744 (define-public cl-metatilities-base
6745   (sbcl-package->cl-source-package sbcl-metatilities-base))
6746
6747 (define-public ecl-metatilities-base
6748   (sbcl-package->ecl-package sbcl-metatilities-base))
6749
6750 (define-public sbcl-cl-containers
6751   (let ((commit "3d1df53c22403121bffb5d553cf7acb1503850e7")
6752         (revision "3"))
6753     (package
6754       (name "sbcl-cl-containers")
6755       (version (git-version "0.12.1" revision commit))
6756       (source
6757        (origin
6758          (method git-fetch)
6759          (uri (git-reference
6760                (url "https://github.com/gwkkwg/cl-containers.git")
6761                (commit commit)))
6762          (file-name (git-file-name name version))
6763          (sha256
6764           (base32
6765            "18s6jfq11n8nv9k4biz32pm1s7y9zl054ry1gmdbcf39nisy377y"))))
6766       (build-system asdf-build-system/sbcl)
6767       (native-inputs
6768        `(("lift" ,sbcl-lift)))
6769       (inputs
6770        `(("metatilities-base" ,sbcl-metatilities-base)))
6771       (arguments
6772        '(#:phases
6773          (modify-phases %standard-phases
6774            (add-after 'unpack 'relax-version-checks
6775              (lambda _
6776                (substitute* "cl-containers.asd"
6777                  (("\\(:version \"metatilities-base\" \"0\\.6\\.6\"\\)")
6778                   "\"metatilities-base\""))
6779                (substitute* "cl-containers-test.asd"
6780                  (("\\(:version \"lift\" \"1\\.7\\.0\"\\)")
6781                   "\"lift\""))
6782                #t)))))
6783       (synopsis "Container library for Common Lisp")
6784       (description
6785        "Common Lisp ships with a set of powerful built in data structures
6786 including the venerable list, full featured arrays, and hash-tables.
6787 CL-containers enhances and builds on these structures by adding containers
6788 that are not available in native Lisp (for example: binary search trees,
6789 red-black trees, sparse arrays and so on), and by providing a standard
6790 interface so that they are simpler to use and so that changing design
6791 decisions becomes significantly easier.")
6792       (home-page "https://common-lisp.net/project/cl-containers/")
6793       (license license:expat))))
6794
6795 (define-public cl-containers
6796   (sbcl-package->cl-source-package sbcl-cl-containers))
6797
6798 (define-public ecl-cl-containers
6799   (sbcl-package->ecl-package sbcl-cl-containers))
6800
6801 (define-public sbcl-xlunit
6802   (let ((commit "3805d34b1d8dc77f7e0ee527a2490194292dd0fc")
6803         (revision "1"))
6804     (package
6805       (name "sbcl-xlunit")
6806       (version (git-version "0.6.3" revision commit))
6807       (source
6808        (origin
6809          (method git-fetch)
6810          (uri (git-reference
6811                (url "http://git.kpe.io/xlunit.git")
6812                (commit commit)))
6813          (file-name (git-file-name name version))
6814          (sha256
6815           (base32
6816            "0argfmp9nghs4sihyj3f8ch9qfib2b7ll07v5m9ziajgzsfl5xw3"))))
6817       (build-system asdf-build-system/sbcl)
6818       (arguments
6819        '(#:phases
6820          (modify-phases %standard-phases
6821            (add-after 'unpack 'fix-tests
6822              (lambda _
6823                (substitute* "xlunit.asd"
6824                  ((" :force t") ""))
6825                #t)))))
6826       (synopsis "Unit testing package for Common Lisp")
6827       (description
6828        "The XLUnit package is a toolkit for building test suites.  It is based
6829 on the XPTest package by Craig Brozensky and the JUnit package by Kent Beck.")
6830       (home-page "http://quickdocs.org/xlunit/")
6831       (license license:bsd-3))))
6832
6833 (define-public cl-xlunit
6834   (sbcl-package->cl-source-package sbcl-xlunit))
6835
6836 (define-public ecl-xlunit
6837   (sbcl-package->ecl-package sbcl-xlunit))
6838
6839 (define-public sbcl-fprog
6840   (let ((commit "7016d1a98215f82605d1c158e7a16504ca1f4636")
6841         (revision "1"))
6842     (package
6843       (name "sbcl-fprog")
6844       (version (git-version "1.0.0" revision commit))
6845       (source
6846        (origin
6847          (method git-fetch)
6848          (uri (git-reference
6849                (url "https://github.com/jwiegley/cambl.git")
6850                (commit commit)))
6851          (file-name (git-file-name name version))
6852          (sha256
6853           (base32
6854            "103mry04j2k9vznsxm7wcvccgxkil92cdrv52miwcmxl8daa4jiz"))))
6855       (build-system asdf-build-system/sbcl)
6856       (synopsis "Functional programming utilities for Common Lisp")
6857       (description
6858        "@code{fprog} is a Common Lisp library allowing iteration over
6859 immutable lists sharing identical sublists.")
6860       (home-page "https://github.com/jwiegley/cambl")
6861       (license license:bsd-3))))
6862
6863 (define-public cl-fprog
6864   (sbcl-package->cl-source-package sbcl-fprog))
6865
6866 (define-public ecl-fprog
6867   (sbcl-package->ecl-package sbcl-fprog))
6868
6869 (define-public sbcl-cambl
6870   (let ((commit "7016d1a98215f82605d1c158e7a16504ca1f4636")
6871         (revision "1"))
6872     (package
6873       (inherit sbcl-fprog)
6874       (name "sbcl-cambl")
6875       (version (git-version "4.0.0" revision commit))
6876       (native-inputs
6877        `(("xlunit" ,sbcl-xlunit)))
6878       (inputs
6879        `(("alexandria" ,sbcl-alexandria)
6880          ("cl-containers" ,sbcl-cl-containers)
6881          ("local-time" ,sbcl-local-time)
6882          ("periods" ,sbcl-periods)
6883          ("fprog" ,sbcl-fprog)))
6884       (synopsis "Commoditized amounts and balances for Common Lisp")
6885       (description
6886        "CAMBL is a Common Lisp library providing a convenient facility for
6887 working with commoditized values.  It does not allow compound units (and so is
6888 not suited for scientific operations) but does work rather nicely for the
6889 purpose of financial calculations."))))
6890
6891 (define-public cl-cambl
6892   (sbcl-package->cl-source-package sbcl-cambl))
6893
6894 (define-public ecl-cambl
6895   (sbcl-package->ecl-package sbcl-cambl))
6896
6897 (define-public sbcl-cl-ledger
6898   (let ((commit "08e0be41795e804cd36142e51756ad0b1caa377b")
6899         (revision "1"))
6900     (package
6901       (name "sbcl-cl-ledger")
6902       (version (git-version "4.0.0" revision commit))
6903       (source
6904        (origin
6905          (method git-fetch)
6906          (uri (git-reference
6907                (url "https://github.com/ledger/cl-ledger.git")
6908                (commit commit)))
6909          (file-name (git-file-name name version))
6910          (sha256
6911           (base32
6912            "1via0qf6wjcyxnfbmfxjvms0ik9j8rqbifgpmnhrzvkhrq9pv8h1"))))
6913       (build-system asdf-build-system/sbcl)
6914       (inputs
6915        `(("cambl" ,sbcl-cambl)
6916          ("cl-ppcre" ,sbcl-cl-ppcre)
6917          ("local-time" ,sbcl-local-time)
6918          ("periods-series" ,sbcl-periods-series)))
6919       (arguments
6920        '(#:phases
6921          (modify-phases %standard-phases
6922            (add-after 'unpack 'fix-system-definition
6923              (lambda _
6924                (substitute* "cl-ledger.asd"
6925                  (("  :build-operation program-op") "")
6926                  (("  :build-pathname \"cl-ledger\"") "")
6927                  (("  :entry-point \"ledger::main\"") ""))
6928                #t)))))
6929       (synopsis "Common Lisp port of the Ledger accounting system")
6930       (description
6931        "CL-Ledger is a Common Lisp port of the Ledger double-entry accounting
6932 system.")
6933       (home-page "https://github.com/ledger/cl-ledger")
6934       (license license:bsd-3))))
6935
6936 (define-public cl-ledger
6937   (sbcl-package->cl-source-package sbcl-cl-ledger))
6938
6939 (define-public ecl-cl-ledger
6940   (sbcl-package->ecl-package sbcl-cl-ledger))
6941
6942 (define-public sbcl-bst
6943   (let ((commit "34f9c7e8e0a9f2c952fe310ab36cb630d5d9c15a")
6944         (revision "1"))
6945     (package
6946       (name "sbcl-bst")
6947       (version (git-version "1.1" revision commit))
6948       (source
6949        (origin
6950          (method git-fetch)
6951          (uri (git-reference
6952                (url "https://github.com/glv2/bst.git")
6953                (commit commit)))
6954          (file-name (git-file-name name version))
6955          (sha256
6956           (base32
6957            "1amxns7hvvh4arwbh8ciwfzplg127vh37dnbamv1m1kmmnmihfc8"))))
6958       (build-system asdf-build-system/sbcl)
6959       (native-inputs
6960        `(("alexandria" ,sbcl-alexandria)
6961          ("fiveam" ,sbcl-fiveam)))
6962       (synopsis "Binary search tree for Common Lisp")
6963       (description
6964        "BST is a Common Lisp library for working with binary search trees that
6965 can contain any kind of values.")
6966       (home-page "https://github.com/glv2/bst")
6967       (license license:gpl3))))
6968
6969 (define-public cl-bst
6970   (sbcl-package->cl-source-package sbcl-bst))
6971
6972 (define-public ecl-bst
6973   (sbcl-package->ecl-package sbcl-bst))
6974
6975 (define-public sbcl-cl-octet-streams
6976   (package
6977     (name "sbcl-cl-octet-streams")
6978     (version "1.0")
6979     (source
6980      (origin
6981        (method git-fetch)
6982        (uri (git-reference
6983              (url "https://github.com/glv2/cl-octet-streams.git")
6984              (commit (string-append "v" version))))
6985        (file-name (git-file-name name version))
6986        (sha256
6987         (base32
6988          "1d7mn6ydv0j2x4r7clpc9ijjwrnfpxmvhifv8n5j7jh7s744sf8d"))))
6989     (build-system asdf-build-system/sbcl)
6990     (native-inputs
6991      `(("fiveam" ,sbcl-fiveam)))
6992     (inputs
6993      `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
6994     (synopsis "In-memory octet streams for Common Lisp")
6995     (description
6996      "CL-octet-streams is a library implementing in-memory octet
6997 streams for Common Lisp.  It was inspired by the trivial-octet-streams and
6998 cl-plumbing libraries.")
6999     (home-page "https://github.com/glv2/cl-octet-streams")
7000     (license license:gpl3+)))
7001
7002 (define-public cl-octet-streams
7003   (sbcl-package->cl-source-package sbcl-cl-octet-streams))
7004
7005 (define-public ecl-cl-octet-streams
7006   (sbcl-package->ecl-package sbcl-cl-octet-streams))
7007
7008 (define-public sbcl-lzlib
7009   (let ((commit "0de1db7129fef9a58a059d35a2fa2ecfc5b47b47")
7010         (revision "1"))
7011     (package
7012       (name "sbcl-lzlib")
7013       (version (git-version "1.0" revision commit))
7014       (source
7015        (origin
7016          (method git-fetch)
7017          (uri (git-reference
7018                (url "https://github.com/glv2/cl-lzlib.git")
7019                (commit commit)))
7020          (file-name (git-file-name name version))
7021          (sha256
7022           (base32
7023            "12ny7vj52fgnd8hb8fc8mry92vq4c1x72x2350191m4476j95clz"))))
7024       (build-system asdf-build-system/sbcl)
7025       (native-inputs
7026        `(("fiveam" ,sbcl-fiveam)))
7027       (inputs
7028        `(("cffi" ,sbcl-cffi)
7029          ("cl-octet-streams" ,sbcl-cl-octet-streams)
7030          ("lzlib" ,lzlib)))
7031       (arguments
7032        '(#:phases
7033          (modify-phases %standard-phases
7034            (add-after 'unpack 'fix-paths
7035              (lambda* (#:key inputs #:allow-other-keys)
7036                (substitute* "src/lzlib.lisp"
7037                  (("liblz\\.so")
7038                   (string-append (assoc-ref inputs "lzlib") "/lib/liblz.so")))
7039                #t)))))
7040       (synopsis "Common Lisp library for lzip (de)compression")
7041       (description
7042        "This Common Lisp library provides functions for lzip (LZMA)
7043 compression/decompression using bindings to the lzlib C library.")
7044       (home-page "https://github.com/glv2/cl-lzlib")
7045       (license license:gpl3+))))
7046
7047 (define-public cl-lzlib
7048   (sbcl-package->cl-source-package sbcl-lzlib))
7049
7050 (define-public ecl-lzlib
7051   (sbcl-package->ecl-package sbcl-lzlib))
7052
7053 (define-public sbcl-chanl
7054   (let ((commit "56e90a126c78b39bb621a01585e8d3b985238e8c")
7055         (revision "1"))
7056     (package
7057       (name "sbcl-chanl")
7058       (version (git-version "0.4.1" revision commit))
7059       (source
7060        (origin
7061          (method git-fetch)
7062          (uri (git-reference
7063                (url "https://github.com/zkat/chanl.git")
7064                (commit commit)))
7065          (file-name (git-file-name name version))
7066          (sha256
7067           (base32
7068            "0b1cf6c12qx5cy1fw2z42jgh566rp3l8nv5qf0qqc569s7bgmrh4"))))
7069       (build-system asdf-build-system/sbcl)
7070       (native-inputs
7071        `(("fiveam" ,sbcl-fiveam)))
7072       (inputs
7073        `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
7074       (synopsis "Portable channel-based concurrency for Common Lisp")
7075       (description "Common Lisp library for channel-based concurrency.  In
7076 a nutshell, you create various threads sequentially executing tasks you need
7077 done, and use channel objects to communicate and synchronize the state of these
7078 threads.")
7079       (home-page "https://github.com/zkat/chanl")
7080       (license (list license:expat license:bsd-3)))))
7081
7082 (define-public cl-chanl
7083   (sbcl-package->cl-source-package sbcl-chanl))
7084
7085 (define-public ecl-chanl
7086   (sbcl-package->ecl-package sbcl-chanl))
7087
7088 (define-public sbcl-cl-store
7089   (let ((commit "c787337a16ea8cf8a06227f35933a4ec774746b3")
7090         (revision "1"))
7091     (package
7092       (name "sbcl-cl-store")
7093       (version (git-version "0.8.11" revision commit))
7094       (source
7095        (origin
7096          (method git-fetch)
7097          (uri (git-reference
7098                (url "https://github.com/skypher/cl-store.git")
7099                (commit commit)))
7100          (file-name (git-file-name name version))
7101          (sha256
7102           (base32
7103            "194srkg8nrym19c6i7zbnkzshc1qhqa82m53qnkirz9fw928bqxr"))))
7104       (build-system asdf-build-system/sbcl)
7105       (native-inputs
7106        `(("rt" ,sbcl-rt)))
7107       (synopsis "Common Lisp library to serialize data")
7108       (description
7109        "CL-STORE is a portable serialization package which should give you the
7110 ability to store all Common Lisp data types into streams.")
7111       (home-page "https://www.common-lisp.net/project/cl-store/")
7112       (license license:expat))))
7113
7114 (define-public cl-store
7115   (sbcl-package->cl-source-package sbcl-cl-store))
7116
7117 (define-public ecl-cl-store
7118   (sbcl-package->ecl-package sbcl-cl-store))
7119
7120 (define-public sbcl-cl-gobject-introspection
7121   (let ((commit "7b703e2384945ea0ac39d9b766de434a08d81560")
7122         (revision "0"))
7123     (package
7124       (name "sbcl-cl-gobject-introspection")
7125       (version (git-version "0.3" revision commit))
7126       (home-page "https://github.com/andy128k/cl-gobject-introspection")
7127       (source
7128        (origin
7129          (method git-fetch)
7130          (uri (git-reference
7131                (url home-page)
7132                (commit commit)))
7133          (file-name (git-file-name name version))
7134          (sha256
7135           (base32
7136            "1zcqd2qj14f6b38vys8gr89s6cijsp9r8j43xa8lynilwva7bwyh"))))
7137       (build-system asdf-build-system/sbcl)
7138       (inputs
7139        `(("alexandria" ,sbcl-alexandria)
7140          ("cffi" ,sbcl-cffi)
7141          ("iterate" ,sbcl-iterate)
7142          ("trivial-garbage" ,sbcl-trivial-garbage)
7143          ("glib" ,glib)
7144          ("gobject-introspection" ,gobject-introspection)))
7145       (native-inputs
7146        `(("fiveam" ,sbcl-fiveam)))
7147       (arguments
7148        ;; TODO: Tests fail, see
7149        ;; https://github.com/andy128k/cl-gobject-introspection/issues/70.
7150        '(#:tests? #f
7151          #:phases
7152          (modify-phases %standard-phases
7153            (add-after (quote unpack) (quote fix-paths)
7154              (lambda* (#:key inputs #:allow-other-keys)
7155                (substitute* "src/init.lisp"
7156                  (("libgobject-2\\.0\\.so")
7157                   (string-append (assoc-ref inputs "glib") "/lib/libgobject-2.0.so"))
7158                  (("libgirepository-1\\.0\\.so")
7159                   (string-append (assoc-ref inputs "gobject-introspection")
7160                                  "/lib/libgirepository-1.0.so")))
7161                #t)))))
7162       (synopsis "Common Lisp bindings to GObject Introspection")
7163       (description
7164        "This library is a bridge between Common Lisp and GObject
7165 Introspection, which enables Common Lisp programs to access the full interface
7166 of C+GObject libraries without the need of writing dedicated bindings.")
7167       (license (list license:bsd-3
7168                      ;; Tests are under a different license.
7169                      license:llgpl)))))
7170
7171 (define-public cl-gobject-introspection
7172   (sbcl-package->cl-source-package sbcl-cl-gobject-introspection))
7173
7174 (define-public sbcl-string-case
7175   (let ((commit "718c761e33749e297cd2809c7ba3ade1985c49f7")
7176         (revision "0"))
7177     (package
7178       (name "sbcl-string-case")
7179       (version (git-version "0.0.2" revision commit))
7180       (home-page "https://github.com/pkhuong/string-case")
7181       (source
7182        (origin
7183          (method git-fetch)
7184          (uri (git-reference
7185                (url home-page)
7186                (commit commit)))
7187          (file-name (git-file-name name version))
7188          (sha256
7189           (base32
7190            "1n5i3yh0h5s636rcnwn7jwqy3rjflikra04lymimhpcshhjsk0md"))))
7191       (build-system asdf-build-system/sbcl)
7192       (synopsis "Efficient string= case in Common Lisp")
7193       (description
7194        "@code{string-case} is a Common Lisp macro that generates specialised decision
7195 trees to dispatch on string equality.")
7196       (license license:bsd-3))))
7197
7198 (define-public cl-string-case
7199   (sbcl-package->cl-source-package sbcl-string-case))
7200
7201 (define-public ecl-string-case
7202   (sbcl-package->ecl-package sbcl-string-case))
7203
7204 (define-public sbcl-global-vars
7205   (let ((commit "c749f32c9b606a1457daa47d59630708ac0c266e")
7206         (revision "0"))
7207     (package
7208       (name "sbcl-global-vars")
7209       (version (git-version "1.0.0" revision commit))
7210       (home-page "https://github.com/lmj/global-vars")
7211       (source
7212        (origin
7213          (method git-fetch)
7214          (uri (git-reference
7215                (url home-page)
7216                (commit commit)))
7217          (file-name (git-file-name name version))
7218          (sha256
7219           (base32
7220            "06m3xc8l3pgsapl8fvsi9wf6y46zs75cp9zn7zh6dc65v4s5wz3d"))))
7221       (build-system asdf-build-system/sbcl)
7222       (synopsis "Efficient global variables in Common Lisp")
7223       (description
7224        "In Common Lisp, a special variable that is never dynamically bound
7225 typically serves as a stand-in for a global variable.  The @code{global-vars}
7226 library provides true global variables that are implemented by some compilers.
7227 An attempt to rebind a global variable properly results in a compiler error.
7228 That is, a global variable cannot be dynamically bound.
7229
7230 Global variables therefore allow us to communicate an intended usage that
7231 differs from special variables.  Global variables are also more efficient than
7232 special variables, especially in the presence of threads.")
7233       (license license:expat))))
7234
7235 (define-public cl-global-vars
7236   (sbcl-package->cl-source-package sbcl-global-vars))
7237
7238 (define-public ecl-global-vars
7239   (sbcl-package->ecl-package sbcl-global-vars))
7240
7241 (define-public sbcl-trivial-file-size
7242   (let ((commit "1c1d672a01a446ba0391dbb4ffc40be3b0476f23")
7243         (revision "0"))
7244     (package
7245       (name "sbcl-trivial-file-size")
7246       (version (git-version "0.0.0" revision commit))
7247       (home-page "https://github.com/ruricolist/trivial-file-size")
7248       (source
7249        (origin
7250          (method git-fetch)
7251          (uri (git-reference
7252                (url home-page)
7253                (commit commit)))
7254          (file-name (git-file-name name version))
7255          (sha256
7256           (base32
7257            "17pp86c9zs4y7i1sh7q9gbfw9iqv6655k7fz8qbj9ly1ypgxp4qs"))))
7258       (build-system asdf-build-system/sbcl)
7259       (native-inputs
7260        `(("fiveam" ,sbcl-fiveam)))
7261       (synopsis "Size of a file in bytes in Common Lisp")
7262       (description
7263        "The canonical way to determine the size of a file in bytes, using Common Lisp,
7264 is to open the file with an element type of (unsigned-byte 8) and then
7265 calculate the length of the stream.  This is less than ideal.  In most cases
7266 it is better to get the size of the file from its metadata, using a system
7267 call.
7268
7269 This library exports a single function, file-size-in-octets.  It returns the
7270 size of a file in bytes, using system calls when possible.")
7271       (license license:expat))))
7272
7273 (define-public cl-trivial-file-size
7274   (sbcl-package->cl-source-package sbcl-trivial-file-size))
7275
7276 (define-public ecl-trivial-file-size
7277   (sbcl-package->ecl-package sbcl-trivial-file-size))
7278
7279 (define-public sbcl-trivial-macroexpand-all
7280   (let ((commit "933270ac7107477de1bc92c1fd641fe646a7a8a9")
7281         (revision "0"))
7282     (package
7283       (name "sbcl-trivial-macroexpand-all")
7284       (version (git-version "0.0.0" revision commit))
7285       (home-page "https://github.com/cbaggers/trivial-macroexpand-all")
7286       (source
7287        (origin
7288          (method git-fetch)
7289          (uri (git-reference
7290                (url home-page)
7291                (commit commit)))
7292          (file-name (git-file-name name version))
7293          (sha256
7294           (base32
7295            "191hnn4b5j4i3crydmlzbm231kj0h7l8zj6mzj69r1npbzkas4bd"))))
7296       (build-system asdf-build-system/sbcl)
7297       (native-inputs
7298        `(("fiveam" ,sbcl-fiveam)))
7299       (synopsis "Portable macroexpand-all for Common Lisp")
7300       (description
7301        "This library provides a macroexpand-all function that calls the
7302 implementation specific equivalent.")
7303       (license license:unlicense))))
7304
7305 (define-public cl-trivial-macroexpand-all
7306   (sbcl-package->cl-source-package sbcl-trivial-macroexpand-all))
7307
7308 (define-public ecl-trivial-macroexpand-all
7309   (sbcl-package->ecl-package sbcl-trivial-macroexpand-all))
7310
7311 (define-public sbcl-serapeum
7312   (let ((commit "64f0c4a161bbbda7c275012ca1415b4293b9e169")
7313         (revision "1"))
7314     (package
7315       (name "sbcl-serapeum")
7316       (version (git-version "0.0.0" revision commit))
7317       (home-page "https://github.com/ruricolist/serapeum")
7318       (source
7319        (origin
7320          (method git-fetch)
7321          (uri (git-reference
7322                (url home-page)
7323                (commit commit)))
7324          (file-name (git-file-name name version))
7325          (sha256
7326           (base32
7327            "0djnj0py8hdjnk5j6shjq2kbmyxqd5sw79cilcfmpfz4dzjdgkx9"))))
7328       (build-system asdf-build-system/sbcl)
7329       (inputs
7330        `(("alexandria" ,sbcl-alexandria)
7331          ("trivia" ,sbcl-trivia)
7332          ("trivia.quasiquote" ,sbcl-trivia.quasiquote)
7333          ("split-sequence" ,sbcl-split-sequence)
7334          ("string-case" ,sbcl-string-case)
7335          ("parse-number" ,sbcl-parse-number)
7336          ("trivial-garbage" ,sbcl-trivial-garbage)
7337          ("bordeaux-threads" ,sbcl-bordeaux-threads)
7338          ("named-readtables" ,sbcl-named-readtables)
7339          ("fare-quasiquote-extras" ,sbcl-fare-quasiquote-extras)
7340          ("parse-declarations-1.0" ,sbcl-parse-declarations)
7341          ("global-vars" ,sbcl-global-vars)
7342          ("trivial-file-size" ,sbcl-trivial-file-size)
7343          ("trivial-macroexpand-all" ,sbcl-trivial-macroexpand-all)))
7344       (native-inputs
7345        `(("fiveam" ,sbcl-fiveam)
7346          ("local-time" ,sbcl-local-time)))
7347       (arguments
7348        '(#:phases
7349          (modify-phases %standard-phases
7350            (add-after 'unpack 'disable-failing-tests
7351              (lambda* (#:key inputs #:allow-other-keys)
7352                (substitute* "serapeum.asd"
7353                  ;; Guix does not have Quicklisp, and probably never will.
7354                  (("\\(:file \"quicklisp\"\\)") ""))
7355                #t)))))
7356       (synopsis "Common Lisp utility library beyond Alexandria")
7357       (description
7358        "Serapeum is a conservative library of Common Lisp utilities.  It is a
7359 supplement, not a competitor, to Alexandria.")
7360       (license license:expat))))
7361
7362 (define-public cl-serapeum
7363   (sbcl-package->cl-source-package sbcl-serapeum))
7364
7365 (define-public sbcl-arrows
7366   (let ((commit "df7cf0067e0132d9697ac8b1a4f1b9c88d4f5382")
7367         (revision "0"))
7368     (package
7369       (name "sbcl-arrows")
7370       (version (git-version "0.2.0" revision commit))
7371       (source
7372        (origin
7373          (method git-fetch)
7374          (uri (git-reference
7375                (url "https://gitlab.com/Harleqin/arrows.git")
7376                (commit commit)))
7377          (file-name (git-file-name name version))
7378          (sha256
7379           (base32
7380            "042k9vkssrqx9nhp14wdzm942zgdxvp35mba0p2syz98i75im2yy"))))
7381       (build-system asdf-build-system/sbcl)
7382       (native-inputs
7383        `(("hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
7384       (synopsis "Clojure-like arrow macros for Common Lisp")
7385       (description
7386        "This library implements the @code{->} and @code{->>} macros from
7387 Clojure, as well as several expansions on the idea.")
7388       (home-page "https://gitlab.com/Harleqin/arrows")
7389       (license license:public-domain))))
7390
7391 (define-public cl-arrows
7392   (sbcl-package->cl-source-package sbcl-arrows))
7393
7394 (define-public ecl-arrows
7395   (sbcl-package->ecl-package sbcl-arrows))
7396
7397 (define-public sbcl-simple-parallel-tasks
7398   (let ((commit "db460f7a3f7bbfe2d3a2223ed21e162068d04dda")
7399         (revision "0"))
7400     (package
7401       (name "sbcl-simple-parallel-tasks")
7402       (version (git-version "1.0" revision commit))
7403       (source
7404        (origin
7405          (method git-fetch)
7406          (uri (git-reference
7407                (url "https://github.com/glv2/simple-parallel-tasks.git")
7408                (commit commit)))
7409          (file-name (git-file-name name version))
7410          (sha256
7411           (base32
7412            "0amw3qk23wnlyrsgzszs6rs7y4zvxv8dr03rnqhc60mnm8ds4dd5"))))
7413       (build-system asdf-build-system/sbcl)
7414       (native-inputs
7415        `(("fiveam" ,sbcl-fiveam)))
7416       (inputs
7417        `(("chanl" ,sbcl-chanl)))
7418       (synopsis "Common Lisp library to evaluate some forms in parallel")
7419       (description "This is a simple Common Lisp library to evaluate some
7420 forms in parallel.")
7421       (home-page "https://github.com/glv2/simple-parallel-tasks")
7422       (license license:gpl3))))
7423
7424 (define-public cl-simple-parallel-tasks
7425   (sbcl-package->cl-source-package sbcl-simple-parallel-tasks))
7426
7427 (define-public ecl-simple-parallel-tasks
7428   (sbcl-package->ecl-package sbcl-simple-parallel-tasks))
7429
7430 (define-public sbcl-cl-heap
7431   (package
7432     (name "sbcl-cl-heap")
7433     (version "0.1.6")
7434     (source
7435      (origin
7436        (method url-fetch)
7437        (uri (string-append "https://common-lisp.net/project/cl-heap/releases/"
7438                            "cl-heap_" version ".tar.gz"))
7439        (sha256
7440         (base32
7441          "163hb07p2nxz126rpq3cj5dyala24n0by5i5786n2qcr1w0bak4i"))))
7442     (build-system asdf-build-system/sbcl)
7443     (native-inputs
7444      `(("xlunit" ,sbcl-xlunit)))
7445     (arguments
7446      `(#:test-asd-file "cl-heap-tests.asd"))
7447     (synopsis "Heap and priority queue data structures for Common Lisp")
7448     (description
7449      "CL-HEAP provides various implementations of heap data structures (a
7450 binary heap and a Fibonacci heap) as well as an efficient priority queue.")
7451     (home-page "https://common-lisp.net/project/cl-heap/")
7452     (license license:gpl3+)))
7453
7454 (define-public cl-heap
7455   (sbcl-package->cl-source-package sbcl-cl-heap))
7456
7457 (define-public ecl-cl-heap
7458   (sbcl-package->ecl-package sbcl-cl-heap))
7459
7460 (define-public sbcl-curry-compose-reader-macros
7461   (let ((commit "beaa92dedf392726c042184bfd6149fa8d9e6ac2")
7462         (revision "0"))
7463     (package
7464       (name "sbcl-curry-compose-reader-macros")
7465       (version (git-version "1.0.0" revision commit))
7466       (source
7467        (origin
7468          (method git-fetch)
7469          (uri
7470           (git-reference
7471            (url "https://github.com/eschulte/curry-compose-reader-macros.git")
7472            (commit commit)))
7473          (file-name (git-file-name name version))
7474          (sha256
7475           (base32
7476            "0rv9bl8xrad5wfcg5zs1dazvnpmvqz6297lbn8bywsrcfnlf7h98"))))
7477       (build-system asdf-build-system/sbcl)
7478       (inputs
7479        `(("alexandria" ,sbcl-alexandria)
7480          ("named-readtables" ,sbcl-named-readtables)))
7481       (synopsis "Reader macros for partial application and composition")
7482       (description
7483        "This Common Lisp library provides reader macros for concise expression
7484 of function partial application and composition.")
7485       (home-page "https://eschulte.github.io/curry-compose-reader-macros/")
7486       (license license:public-domain))))
7487
7488 (define-public cl-curry-compose-reader-macros
7489   (sbcl-package->cl-source-package sbcl-curry-compose-reader-macros))
7490
7491 (define-public ecl-curry-compose-reader-macros
7492   (sbcl-package->ecl-package sbcl-curry-compose-reader-macros))
7493
7494 (define-public sbcl-yason
7495   (package
7496     (name "sbcl-yason")
7497     (version "0.7.7")
7498     (source
7499      (origin
7500        (method git-fetch)
7501        (uri (git-reference
7502              (url "https://github.com/phmarek/yason.git")
7503              (commit (string-append "v" version))))
7504        (file-name (git-file-name name version))
7505        (sha256
7506         (base32
7507          "0479rbjgbj80jpk5bby18inlv1kfp771a82rlcq5psrz65qqa9bj"))))
7508     (build-system asdf-build-system/sbcl)
7509     (inputs
7510      `(("alexandria" ,sbcl-alexandria)
7511        ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
7512     (synopsis "Common Lisp JSON parser/encoder")
7513     (description
7514      "YASON is a Common Lisp library for encoding and decoding data in the
7515 JSON interchange format.")
7516     (home-page "https://github.com/phmarek/yason")
7517     (license license:bsd-3)))
7518
7519 (define-public cl-yason
7520   (sbcl-package->cl-source-package sbcl-yason))
7521
7522 (define-public ecl-yason
7523   (sbcl-package->ecl-package sbcl-yason))
7524
7525 (define-public sbcl-stefil
7526   (let ((commit "0398548ec95dceb50fc2c2c03e5fb0ce49b86c7a")
7527         (revision "0"))
7528     (package
7529       (name "sbcl-stefil")
7530       (version (git-version "0.1" revision commit))
7531       (source
7532        (origin
7533          (method git-fetch)
7534          (uri (git-reference
7535                (url "https://gitlab.common-lisp.net/stefil/stefil.git")
7536                (commit commit)))
7537          (file-name (git-file-name name version))
7538          (sha256
7539           (base32
7540            "0bqz64q2szzhf91zyqyssmvrz7da6442rs01808pf3wrdq28bclh"))))
7541       (build-system asdf-build-system/sbcl)
7542       (inputs
7543        `(("alexandria" ,sbcl-alexandria)
7544          ("iterate" ,sbcl-iterate)
7545          ("metabang-bind" ,sbcl-metabang-bind)))
7546       (propagated-inputs
7547        ;; Swank doesn't have a pre-compiled package, therefore we must
7548        ;; propagate its sources.
7549        `(("swank" ,cl-slime-swank)))
7550       (arguments
7551        '(#:phases
7552          (modify-phases %standard-phases
7553            (add-after 'unpack 'drop-unnecessary-dependency
7554              (lambda _
7555                (substitute* "package.lisp"
7556                  ((":stefil-system") ""))
7557                #t)))))
7558       (home-page "https://common-lisp.net/project/stefil/index-old.shtml")
7559       (synopsis "Simple test framework")
7560       (description
7561        "Stefil is a simple test framework for Common Lisp, with a focus on
7562 interactive development.")
7563       (license license:public-domain))))
7564
7565 (define-public cl-stefil
7566   (sbcl-package->cl-source-package sbcl-stefil))
7567
7568 (define-public sbcl-graph
7569   (let ((commit "78bf9ec930d8eae4f0861b5be76765fb1e45e24f")
7570         (revision "0"))
7571     (package
7572       (name "sbcl-graph")
7573       (version (git-version "0.0.0" revision commit))
7574       (source
7575        (origin
7576          (method git-fetch)
7577          (uri
7578           (git-reference
7579            (url "https://github.com/eschulte/graph.git")
7580            (commit commit)))
7581          (file-name (git-file-name name version))
7582          (sha256
7583           (base32
7584            "1qpij4xh8bqwc2myahpilcbh916v7vg0acz2fij14d3y0jm02h0g"))
7585          (patches (search-patches "sbcl-graph-asdf-definitions.patch"))))
7586       (build-system asdf-build-system/sbcl)
7587       (native-inputs
7588        `(("stefil" ,sbcl-stefil)))
7589       (inputs
7590        `(("alexandria" ,sbcl-alexandria)
7591          ("cl-heap" ,sbcl-cl-heap)
7592          ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
7593          ("metabang-bind" ,sbcl-metabang-bind)
7594          ("named-readtables" ,sbcl-named-readtables)))
7595       (arguments
7596        '(#:test-asd-file "graph-test.asd"))
7597       (synopsis "Graph data structure and algorithms for Common Lisp")
7598       (description
7599        "The GRAPH Common Lisp library provides a data structures to represent
7600 graphs, as well as some graph manipulation and analysis algorithms (shortest
7601 path, maximum flow, minimum spanning tree, etc.).")
7602       (home-page "https://eschulte.github.io/graph/")
7603       (license license:gpl3+))))
7604
7605 (define-public cl-graph
7606   (sbcl-package->cl-source-package sbcl-graph))
7607
7608 (define-public sbcl-graph-dot
7609   (package
7610     (inherit sbcl-graph)
7611     (name "sbcl-graph-dot")
7612     (inputs
7613      `(("alexandria" ,sbcl-alexandria)
7614        ("cl-ppcre" ,sbcl-cl-ppcre)
7615        ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
7616        ("graph" ,sbcl-graph)
7617        ("metabang-bind" ,sbcl-metabang-bind)
7618        ("named-readtables" ,sbcl-named-readtables)))
7619     (arguments
7620      (substitute-keyword-arguments (package-arguments sbcl-graph)
7621        ((#:asd-file _ "") "graph-dot.asd")
7622        ((#:asd-system-name _ #f) "graph-dot")))
7623     (synopsis "Serialize graphs to and from DOT format")))
7624
7625 (define-public sbcl-graph-json
7626   (package
7627     (inherit sbcl-graph)
7628     (name "sbcl-graph-json")
7629     (inputs
7630      `(("alexandria" ,sbcl-alexandria)
7631        ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
7632        ("graph" ,sbcl-graph)
7633        ("metabang-bind" ,sbcl-metabang-bind)
7634        ("named-readtables" ,sbcl-named-readtables)
7635        ("yason" ,sbcl-yason)))
7636     (arguments
7637      (substitute-keyword-arguments (package-arguments sbcl-graph)
7638        ((#:asd-file _ "") "graph-json.asd")
7639        ((#:asd-system-name _ #f) "graph-json")))
7640     (synopsis "Serialize graphs to and from JSON format")))
7641
7642 (define-public sbcl-trivial-indent
7643   (let ((commit "2d016941751647c6cc5bd471751c2cf68861c94a")
7644         (revision "0"))
7645     (package
7646       (name "sbcl-trivial-indent")
7647       (version (git-version "1.0.0" revision commit))
7648       (source
7649        (origin
7650          (method git-fetch)
7651          (uri
7652           (git-reference
7653            (url "https://github.com/Shinmera/trivial-indent")
7654            (commit commit)))
7655          (file-name (git-file-name name version))
7656          (sha256
7657           (base32
7658            "1sj90nqz17w4jq0ixz00gb9g5g6d2s7l8r17zdby27gxxh51w266"))))
7659       (build-system asdf-build-system/sbcl)
7660       (synopsis "Simple Common Lisp library to allow indentation hints for SWANK")
7661       (description
7662        "This library allows you to define custom indentation hints for your
7663 macros if the one recognised by SLIME automatically produces unwanted
7664 results.")
7665       (home-page "https://shinmera.github.io/trivial-indent/")
7666       (license license:zlib))))
7667
7668 (define-public cl-trivial-indent
7669   (sbcl-package->cl-source-package sbcl-trivial-indent))
7670
7671 (define-public sbcl-documentation-utils
7672   (let ((commit "98630dd5f7e36ae057fa09da3523f42ccb5d1f55")
7673         (revision "0"))
7674     (package
7675       (name "sbcl-documentation-utils")
7676       (version (git-version "1.2.0" revision commit))
7677       (source
7678        (origin
7679          (method git-fetch)
7680          (uri
7681           (git-reference
7682            (url "https://github.com/Shinmera/documentation-utils.git")
7683            (commit commit)))
7684          (file-name (git-file-name name version))
7685          (sha256
7686           (base32
7687            "098qhkqskmmrh4wix34mawf7p5c87yql28r51r75yjxj577k5idq"))))
7688       (build-system asdf-build-system/sbcl)
7689       (inputs
7690        `(("trivial-indent" ,sbcl-trivial-indent)))
7691       (synopsis "Few simple tools to document Common Lisp libraries")
7692       (description
7693        "This is a small library to help you with managing the Common Lisp
7694 docstrings for your library.")
7695       (home-page "https://shinmera.github.io/documentation-utils/")
7696       (license license:zlib))))
7697
7698 (define-public cl-documentation-utils
7699   (sbcl-package->cl-source-package sbcl-documentation-utils))
7700
7701 (define-public ecl-documentation-utils
7702   (sbcl-package->ecl-package sbcl-documentation-utils))
7703
7704 (define-public sbcl-form-fiddle
7705   (let ((commit "e0c23599dbb8cff3e83e012f3d86d0764188ad18")
7706         (revision "0"))
7707     (package
7708       (name "sbcl-form-fiddle")
7709       (version (git-version "1.1.0" revision commit))
7710       (source
7711        (origin
7712          (method git-fetch)
7713          (uri
7714           (git-reference
7715            (url "https://github.com/Shinmera/form-fiddle")
7716            (commit commit)))
7717          (file-name (git-file-name name version))
7718          (sha256
7719           (base32
7720            "041iznc9mpfyrl0sv5893ys9pbb2pvbn9g3clarqi7gsfj483jln"))))
7721       (build-system asdf-build-system/sbcl)
7722       (inputs
7723        `(("documentation-utils" ,sbcl-documentation-utils)))
7724       (synopsis "Utilities to destructure Common Lisp lambda forms")
7725       (description
7726        "Often times we need to destructure a form definition in a Common Lisp
7727 macro.  This library provides a set of simple utilities to help with that.")
7728       (home-page "https://shinmera.github.io/form-fiddle/")
7729       (license license:zlib))))
7730
7731 (define-public cl-form-fiddle
7732   (sbcl-package->cl-source-package sbcl-form-fiddle))
7733
7734 (define-public sbcl-parachute
7735   (let ((commit "ca04dd8e43010a6dfffa26dbe1d62af86008d666")
7736         (revision "0"))
7737     (package
7738       (name "sbcl-parachute")
7739       (version (git-version "1.1.1" revision commit))
7740       (source
7741        (origin
7742          (method git-fetch)
7743          (uri
7744           (git-reference
7745            (url "https://github.com/Shinmera/parachute")
7746            (commit commit)))
7747          (file-name (git-file-name name version))
7748          (sha256
7749           (base32
7750            "1mvsm3r0r6a2bg75nw0q7n9vlby3ch45qjl7hnb5k1z2n5x5lh60"))))
7751       (build-system asdf-build-system/sbcl)
7752       (inputs
7753        `(("documentation-utils" ,sbcl-documentation-utils)
7754          ("form-fiddle" ,sbcl-form-fiddle)))
7755       (synopsis "Extensible and cross-compatible testing framework for Common Lisp")
7756       (description
7757        "Parachute is a simple-to-use and extensible testing framework.
7758 In Parachute, things are organised as a bunch of named tests within a package.
7759 Each test can contain a bunch of test forms that make up its body.")
7760       (home-page "https://shinmera.github.io/parachute/")
7761       (license license:zlib))))
7762
7763 (define-public cl-parachute
7764   (sbcl-package->cl-source-package sbcl-parachute))
7765
7766 (define-public sbcl-array-utils
7767   (let ((commit "f90eb9070d0b2205af51126a35033574725e5c56")
7768         (revision "0"))
7769     (package
7770       (name "sbcl-array-utils")
7771       (version (git-version "1.1.1" revision commit))
7772       (source
7773        (origin
7774          (method git-fetch)
7775          (uri
7776           (git-reference
7777            (url "https://github.com/Shinmera/array-utils")
7778            (commit commit)))
7779          (file-name (git-file-name name version))
7780          (sha256
7781           (base32
7782            "0zhwfbpr53vs1ii4sx75dz2k9yhh1xpwdqqpg8nmfndxkmhpbi3x"))))
7783       (build-system asdf-build-system/sbcl)
7784       (native-inputs
7785        `(("parachute" ,sbcl-parachute)))
7786       (inputs
7787        `(("documentation-utils" ,sbcl-documentation-utils)))
7788       (synopsis "Tiny collection of array and vector utilities for Common Lisp")
7789       (description
7790        "A miniature toolkit that contains some useful shifting/popping/pushing
7791 functions for arrays and vectors.  Originally from Plump.")
7792       (home-page "https://shinmera.github.io/array-utils/")
7793       (license license:zlib))))
7794
7795 (define-public cl-array-utils
7796   (sbcl-package->cl-source-package sbcl-array-utils))
7797
7798 (define-public sbcl-plump
7799   (let ((commit "16f1231bf706cfbc54d9e55a853ca945e4452a08")
7800         (revision "0"))
7801     (package
7802       (name "sbcl-plump")
7803       (version (git-version "2.0.0" revision commit))
7804       (source
7805        (origin
7806          (method git-fetch)
7807          (uri
7808           (git-reference
7809            (url "https://github.com/Shinmera/plump")
7810            (commit commit)))
7811          (file-name (git-file-name name version))
7812          (sha256
7813           (base32
7814            "0705k8pbip51v74rccgwscwph439f2pma9f915qf1h4bhjx999ip"))))
7815       (build-system asdf-build-system/sbcl)
7816       (inputs
7817        `(("array-utils" ,sbcl-array-utils)
7818          ("documentation-utils" ,sbcl-documentation-utils)))
7819       (synopsis "Lenient XML / XHTML / HTML parser for Common Lisp")
7820       (description
7821        "Plump is a parser for HTML/XML-like documents, focusing on being
7822 lenient towards invalid markup.  It can handle things like invalid attributes,
7823 bad closing tag order, unencoded entities, inexistent tag types, self-closing
7824 tags and so on.  It parses documents to a class representation and offers a
7825 small set of DOM functions to manipulate it.  It can be extended to parse to
7826 your own classes.")
7827       (home-page "https://shinmera.github.io/plump/")
7828       (license license:zlib))))
7829
7830 (define-public cl-plump
7831   (sbcl-package->cl-source-package sbcl-plump))
7832
7833 (define-public sbcl-antik-base
7834   (let ((commit "e4711a69b3d6bf37b5727af05c3cfd03e8428ba3")
7835         (revision "1"))
7836     (package
7837       (name "sbcl-antik-base")
7838       (version (git-version "0.0.0" revision commit))
7839       (source
7840        (origin
7841          (method git-fetch)
7842          (uri (git-reference
7843                (url "https://gitlab.common-lisp.net/antik/antik.git")
7844                (commit commit)))
7845          (file-name (git-file-name name version))
7846          (sha256
7847           (base32
7848            "047ga2c38par2xbgg4qx6hwv06qhf1c1f67as8xvir6s80lip1km"))))
7849       (build-system asdf-build-system/sbcl)
7850       (inputs
7851        `(("alexandria" ,sbcl-alexandria)
7852          ("cl-ppcre" ,sbcl-cl-ppcre)
7853          ("iterate" ,sbcl-iterate)
7854          ("metabang-bind" ,sbcl-metabang-bind)
7855          ("named-readtables" ,sbcl-named-readtables)
7856          ("split-sequence" ,sbcl-split-sequence)))
7857       (native-inputs
7858        `(("lisp-unit" ,sbcl-lisp-unit)))
7859       (synopsis "Scientific and engineering computation in Common Lisp")
7860       (description
7861        "Antik provides a foundation for scientific and engineering
7862 computation in Common Lisp.  It is designed not only to facilitate
7863 numerical computations, but to permit the use of numerical computation
7864 libraries and the interchange of data and procedures, whether
7865 foreign (non-Lisp) or Lisp libraries.  It is named after the
7866 Antikythera mechanism, one of the oldest examples of a scientific
7867 computer known.")
7868       (home-page "https://common-lisp.net/project/antik/")
7869       (license license:gpl3))))
7870
7871 (define-public cl-antik-base
7872   (sbcl-package->cl-source-package sbcl-antik-base))
7873
7874 (define-public ecl-antik-base
7875   (sbcl-package->ecl-package sbcl-antik-base))
7876
7877 (define-public sbcl-foreign-array
7878   (package
7879     (inherit sbcl-antik-base)
7880     (name "sbcl-foreign-array")
7881     (arguments
7882      (substitute-keyword-arguments (package-arguments sbcl-antik-base)
7883        ((#:asd-file _ "") "foreign-array.asd")
7884        ((#:asd-system-name _ #f) "foreign-array")))
7885     (inputs
7886      `(("antik-base" ,sbcl-antik-base)
7887        ("cffi" ,sbcl-cffi)
7888        ("trivial-garbage" ,sbcl-trivial-garbage)
7889        ("static-vectors" ,sbcl-static-vectors)))
7890     (synopsis "Common Lisp library providing access to foreign arrays")))
7891
7892 (define-public cl-foreign-array
7893   (sbcl-package->cl-source-package sbcl-foreign-array))
7894
7895 (define-public ecl-foreign-array
7896   (sbcl-package->ecl-package sbcl-foreign-array))
7897
7898 (define-public sbcl-physical-dimension
7899   (package
7900     (inherit sbcl-antik-base)
7901     (name "sbcl-physical-dimension")
7902     (inputs
7903      `(("fare-utils" ,sbcl-fare-utils)
7904        ("foreign-array" ,sbcl-foreign-array)
7905        ("trivial-utf-8" ,sbcl-trivial-utf-8)))
7906     (arguments
7907      (substitute-keyword-arguments (package-arguments sbcl-antik-base)
7908        ((#:asd-file _ "") "physical-dimension.asd")
7909        ((#:asd-system-name _ #f) "physical-dimension")))
7910     (synopsis
7911      "Common Lisp library providing computations with physical units")))
7912
7913 (define-public cl-physical-dimension
7914   (sbcl-package->cl-source-package sbcl-physical-dimension))
7915
7916 (define-public sbcl-science-data
7917   (package
7918     (inherit sbcl-antik-base)
7919     (name "sbcl-science-data")
7920     (inputs
7921      `(("physical-dimension" ,sbcl-physical-dimension)
7922        ("drakma" ,sbcl-drakma)))
7923     (arguments
7924      (substitute-keyword-arguments (package-arguments sbcl-antik-base)
7925        ((#:asd-file _ "") "science-data.asd")
7926        ((#:asd-system-name _ #f) "science-data")))
7927     (synopsis
7928      "Common Lisp library for scientific and engineering numerical data")))
7929
7930 (define-public cl-science-data
7931   (sbcl-package->cl-source-package sbcl-science-data))
7932
7933 (define-public sbcl-gsll
7934   (let ((commit "1a8ada22f9cf5ed7372d352b2317f4ccdb6ab308")
7935         (revision "1"))
7936     (package
7937       (name "sbcl-gsll")
7938       (version (git-version "0.0.0" revision commit))
7939       (source
7940        (origin
7941          (method git-fetch)
7942          (uri (git-reference
7943                (url "https://gitlab.common-lisp.net/antik/gsll.git")
7944                (commit commit)))
7945          (file-name (git-file-name name version))
7946          (sha256
7947           (base32
7948            "0z5nypfk26hxihb08p085644afawicrgb4xvadh3lmrn46qbjfn4"))))
7949       (build-system asdf-build-system/sbcl)
7950       (native-inputs
7951        `(("lisp-unit" ,sbcl-lisp-unit)))
7952       (inputs
7953        `(("alexandria" ,sbcl-alexandria)
7954          ("cffi-grovel" ,sbcl-cffi-grovel)
7955          ("cffi-libffi" ,sbcl-cffi-libffi)
7956          ("foreign-array" ,sbcl-foreign-array)
7957          ("gsl" ,gsl)
7958          ("metabang-bind" ,sbcl-metabang-bind)
7959          ("trivial-features" ,sbcl-trivial-features)
7960          ("trivial-garbage" ,sbcl-trivial-garbage)))
7961       (arguments
7962        `(#:tests? #f
7963          #:phases
7964          (modify-phases %standard-phases
7965            (add-after 'unpack 'fix-cffi-paths
7966              (lambda* (#:key inputs #:allow-other-keys)
7967                (substitute* "gsll.asd"
7968                  ((":depends-on \\(#:foreign-array")
7969                   ":depends-on (#:foreign-array #:cffi-libffi"))
7970                (substitute* "init/init.lisp"
7971                  (("libgslcblas.so" all)
7972                   (string-append
7973                    (assoc-ref inputs "gsl") "/lib/" all)))
7974                (substitute* "init/init.lisp"
7975                  (("libgsl.so" all)
7976                   (string-append
7977                    (assoc-ref inputs "gsl") "/lib/" all))))))))
7978       (synopsis "GNU Scientific Library for Lisp")
7979       (description
7980        "The GNU Scientific Library for Lisp (GSLL) allows the use of the
7981 GNU Scientific Library (GSL) from Common Lisp.  This library provides a
7982 full range of common mathematical operations useful to scientific and
7983 engineering applications.  The design of the GSLL interface is such
7984 that access to most of the GSL library is possible in a Lisp-natural
7985 way; the intent is that the user not be hampered by the restrictions
7986 of the C language in which GSL has been written.  GSLL thus provides
7987 interactive use of GSL for getting quick answers, even for someone not
7988 intending to program in Lisp.")
7989       (home-page "https://common-lisp.net/project/gsll/")
7990       (license license:gpl3))))
7991
7992 (define-public cl-gsll
7993   (sbcl-package->cl-source-package sbcl-gsll))
7994
7995 (define-public sbcl-antik
7996   (package
7997     (inherit sbcl-antik-base)
7998     (name "sbcl-antik")
7999     (inputs
8000      `(("gsll" ,sbcl-gsll)
8001        ("physical-dimension" ,sbcl-physical-dimension)))
8002     (arguments
8003      (substitute-keyword-arguments (package-arguments sbcl-antik-base)
8004        ((#:asd-file _ "") "antik.asd")
8005        ((#:asd-system-name _ #f) "antik")))))
8006
8007 (define-public cl-antik
8008   (sbcl-package->cl-source-package sbcl-antik))
8009
8010 (define-public sbcl-cl-interpol
8011   (let ((commit "1fd288d861db85bc4677cff3cdd6af75fda1afb4")
8012         (revision "1"))
8013     (package
8014       (name "sbcl-cl-interpol")
8015       (version (git-version "0.2.6" revision commit))
8016       (source
8017        (origin
8018          (method git-fetch)
8019          (uri (git-reference
8020                (url "https://github.com/edicl/cl-interpol.git")
8021                (commit commit)))
8022          (file-name (git-file-name name version))
8023          (sha256
8024           (base32
8025            "1hnikak52hmcq1r5f616m6qq1108qnkw80pja950nv1fq5p0ppjn"))))
8026       (build-system asdf-build-system/sbcl)
8027       (inputs
8028        `(("cl-unicode" ,sbcl-cl-unicode)
8029          ("named-readtables" ,sbcl-named-readtables)))
8030       (native-inputs
8031        `(("flexi-streams" ,sbcl-flexi-streams)))
8032       (synopsis "String interpolation for Common Lisp")
8033       (description
8034        "CL-INTERPOL is a library for Common Lisp which modifies the
8035 reader so that you can have interpolation within strings similar to
8036 Perl or Unix Shell scripts.  It also provides various ways to insert
8037 arbitrary characters into literal strings even if your editor/IDE
8038 doesn't support them.")
8039       (home-page "https://edicl.github.io/cl-interpol/")
8040       (license license:bsd-3))))
8041
8042 (define-public cl-interpol
8043   (sbcl-package->cl-source-package sbcl-cl-interpol))
8044
8045 (define-public ecl-cl-interpol
8046   (sbcl-package->ecl-package sbcl-cl-interpol))
8047
8048 (define sbcl-symbol-munger-boot0
8049   ;; There is a cyclical dependency between symbol-munger and lisp-unit2.
8050   ;; See https://github.com/AccelerationNet/symbol-munger/issues/4
8051   (let ((commit "cc2bb4b7acd454d756484aec81ba487648385fc3")
8052         (revision "1"))
8053     (package
8054       (name "sbcl-symbol-munger-boot0")
8055       (version (git-version "0.0.1" revision commit))
8056       (source
8057        (origin
8058          (method git-fetch)
8059          (uri (git-reference
8060                (url "https://github.com/AccelerationNet/symbol-munger.git")
8061                (commit commit)))
8062          (file-name (git-file-name name version))
8063          (sha256
8064           (base32
8065            "0diav5ricqsybqvbp4bkxyj3bn3v9n7xb2pqqc4vg1algsw2pyjl"))))
8066       (build-system asdf-build-system/sbcl)
8067       (arguments
8068        `(#:asd-file "symbol-munger.asd"
8069          #:asd-system-name "symbol-munger"))
8070       (inputs
8071        `(("iterate" ,sbcl-iterate)
8072          ("alexandria" ,sbcl-alexandria)))
8073       (native-inputs
8074        `(("lisp-unit" ,sbcl-lisp-unit)))
8075       (synopsis
8076        "Capitalization and spacing conversion functions for Common Lisp")
8077       (description
8078        "This is a Common Lisp library to change the capitalization and spacing
8079 of a string or a symbol.  It can convert to and from Lisp, english, underscore
8080 and camel-case rules.")
8081       (home-page "https://github.com/AccelerationNet/symbol-munger")
8082       ;; The package declares a BSD license, but all of the license
8083       ;; text is MIT.
8084       ;; See https://github.com/AccelerationNet/symbol-munger/issues/5
8085       (license license:expat))))
8086
8087 (define sbcl-lisp-unit2-boot0
8088   ;; There is a cyclical dependency between symbol-munger and lisp-unit2.
8089   ;; See https://github.com/AccelerationNet/symbol-munger/issues/4
8090   (let ((commit "fb9721524d1e4e73abb223ee036d74ce14a5505c")
8091         (revision "1"))
8092     (package
8093       (name "sbcl-lisp-unit2-boot0")
8094       (version (git-version "0.2.0" revision commit))
8095       (source
8096        (origin
8097          (method git-fetch)
8098          (uri (git-reference
8099                (url "https://github.com/AccelerationNet/lisp-unit2.git")
8100                (commit commit)))
8101          (file-name (git-file-name name version))
8102          (sha256
8103           (base32
8104            "1rsqy8y0jqll6xn9a593848f5wvd5ribv4csry1ly0hmdhfnqzlp"))))
8105       (build-system asdf-build-system/sbcl)
8106       (arguments
8107        `(#:asd-file "lisp-unit2.asd"
8108          #:asd-system-name "lisp-unit2"))
8109       (inputs
8110        `(("alexandria" ,sbcl-alexandria)
8111          ("cl-interpol" ,sbcl-cl-interpol)
8112          ("iterate" ,sbcl-iterate)
8113          ("symbol-munger-boot0" ,sbcl-symbol-munger-boot0)))
8114       (synopsis "Test Framework for Common Lisp")
8115       (description
8116        "LISP-UNIT2 is a Common Lisp library that supports unit testing in the
8117 style of JUnit for Java.  It is a new version of the lisp-unit library written
8118 by Chris Riesbeck.")
8119       (home-page "https://github.com/AccelerationNet/lisp-unit2")
8120       (license license:expat))))
8121
8122 (define-public sbcl-symbol-munger
8123   (let ((commit "97598d4c3c53fd5da72ab78908fbd5d8c7a13416")
8124         (revision "1"))
8125     (package
8126       (name "sbcl-symbol-munger")
8127       (version (git-version "0.0.1" revision commit))
8128       (source
8129        (origin
8130          (method git-fetch)
8131          (uri (git-reference
8132                (url "https://github.com/AccelerationNet/symbol-munger.git")
8133                (commit commit)))
8134          (file-name (git-file-name name version))
8135          (sha256
8136           (base32
8137            "0y8jywjy0ldyhp7bxf16fdvdd2qgqnd7nlhlqfpfnzxcqk4xy1km"))))
8138       (build-system asdf-build-system/sbcl)
8139       (inputs
8140        `(("alexandria" ,sbcl-alexandria)
8141          ("iterate" ,sbcl-iterate)))
8142       (native-inputs
8143        `(("lisp-unit2-boot0" ,sbcl-lisp-unit2-boot0)))
8144       (synopsis
8145        "Capitalization and spacing conversion functions for Common Lisp")
8146       (description
8147        "This is a Common Lisp library to change the capitalization and spacing
8148 of a string or a symbol.  It can convert to and from Lisp, english, underscore
8149 and camel-case rules.")
8150       (home-page "https://github.com/AccelerationNet/symbol-munger")
8151       ;; The package declares a BSD license, but all of the license
8152       ;; text is MIT.
8153       ;; See https://github.com/AccelerationNet/symbol-munger/issues/5
8154       (license license:expat))))
8155
8156 (define-public cl-symbol-munger
8157   (sbcl-package->cl-source-package sbcl-symbol-munger))
8158
8159 (define-public ecl-symbol-munger
8160   (sbcl-package->ecl-package sbcl-symbol-munger))
8161
8162 (define-public sbcl-lisp-unit2
8163   (package
8164     (inherit sbcl-lisp-unit2-boot0)
8165     (name "sbcl-lisp-unit2")
8166     (inputs
8167      `(("alexandria" ,sbcl-alexandria)
8168        ("cl-interpol" ,sbcl-cl-interpol)
8169        ("iterate" ,sbcl-iterate)
8170        ("symbol-munger" ,sbcl-symbol-munger)))))
8171
8172 (define-public cl-lisp-unit2
8173   (sbcl-package->cl-source-package sbcl-lisp-unit2))
8174
8175 (define-public ecl-lisp-unit2
8176   (sbcl-package->ecl-package sbcl-lisp-unit2))
8177
8178 (define-public sbcl-cl-csv
8179   (let ((commit "3eba29c8364b033fbe0d189c2500559278b6a362")
8180         (revision "1"))
8181     (package
8182       (name "sbcl-cl-csv")
8183       (version (git-version "1.0.6" revision commit))
8184       (source
8185        (origin
8186          (method git-fetch)
8187          (uri (git-reference
8188                (url "https://github.com/AccelerationNet/cl-csv.git")
8189                (commit commit)))
8190          (file-name (git-file-name name version))
8191          (sha256
8192           (base32
8193            "07h4ni89jzx93clx453hlnnb5g53hhlcmz5hghqv6ysam48lc8g6"))))
8194       (build-system asdf-build-system/sbcl)
8195       (arguments
8196        ;; See: https://github.com/AccelerationNet/cl-csv/pull/34
8197        `(#:tests? #f))
8198       (inputs
8199        `(("alexandria" ,sbcl-alexandria)
8200          ("cl-interpol" ,sbcl-cl-interpol)
8201          ("iterate" ,sbcl-iterate)))
8202       (native-inputs
8203        `(("lisp-unit2" ,sbcl-lisp-unit2)))
8204       (synopsis "Common lisp library for comma-separated values")
8205       (description
8206        "This is a Common Lisp library providing functions to read/write CSV
8207 from/to strings, streams and files.")
8208       (home-page "https://github.com/AccelerationNet/cl-csv")
8209       (license license:bsd-3))))
8210
8211 (define-public cl-csv
8212   (sbcl-package->cl-source-package sbcl-cl-csv))
8213
8214 (define-public ecl-cl-csv
8215   (sbcl-package->ecl-package sbcl-cl-csv))
8216
8217 (define-public sbcl-external-program
8218   (let ((commit "5888b8f1fd3953feeeacecbba4384ddda584a749")
8219         (revision "1"))
8220     (package
8221       (name "sbcl-external-program")
8222       (version (git-version "0.0.6" revision commit))
8223       (source
8224        (origin
8225          (method git-fetch)
8226          (uri (git-reference
8227                (url "https://github.com/sellout/external-program.git")
8228                (commit commit)))
8229          (file-name (git-file-name name version))
8230          (sha256
8231           (base32
8232            "0vww1x3yilb3bjwg6k184vaj4vxyxw4vralhnlm6lk4xac67kc9z"))))
8233       (build-system asdf-build-system/sbcl)
8234       (inputs
8235        `(("trivial-features" ,sbcl-trivial-features)))
8236       (native-inputs
8237        `(("fiveam" ,sbcl-fiveam)))
8238       (synopsis "Common Lisp library for running external programs")
8239       (description
8240        "EXTERNAL-PROGRAM enables running programs outside the Lisp
8241 process.  It is an attempt to make the RUN-PROGRAM functionality in
8242 implementations like SBCL and CCL as portable as possible without
8243 sacrificing much in the way of power.")
8244       (home-page "https://github.com/sellout/external-program")
8245       (license license:llgpl))))
8246
8247 (define-public cl-external-program
8248   (sbcl-package->cl-source-package sbcl-external-program))
8249
8250 (define-public ecl-external-program
8251   (sbcl-package->ecl-package sbcl-external-program))
8252
8253 (define sbcl-cl-ana-boot0
8254   (let ((commit "fa7cee4c50aa1c859652813049ba0da7c18a0df9")
8255         (revision "1"))
8256     (package
8257      (name "sbcl-cl-ana-boot0")
8258      (version (git-version "0.0.0" revision commit))
8259      (source
8260       (origin
8261        (method git-fetch)
8262        (uri (git-reference
8263              (url "https://github.com/ghollisjr/cl-ana.git")
8264              (commit commit)))
8265        (file-name (git-file-name name version))
8266        (sha256
8267         (base32
8268          "0mr47l57m276dbpap7irr4fcnk5fgknhf6mgv4043s8h73amk5qh"))))
8269      (build-system asdf-build-system/sbcl)
8270      (synopsis "Common Lisp data analysis library")
8271      (description
8272       "CL-ANA is a data analysis library in Common Lisp providing tabular and
8273 binned data analysis along with nonlinear least squares fitting and
8274 visualization.")
8275      (home-page "https://github.com/ghollisjr/cl-ana")
8276      (license license:gpl3))))
8277
8278 (define-public sbcl-cl-ana.pathname-utils
8279   (package
8280     (inherit sbcl-cl-ana-boot0)
8281     (name "sbcl-cl-ana.pathname-utils")
8282     (arguments
8283      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8284        ((#:asd-file _ "") "pathname-utils/cl-ana.pathname-utils.asd")
8285        ((#:asd-system-name _ #f) "cl-ana.pathname-utils")))))
8286
8287 (define-public cl-ana.pathname-utils
8288   (sbcl-package->cl-source-package sbcl-cl-ana.pathname-utils))
8289
8290 (define-public ecl-cl-ana.pathname-utils
8291   (sbcl-package->ecl-package sbcl-cl-ana.pathname-utils))
8292
8293 (define-public sbcl-cl-ana.package-utils
8294   (package
8295     (inherit sbcl-cl-ana-boot0)
8296     (name "sbcl-cl-ana.package-utils")
8297     (inputs
8298      `(("alexandria" ,sbcl-alexandria)))
8299     (arguments
8300      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8301        ((#:asd-file _ "") "package-utils/cl-ana.package-utils.asd")
8302        ((#:asd-system-name _ #f) "cl-ana.package-utils")))))
8303
8304 (define-public cl-ana.package-utils
8305   (sbcl-package->cl-source-package sbcl-cl-ana.package-utils))
8306
8307 (define-public ecl-cl-ana.package-utils
8308   (sbcl-package->ecl-package sbcl-cl-ana.package-utils))
8309
8310 (define-public sbcl-cl-ana.string-utils
8311   (package
8312     (inherit sbcl-cl-ana-boot0)
8313     (name "sbcl-cl-ana.string-utils")
8314     (inputs
8315      `(("split-sequence" ,sbcl-split-sequence)))
8316     (arguments
8317      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8318        ((#:asd-file _ "") "string-utils/cl-ana.string-utils.asd")
8319        ((#:asd-system-name _ #f) "cl-ana.string-utils")))))
8320
8321 (define-public cl-ana.string-utils
8322   (sbcl-package->cl-source-package sbcl-cl-ana.string-utils))
8323
8324 (define-public ecl-cl-ana.string-utils
8325   (sbcl-package->ecl-package sbcl-cl-ana.string-utils))
8326
8327 (define-public sbcl-cl-ana.functional-utils
8328   (package
8329     (inherit sbcl-cl-ana-boot0)
8330     (name "sbcl-cl-ana.functional-utils")
8331     (arguments
8332      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8333        ((#:asd-file _ "") "functional-utils/cl-ana.functional-utils.asd")
8334        ((#:asd-system-name _ #f) "cl-ana.functional-utils")))))
8335
8336 (define-public cl-ana.functional-utils
8337   (sbcl-package->cl-source-package sbcl-cl-ana.functional-utils))
8338
8339 (define-public ecl-cl-ana.functional-utils
8340   (sbcl-package->ecl-package sbcl-cl-ana.functional-utils))
8341
8342 (define-public sbcl-cl-ana.list-utils
8343   (package
8344     (inherit sbcl-cl-ana-boot0)
8345     (name "sbcl-cl-ana.list-utils")
8346     (inputs
8347      `(("alexandria" ,sbcl-alexandria)
8348        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
8349        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)))
8350     (arguments
8351      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8352        ((#:asd-file _ "") "list-utils/cl-ana.list-utils.asd")
8353        ((#:asd-system-name _ #f) "cl-ana.list-utils")))))
8354
8355 (define-public cl-ana.list-utils
8356   (sbcl-package->cl-source-package sbcl-cl-ana.list-utils))
8357
8358 (define-public ecl-cl-ana.list-utils
8359   (sbcl-package->ecl-package sbcl-cl-ana.list-utils))
8360
8361 (define-public sbcl-cl-ana.generic-math
8362   (package
8363     (inherit sbcl-cl-ana-boot0)
8364     (name "sbcl-cl-ana.generic-math")
8365     (inputs
8366      `(("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8367        ("cl-ana.package-utils" ,sbcl-cl-ana.package-utils)))
8368     (arguments
8369      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8370        ((#:asd-file _ "") "generic-math/cl-ana.generic-math.asd")
8371        ((#:asd-system-name _ #f) "cl-ana.generic-math")))))
8372
8373 (define-public cl-ana.generic-math
8374   (sbcl-package->cl-source-package sbcl-cl-ana.generic-math))
8375
8376 (define-public ecl-cl-ana.generic-math
8377   (sbcl-package->ecl-package sbcl-cl-ana.generic-math))
8378
8379 (define-public sbcl-cl-ana.math-functions
8380   (package
8381     (inherit sbcl-cl-ana-boot0)
8382     (name "sbcl-cl-ana.math-functions")
8383     (inputs
8384      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8385        ("gsll" ,sbcl-gsll)))
8386     (arguments
8387      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8388        ((#:asd-file _ "") "math-functions/cl-ana.math-functions.asd")
8389        ((#:asd-system-name _ #f) "cl-ana.math-functions")))))
8390
8391 (define-public cl-ana.math-functions
8392   (sbcl-package->cl-source-package sbcl-cl-ana.math-functions))
8393
8394 (define-public sbcl-cl-ana.calculus
8395   (package
8396     (inherit sbcl-cl-ana-boot0)
8397     (name "sbcl-cl-ana.calculus")
8398     (inputs
8399      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)))
8400     (arguments
8401      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8402        ((#:asd-file _ "") "calculus/cl-ana.calculus.asd")
8403        ((#:asd-system-name _ #f) "cl-ana.calculus")))))
8404
8405 (define-public cl-ana.calculus
8406   (sbcl-package->cl-source-package sbcl-cl-ana.calculus))
8407
8408 (define-public ecl-cl-ana.calculus
8409   (sbcl-package->ecl-package sbcl-cl-ana.calculus))
8410
8411 (define-public sbcl-cl-ana.symbol-utils
8412   (package
8413     (inherit sbcl-cl-ana-boot0)
8414     (name "sbcl-cl-ana.symbol-utils")
8415     (inputs
8416      `(("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)))
8417     (arguments
8418      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8419        ((#:asd-file _ "") "symbol-utils/cl-ana.symbol-utils.asd")
8420        ((#:asd-system-name _ #f) "cl-ana.symbol-utils")))))
8421
8422 (define-public cl-ana.symbol-utils
8423   (sbcl-package->cl-source-package sbcl-cl-ana.symbol-utils))
8424
8425 (define-public ecl-cl-ana.symbol-utils
8426   (sbcl-package->ecl-package sbcl-cl-ana.symbol-utils))
8427
8428 (define-public sbcl-cl-ana.macro-utils
8429   (package
8430     (inherit sbcl-cl-ana-boot0)
8431     (name "sbcl-cl-ana.macro-utils")
8432     (inputs
8433      `(("alexandria" ,sbcl-alexandria)
8434        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8435        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8436        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8437        ("split-sequence" ,sbcl-split-sequence)))
8438     (arguments
8439      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8440        ((#:asd-file _ "") "macro-utils/cl-ana.macro-utils.asd")
8441        ((#:asd-system-name _ #f) "cl-ana.macro-utils")))))
8442
8443 (define-public cl-ana.macro-utils
8444   (sbcl-package->cl-source-package sbcl-cl-ana.macro-utils))
8445
8446 (define-public ecl-cl-ana.macro-utils
8447   (sbcl-package->ecl-package sbcl-cl-ana.macro-utils))
8448
8449 (define-public sbcl-cl-ana.binary-tree
8450   (package
8451     (inherit sbcl-cl-ana-boot0)
8452     (name "sbcl-cl-ana.binary-tree")
8453     (inputs
8454      `(("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
8455        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8456        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)))
8457     (arguments
8458      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8459        ((#:asd-file _ "") "binary-tree/cl-ana.binary-tree.asd")
8460        ((#:asd-system-name _ #f) "cl-ana.binary-tree")))))
8461
8462 (define-public cl-ana.binary-tree
8463   (sbcl-package->cl-source-package sbcl-cl-ana.binary-tree))
8464
8465 (define-public ecl-cl-ana.binary-tree
8466   (sbcl-package->ecl-package sbcl-cl-ana.binary-tree))
8467
8468 (define-public sbcl-cl-ana.tensor
8469   (package
8470     (inherit sbcl-cl-ana-boot0)
8471     (name "sbcl-cl-ana.tensor")
8472     (inputs
8473      `(("alexandria" ,sbcl-alexandria)
8474        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8475        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8476        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8477        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)))
8478     (arguments
8479      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8480        ((#:asd-file _ "") "tensor/cl-ana.tensor.asd")
8481        ((#:asd-system-name _ #f) "cl-ana.tensor")))))
8482
8483 (define-public cl-ana.tensor
8484   (sbcl-package->cl-source-package sbcl-cl-ana.tensor))
8485
8486 (define-public ecl-cl-ana.tensor
8487   (sbcl-package->ecl-package sbcl-cl-ana.tensor))
8488
8489 (define-public sbcl-cl-ana.error-propogation
8490   (package
8491     (inherit sbcl-cl-ana-boot0)
8492     (name "sbcl-cl-ana.error-propogation")
8493     (inputs
8494      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8495        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)))
8496     (arguments
8497      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8498        ((#:asd-file _ "") "error-propogation/cl-ana.error-propogation.asd")
8499        ((#:asd-system-name _ #f) "cl-ana.error-propogation")))))
8500
8501 (define-public cl-ana.error-propogation
8502   (sbcl-package->cl-source-package sbcl-cl-ana.error-propogation))
8503
8504 (define-public sbcl-cl-ana.quantity
8505   (package
8506     (inherit sbcl-cl-ana-boot0)
8507     (name "sbcl-cl-ana.quantity")
8508     (inputs
8509      `(("alexandria" ,sbcl-alexandria)
8510        ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
8511        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8512        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8513        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8514        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)))
8515     (arguments
8516      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8517        ((#:asd-file _ "") "quantity/cl-ana.quantity.asd")
8518        ((#:asd-system-name _ #f) "cl-ana.quantity")))))
8519
8520 (define-public cl-ana.quantity
8521   (sbcl-package->cl-source-package sbcl-cl-ana.quantity))
8522
8523 (define-public sbcl-cl-ana.table
8524   (package
8525     (inherit sbcl-cl-ana-boot0)
8526     (name "sbcl-cl-ana.table")
8527     (inputs
8528      `(("alexandria" ,sbcl-alexandria)
8529        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
8530        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8531        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8532        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8533        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)))
8534     (arguments
8535      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8536        ((#:asd-file _ "") "table/cl-ana.table.asd")
8537        ((#:asd-system-name _ #f) "cl-ana.table")))))
8538
8539 (define-public cl-ana.table
8540   (sbcl-package->cl-source-package sbcl-cl-ana.table))
8541
8542 (define-public ecl-cl-ana.table
8543   (sbcl-package->ecl-package sbcl-cl-ana.table))
8544
8545 (define-public sbcl-cl-ana.table-utils
8546   (package
8547     (inherit sbcl-cl-ana-boot0)
8548     (name "sbcl-cl-ana.table-utils")
8549     (inputs
8550      `(("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8551        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8552        ("cl-ana.table" ,sbcl-cl-ana.table)))
8553     (arguments
8554      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8555        ((#:asd-file _ "") "table-utils/cl-ana.table-utils.asd")
8556        ((#:asd-system-name _ #f) "cl-ana.table-utils")))))
8557
8558 (define-public cl-ana.table-utils
8559   (sbcl-package->cl-source-package sbcl-cl-ana.table-utils))
8560
8561 (define-public ecl-cl-ana.table-utils
8562   (sbcl-package->ecl-package sbcl-cl-ana.table-utils))
8563
8564 (define-public sbcl-cl-ana.hdf-cffi
8565   (package
8566     (inherit sbcl-cl-ana-boot0)
8567     (name "sbcl-cl-ana.hdf-cffi")
8568     (inputs
8569      `(("cffi" ,sbcl-cffi)
8570        ("hdf5" ,hdf5-parallel-openmpi)))
8571     (arguments
8572      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8573        ((#:asd-file _ "") "hdf-cffi/cl-ana.hdf-cffi.asd")
8574        ((#:asd-system-name _ #f) "cl-ana.hdf-cffi")
8575        ((#:phases phases '%standard-phases)
8576         `(modify-phases ,phases
8577            (add-after 'unpack 'fix-paths
8578              (lambda* (#:key inputs #:allow-other-keys)
8579                (substitute* "hdf-cffi/hdf-cffi.lisp"
8580                  (("/usr/lib/i386-linux-gnu/hdf5/serial/libhdf5.so")
8581                   (string-append
8582                    (assoc-ref inputs "hdf5")
8583                    "/lib/libhdf5.so")))))))))))
8584
8585 (define-public cl-ana.hdf-cffi
8586   (sbcl-package->cl-source-package sbcl-cl-ana.hdf-cffi))
8587
8588 (define-public ecl-cl-ana.hdf-cffi
8589   (sbcl-package->ecl-package sbcl-cl-ana.hdf-cffi))
8590
8591 (define-public sbcl-cl-ana.int-char
8592   (package
8593     (inherit sbcl-cl-ana-boot0)
8594     (name "sbcl-cl-ana.int-char")
8595     (arguments
8596      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8597        ((#:asd-file _ "") "int-char/cl-ana.int-char.asd")
8598        ((#:asd-system-name _ #f) "cl-ana.int-char")))))
8599
8600 (define-public cl-ana.int-char
8601   (sbcl-package->cl-source-package sbcl-cl-ana.int-char))
8602
8603 (define-public ecl-cl-ana.int-char
8604   (sbcl-package->ecl-package sbcl-cl-ana.int-char))
8605
8606 (define-public sbcl-cl-ana.memoization
8607   (package
8608     (inherit sbcl-cl-ana-boot0)
8609     (name "sbcl-cl-ana.memoization")
8610     (inputs
8611      `(("alexandria" ,sbcl-alexandria)))
8612     (arguments
8613      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8614        ((#:asd-file _ "") "memoization/cl-ana.memoization.asd")
8615        ((#:asd-system-name _ #f) "cl-ana.memoization")))))
8616
8617 (define-public cl-ana.memoization
8618   (sbcl-package->cl-source-package sbcl-cl-ana.memoization))
8619
8620 (define-public ecl-cl-ana.memoization
8621   (sbcl-package->ecl-package sbcl-cl-ana.memoization))
8622
8623 (define-public sbcl-cl-ana.typespec
8624   (package
8625     (inherit sbcl-cl-ana-boot0)
8626     (name "sbcl-cl-ana.typespec")
8627     (inputs
8628      `(("alexandria" ,sbcl-alexandria)
8629        ("cffi" ,sbcl-cffi)
8630        ("cl-ana.int-char" ,sbcl-cl-ana.int-char)
8631        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8632        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
8633        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8634        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8635        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)))
8636     (arguments
8637      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8638        ((#:asd-file _ "") "typespec/cl-ana.typespec.asd")
8639        ((#:asd-system-name _ #f) "cl-ana.typespec")))))
8640
8641 (define-public cl-ana.typespec
8642   (sbcl-package->cl-source-package sbcl-cl-ana.typespec))
8643
8644 (define-public ecl-cl-ana.typespec
8645   (sbcl-package->ecl-package sbcl-cl-ana.typespec))
8646
8647 (define-public sbcl-cl-ana.hdf-typespec
8648   (package
8649     (inherit sbcl-cl-ana-boot0)
8650     (name "sbcl-cl-ana.hdf-typespec")
8651     (inputs
8652      `(("alexandria" ,sbcl-alexandria)
8653        ("cffi" ,sbcl-cffi)
8654        ("cl-ana.hdf-cffi" ,sbcl-cl-ana.hdf-cffi)
8655        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8656        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
8657        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8658        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8659        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
8660     (arguments
8661      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8662        ((#:asd-file _ "") "hdf-typespec/cl-ana.hdf-typespec.asd")
8663        ((#:asd-system-name _ #f) "cl-ana.hdf-typespec")))))
8664
8665 (define-public cl-ana.hdf-typespec
8666   (sbcl-package->cl-source-package sbcl-cl-ana.hdf-typespec))
8667
8668 (define-public ecl-cl-ana.hdf-typespec
8669   (sbcl-package->ecl-package sbcl-cl-ana.hdf-typespec))
8670
8671 (define-public sbcl-cl-ana.hdf-utils
8672   (package
8673     (inherit sbcl-cl-ana-boot0)
8674     (name "sbcl-cl-ana.hdf-utils")
8675     (inputs
8676      `(("alexandria" ,sbcl-alexandria)
8677        ("cffi" ,sbcl-cffi)
8678        ("cl-ana.hdf-cffi" ,sbcl-cl-ana.hdf-cffi)
8679        ("cl-ana.hdf-typespec" ,sbcl-cl-ana.hdf-typespec)
8680        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8681        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
8682        ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
8683        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8684        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
8685     (arguments
8686      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8687        ((#:asd-file _ "") "hdf-utils/cl-ana.hdf-utils.asd")
8688        ((#:asd-system-name _ #f) "cl-ana.hdf-utils")))))
8689
8690 (define-public cl-ana.hdf-utils
8691   (sbcl-package->cl-source-package sbcl-cl-ana.hdf-utils))
8692
8693 (define-public ecl-cl-ana.hdf-utils
8694   (sbcl-package->ecl-package sbcl-cl-ana.hdf-utils))
8695
8696 (define-public sbcl-cl-ana.typed-table
8697   (package
8698     (inherit sbcl-cl-ana-boot0)
8699     (name "sbcl-cl-ana.typed-table")
8700     (inputs
8701      `(("alexandria" ,sbcl-alexandria)
8702        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8703        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8704        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8705        ("cl-ana.table" ,sbcl-cl-ana.table)
8706        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
8707     (arguments
8708      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8709        ((#:asd-file _ "") "typed-table/cl-ana.typed-table.asd")
8710        ((#:asd-system-name _ #f) "cl-ana.typed-table")))))
8711
8712 (define-public cl-ana.typed-table
8713   (sbcl-package->cl-source-package sbcl-cl-ana.typed-table))
8714
8715 (define-public ecl-cl-ana.typed-table
8716   (sbcl-package->ecl-package sbcl-cl-ana.typed-table))
8717
8718 (define-public sbcl-cl-ana.hdf-table
8719   (package
8720     (inherit sbcl-cl-ana-boot0)
8721     (name "sbcl-cl-ana.hdf-table")
8722     (inputs
8723      `(("alexandria" ,sbcl-alexandria)
8724        ("cl-ana.binary-tree" ,sbcl-cl-ana.binary-tree)
8725        ("cl-ana.hdf-cffi" ,sbcl-cl-ana.hdf-cffi)
8726        ("cl-ana.hdf-typespec" ,sbcl-cl-ana.hdf-typespec)
8727        ("cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
8728        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8729        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
8730        ("cl-ana.table" ,sbcl-cl-ana.table)
8731        ("cl-ana.typed-table" ,sbcl-cl-ana.typed-table)
8732        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
8733     (arguments
8734      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8735        ((#:asd-file _ "") "hdf-table/cl-ana.hdf-table.asd")
8736        ((#:asd-system-name _ #f) "cl-ana.hdf-table")))))
8737
8738 (define-public cl-ana.hdf-table
8739   (sbcl-package->cl-source-package sbcl-cl-ana.hdf-table))
8740
8741 (define-public ecl-cl-ana.hdf-table
8742   (sbcl-package->ecl-package sbcl-cl-ana.hdf-table))
8743
8744 (define-public sbcl-cl-ana.gsl-cffi
8745   (package
8746     (inherit sbcl-cl-ana-boot0)
8747     (name "sbcl-cl-ana.gsl-cffi")
8748     (inputs
8749      `(("cffi" ,sbcl-cffi)
8750        ("gsl" ,gsl)))
8751     (arguments
8752      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8753        ((#:asd-file _ "") "gsl-cffi/cl-ana.gsl-cffi.asd")
8754        ((#:asd-system-name _ #f) "cl-ana.gsl-cffi")
8755        ((#:phases phases '%standard-phases)
8756         `(modify-phases ,phases
8757            (add-after 'unpack 'fix-paths
8758              (lambda* (#:key inputs #:allow-other-keys)
8759                (substitute* "gsl-cffi/gsl-cffi.lisp"
8760                  (("define-foreign-library gsl-cffi" all)
8761                   (string-append all " (:unix "
8762                                  (assoc-ref inputs "gsl")
8763                                  "/lib/libgsl.so)")))))))))))
8764
8765 (define-public cl-ana.gsl-cffi
8766   (sbcl-package->cl-source-package sbcl-cl-ana.gsl-cffi))
8767
8768 (define-public ecl-cl-ana.gsl-cffi
8769   (sbcl-package->ecl-package sbcl-cl-ana.gsl-cffi))
8770
8771 (define-public sbcl-cl-ana.ntuple-table
8772   (package
8773     (inherit sbcl-cl-ana-boot0)
8774     (name "sbcl-cl-ana.ntuple-table")
8775     (inputs
8776      `(("alexandria" ,sbcl-alexandria)
8777        ("cffi" ,sbcl-cffi)
8778        ("cl-ana.gsl-cffi" ,sbcl-cl-ana.gsl-cffi)
8779        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8780        ("cl-ana.table" ,sbcl-cl-ana.table)
8781        ("cl-ana.typed-table" ,sbcl-cl-ana.typed-table)
8782        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)
8783        ("gsll" ,sbcl-gsll)))
8784     (arguments
8785      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8786        ((#:asd-file _ "") "ntuple-table/cl-ana.ntuple-table.asd")
8787        ((#:asd-system-name _ #f) "cl-ana.ntuple-table")))))
8788
8789 (define-public cl-ana.ntuple-table
8790   (sbcl-package->cl-source-package sbcl-cl-ana.ntuple-table))
8791
8792 (define-public sbcl-cl-ana.csv-table
8793   (package
8794     (inherit sbcl-cl-ana-boot0)
8795     (name "sbcl-cl-ana.csv-table")
8796     (inputs
8797      `(("alexandria" ,sbcl-alexandria)
8798        ("antik" ,sbcl-antik)
8799        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8800        ("cl-ana.table" ,sbcl-cl-ana.table)
8801        ("cl-csv" ,sbcl-cl-csv)
8802        ("iterate" ,sbcl-iterate)))
8803     (arguments
8804      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8805        ((#:asd-file _ "") "csv-table/cl-ana.csv-table.asd")
8806        ((#:asd-system-name _ #f) "cl-ana.csv-table")))))
8807
8808 (define-public cl-ana.csv-table
8809   (sbcl-package->cl-source-package sbcl-cl-ana.csv-table))
8810
8811 (define-public sbcl-cl-ana.reusable-table
8812   (package
8813     (inherit sbcl-cl-ana-boot0)
8814     (name "sbcl-cl-ana.reusable-table")
8815     (inputs
8816      `(("alexandria" ,sbcl-alexandria)
8817        ("cl-ana.table" ,sbcl-cl-ana.table)))
8818     (arguments
8819      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8820        ((#:asd-file _ "") "reusable-table/cl-ana.reusable-table.asd")
8821        ((#:asd-system-name _ #f) "cl-ana.reusable-table")))))
8822
8823 (define-public cl-ana.reusable-table
8824   (sbcl-package->cl-source-package sbcl-cl-ana.reusable-table))
8825
8826 (define-public ecl-cl-ana.reusable-table
8827   (sbcl-package->ecl-package sbcl-cl-ana.reusable-table))
8828
8829 (define-public sbcl-cl-ana.linear-algebra
8830   (package
8831     (inherit sbcl-cl-ana-boot0)
8832     (name "sbcl-cl-ana.linear-algebra")
8833     (inputs
8834      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8835        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8836        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
8837        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
8838        ("gsll" ,sbcl-gsll)))
8839     (arguments
8840      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8841        ((#:asd-file _ "") "linear-algebra/cl-ana.linear-algebra.asd")
8842        ((#:asd-system-name _ #f) "cl-ana.linear-algebra")))))
8843
8844 (define-public cl-ana.linear-algebra
8845   (sbcl-package->cl-source-package sbcl-cl-ana.linear-algebra))
8846
8847 (define-public sbcl-cl-ana.lorentz
8848   (package
8849     (inherit sbcl-cl-ana-boot0)
8850     (name "sbcl-cl-ana.lorentz")
8851     (inputs
8852      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8853        ("cl-ana.linear-algebra" ,sbcl-cl-ana.linear-algebra)
8854        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
8855        ("iterate" ,sbcl-iterate)))
8856     (arguments
8857      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8858        ((#:asd-file _ "") "lorentz/cl-ana.lorentz.asd")
8859        ((#:asd-system-name _ #f) "cl-ana.lorentz")))))
8860
8861 (define-public cl-ana.lorentz
8862   (sbcl-package->cl-source-package sbcl-cl-ana.lorentz))
8863
8864 (define-public sbcl-cl-ana.clos-utils
8865   (package
8866     (inherit sbcl-cl-ana-boot0)
8867     (name "sbcl-cl-ana.clos-utils")
8868     (inputs
8869      `(("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8870        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8871        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
8872        ("closer-mop" ,sbcl-closer-mop)))
8873     (arguments
8874      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8875        ((#:asd-file _ "") "clos-utils/cl-ana.clos-utils.asd")
8876        ((#:asd-system-name _ #f) "cl-ana.clos-utils")))))
8877
8878 (define-public cl-ana.clos-utils
8879   (sbcl-package->cl-source-package sbcl-cl-ana.clos-utils))
8880
8881 (define-public ecl-cl-ana.clos-utils
8882   (sbcl-package->ecl-package sbcl-cl-ana.clos-utils))
8883
8884 (define-public sbcl-cl-ana.hash-table-utils
8885   (package
8886     (inherit sbcl-cl-ana-boot0)
8887     (name "sbcl-cl-ana.hash-table-utils")
8888     (arguments
8889      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8890        ((#:asd-file _ "") "hash-table-utils/cl-ana.hash-table-utils.asd")
8891        ((#:asd-system-name _ #f) "cl-ana.hash-table-utils")))))
8892
8893 (define-public cl-ana.hash-table-utils
8894   (sbcl-package->cl-source-package sbcl-cl-ana.hash-table-utils))
8895
8896 (define-public ecl-cl-ana.hash-table-utils
8897   (sbcl-package->ecl-package sbcl-cl-ana.hash-table-utils))
8898
8899 (define-public sbcl-cl-ana.map
8900   (package
8901     (inherit sbcl-cl-ana-boot0)
8902     (name "sbcl-cl-ana.map")
8903     (inputs
8904      `(("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)))
8905     (arguments
8906      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8907        ((#:asd-file _ "") "map/cl-ana.map.asd")
8908        ((#:asd-system-name _ #f) "cl-ana.map")))))
8909
8910 (define-public cl-ana.map
8911   (sbcl-package->cl-source-package sbcl-cl-ana.map))
8912
8913 (define-public ecl-cl-ana.map
8914   (sbcl-package->ecl-package sbcl-cl-ana.map))
8915
8916 (define-public sbcl-cl-ana.fitting
8917   (package
8918     (inherit sbcl-cl-ana-boot0)
8919     (name "sbcl-cl-ana.fitting")
8920     (inputs
8921      `(("alexandria" ,sbcl-alexandria)
8922        ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
8923        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8924        ("cl-ana.map" ,sbcl-cl-ana.map)
8925        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
8926        ("gsll" ,sbcl-gsll)))
8927     (arguments
8928      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8929        ((#:asd-file _ "") "fitting/cl-ana.fitting.asd")
8930        ((#:asd-system-name _ #f) "cl-ana.fitting")))))
8931
8932 (define-public cl-ana.fitting
8933   (sbcl-package->cl-source-package sbcl-cl-ana.fitting))
8934
8935 (define-public sbcl-cl-ana.histogram
8936   (package
8937     (inherit sbcl-cl-ana-boot0)
8938     (name "sbcl-cl-ana.histogram")
8939     (inputs
8940      `(("alexandria" ,sbcl-alexandria)
8941        ("iterate" ,sbcl-iterate)
8942        ("cl-ana.binary-tree" ,sbcl-cl-ana.binary-tree)
8943        ("cl-ana.clos-utils" ,sbcl-cl-ana.clos-utils)
8944        ("cl-ana.fitting" ,sbcl-cl-ana.fitting)
8945        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
8946        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8947        ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
8948        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8949        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8950        ("cl-ana.map" ,sbcl-cl-ana.map)
8951        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)))
8952     (arguments
8953      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8954        ((#:asd-file _ "") "histogram/cl-ana.histogram.asd")
8955        ((#:asd-system-name _ #f) "cl-ana.histogram")))))
8956
8957 (define-public cl-ana.histogram
8958   (sbcl-package->cl-source-package sbcl-cl-ana.histogram))
8959
8960 (define-public sbcl-cl-ana.file-utils
8961   (package
8962     (inherit sbcl-cl-ana-boot0)
8963     (name "sbcl-cl-ana.file-utils")
8964     (inputs
8965      `(("external-program" ,sbcl-external-program)
8966        ("split-sequence" ,sbcl-split-sequence)))
8967     (arguments
8968      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8969        ((#:asd-file _ "") "file-utils/cl-ana.file-utils.asd")
8970        ((#:asd-system-name _ #f) "cl-ana.file-utils")))))
8971
8972 (define-public cl-ana.file-utils
8973   (sbcl-package->cl-source-package sbcl-cl-ana.file-utils))
8974
8975 (define-public ecl-cl-ana.file-utils
8976   (sbcl-package->ecl-package sbcl-cl-ana.file-utils))
8977
8978 (define-public sbcl-cl-ana.statistics
8979   (package
8980     (inherit sbcl-cl-ana-boot0)
8981     (name "sbcl-cl-ana.statistics")
8982     (inputs
8983      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8984        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
8985        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8986        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8987        ("cl-ana.map" ,sbcl-cl-ana.map)))
8988     (arguments
8989      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8990        ((#:asd-file _ "") "statistics/cl-ana.statistics.asd")
8991        ((#:asd-system-name _ #f) "cl-ana.statistics")))))
8992
8993 (define-public cl-ana.statistics
8994   (sbcl-package->cl-source-package sbcl-cl-ana.statistics))
8995
8996 (define-public sbcl-cl-ana.gnuplot-interface
8997   (package
8998     (inherit sbcl-cl-ana-boot0)
8999     (name "sbcl-cl-ana.gnuplot-interface")
9000     (inputs
9001      `(("external-program" ,sbcl-external-program)))
9002     (arguments
9003      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9004        ((#:asd-file _ "") "gnuplot-interface/cl-ana.gnuplot-interface.asd")
9005        ((#:asd-system-name _ #f) "cl-ana.gnuplot-interface")))))
9006
9007 (define-public cl-ana.gnuplot-interface
9008   (sbcl-package->cl-source-package sbcl-cl-ana.gnuplot-interface))
9009
9010 (define-public ecl-cl-ana.gnuplot-interface
9011   (sbcl-package->ecl-package sbcl-cl-ana.gnuplot-interface))
9012
9013 (define-public sbcl-cl-ana.plotting
9014   (package
9015     (inherit sbcl-cl-ana-boot0)
9016     (name "sbcl-cl-ana.plotting")
9017     (inputs
9018      `(("alexandria" ,sbcl-alexandria)
9019        ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
9020        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
9021        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9022        ("cl-ana.gnuplot-interface" ,sbcl-cl-ana.gnuplot-interface)
9023        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9024        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9025        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9026        ("cl-ana.map" ,sbcl-cl-ana.map)
9027        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
9028        ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
9029        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
9030        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
9031        ("external-program" ,sbcl-external-program)
9032        ("split-sequence" ,sbcl-split-sequence)))
9033     (arguments
9034      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9035        ((#:asd-file _ "") "plotting/cl-ana.plotting.asd")
9036        ((#:asd-system-name _ #f) "cl-ana.plotting")))))
9037
9038 (define-public cl-ana.plotting
9039   (sbcl-package->cl-source-package sbcl-cl-ana.plotting))
9040
9041 (define-public sbcl-cl-ana.table-viewing
9042   (package
9043     (inherit sbcl-cl-ana-boot0)
9044     (name "sbcl-cl-ana.table-viewing")
9045     (inputs
9046      `(("alexandria" ,sbcl-alexandria)
9047        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9048        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9049        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9050        ("cl-ana.plotting" ,sbcl-cl-ana.plotting)
9051        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
9052        ("cl-ana.table" ,sbcl-cl-ana.table)))
9053     (arguments
9054      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9055        ((#:asd-file _ "") "table-viewing/cl-ana.table-viewing.asd")
9056        ((#:asd-system-name _ #f) "cl-ana.table-viewing")))))
9057
9058 (define-public cl-ana.table-viewing
9059   (sbcl-package->cl-source-package sbcl-cl-ana.table-viewing))
9060
9061 (define-public sbcl-cl-ana.serialization
9062   (package
9063     (inherit sbcl-cl-ana-boot0)
9064     (name "sbcl-cl-ana.serialization")
9065     (inputs
9066      `(("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
9067        ("cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
9068        ("cl-ana.hdf-table" ,sbcl-cl-ana.hdf-table)
9069        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9070        ("cl-ana.int-char" ,sbcl-cl-ana.int-char)
9071        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9072        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
9073     (arguments
9074      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9075        ((#:asd-file _ "") "serialization/cl-ana.serialization.asd")
9076        ((#:asd-system-name _ #f) "cl-ana.serialization")))))
9077
9078 (define-public cl-ana.serialization
9079   (sbcl-package->cl-source-package sbcl-cl-ana.serialization))
9080
9081 (define-public sbcl-cl-ana.makeres
9082   (package
9083     (inherit sbcl-cl-ana-boot0)
9084     (name "sbcl-cl-ana.makeres")
9085     (inputs
9086      `(("alexandria" ,sbcl-alexandria)
9087        ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
9088        ("cl-ana.file-utils" ,sbcl-cl-ana.file-utils)
9089        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
9090        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9091        ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
9092        ("cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
9093        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9094        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9095        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9096        ("cl-ana.map" ,sbcl-cl-ana.map)
9097        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
9098        ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
9099        ("cl-ana.plotting" ,sbcl-cl-ana.plotting)
9100        ("cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
9101        ("cl-ana.serialization" ,sbcl-cl-ana.serialization)
9102        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
9103        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
9104        ("cl-ana.table" ,sbcl-cl-ana.table)
9105        ("external-program" ,sbcl-external-program)))
9106     (native-inputs
9107      `(("cl-fad" ,sbcl-cl-fad)))
9108     (arguments
9109      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9110        ((#:asd-file _ "") "makeres/cl-ana.makeres.asd")
9111        ((#:asd-system-name _ #f) "cl-ana.makeres")))))
9112
9113 (define-public cl-ana.makeres
9114   (sbcl-package->cl-source-package sbcl-cl-ana.makeres))
9115
9116 (define-public sbcl-cl-ana.makeres-macro
9117   (package
9118     (inherit sbcl-cl-ana-boot0)
9119     (name "sbcl-cl-ana.makeres-macro")
9120     (inputs
9121      `(("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9122        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)))
9123     (arguments
9124      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9125        ((#:asd-file _ "") "makeres-macro/cl-ana.makeres-macro.asd")
9126        ((#:asd-system-name _ #f) "cl-ana.makeres-macro")))))
9127
9128 (define-public cl-ana.makeres-macro
9129   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-macro))
9130
9131 (define-public sbcl-cl-ana.makeres-block
9132   (package
9133     (inherit sbcl-cl-ana-boot0)
9134     (name "sbcl-cl-ana.makeres-block")
9135     (inputs
9136      `(("alexandria" ,sbcl-alexandria)
9137        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9138        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9139        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)))
9140     (arguments
9141      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9142        ((#:asd-file _ "") "makeres-block/cl-ana.makeres-block.asd")
9143        ((#:asd-system-name _ #f) "cl-ana.makeres-block")))))
9144
9145 (define-public cl-ana.makeres-block
9146   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-block))
9147
9148 (define-public sbcl-cl-ana.makeres-progress
9149   (package
9150     (inherit sbcl-cl-ana-boot0)
9151     (name "sbcl-cl-ana.makeres-progress")
9152     (inputs
9153      `(("alexandria" ,sbcl-alexandria)
9154        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9155        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)))
9156     (arguments
9157      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9158        ((#:asd-file _ "") "makeres-progress/cl-ana.makeres-progress.asd")
9159        ((#:asd-system-name _ #f) "cl-ana.makeres-progress")))))
9160
9161 (define-public cl-ana.makeres-progress
9162   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-progress))
9163
9164 (define-public sbcl-cl-ana.makeres-table
9165   (package
9166     (inherit sbcl-cl-ana-boot0)
9167     (name "sbcl-cl-ana.makeres-table")
9168     (inputs
9169      `(("cl-ana.csv-table" ,sbcl-cl-ana.csv-table)
9170        ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
9171        ("cl-ana.hdf-table" ,sbcl-cl-ana.hdf-table)
9172        ("cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
9173        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9174        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9175        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)
9176        ("cl-ana.makeres-macro" ,sbcl-cl-ana.makeres-macro)
9177        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
9178        ("cl-ana.ntuple-table" ,sbcl-cl-ana.ntuple-table)
9179        ("cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
9180        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
9181        ("cl-ana.table" ,sbcl-cl-ana.table)))
9182     (native-inputs
9183      `(("cl-fad" ,sbcl-cl-fad)))
9184     (arguments
9185      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9186        ((#:asd-file _ "") "makeres-table/cl-ana.makeres-table.asd")
9187        ((#:asd-system-name _ #f) "cl-ana.makeres-table")))))
9188
9189 (define-public cl-ana.makeres-table
9190   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-table))
9191
9192 (define-public sbcl-cl-ana.makeres-graphviz
9193   (package
9194     (inherit sbcl-cl-ana-boot0)
9195     (name "sbcl-cl-ana.makeres-graphviz")
9196     (inputs
9197      `(("cl-ana.makeres" ,sbcl-cl-ana.makeres)
9198        ("external-program" ,sbcl-external-program)))
9199     (arguments
9200      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9201        ((#:asd-file _ "") "makeres-graphviz/cl-ana.makeres-graphviz.asd")
9202        ((#:asd-system-name _ #f) "cl-ana.makeres-graphviz")))))
9203
9204 (define-public cl-ana.makeres-graphviz
9205   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-graphviz))
9206
9207 (define-public sbcl-cl-ana.makeres-branch
9208   (package
9209     (inherit sbcl-cl-ana-boot0)
9210     (name "sbcl-cl-ana.makeres-branch")
9211     (inputs
9212      `(("alexandria" ,sbcl-alexandria)
9213        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9214        ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
9215        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9216        ("cl-ana.map" ,sbcl-cl-ana.map)
9217        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)))
9218     (arguments
9219      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9220        ((#:asd-file _ "") "makeres-branch/cl-ana.makeres-branch.asd")
9221        ((#:asd-system-name _ #f) "cl-ana.makeres-branch")))))
9222
9223 (define-public cl-ana.makeres-branch
9224   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-branch))
9225
9226 (define-public sbcl-cl-ana.makeres-utils
9227   (package
9228     (inherit sbcl-cl-ana-boot0)
9229     (name "sbcl-cl-ana.makeres-utils")
9230     (inputs
9231      `(("alexandria" ,sbcl-alexandria)
9232        ("cl-ana.file-utils" ,sbcl-cl-ana.file-utils)
9233        ("cl-ana.fitting" ,sbcl-cl-ana.fitting)
9234        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
9235        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9236        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9237        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9238        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9239        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)
9240        ("cl-ana.map" ,sbcl-cl-ana.map)
9241        ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
9242        ("cl-ana.plotting" ,sbcl-cl-ana.plotting)
9243        ("cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
9244        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
9245        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
9246        ("cl-ana.table" ,sbcl-cl-ana.table)))
9247     (native-inputs
9248      `(("cl-fad" ,sbcl-cl-fad)))
9249     (arguments
9250      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9251        ((#:asd-file _ "") "makeres-utils/cl-ana.makeres-utils.asd")
9252        ((#:asd-system-name _ #f) "cl-ana.makeres-utils")))))
9253
9254 (define-public cl-ana.makeres-utils
9255   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-utils))
9256
9257 (define-public sbcl-cl-ana.statistical-learning
9258   (package
9259     (inherit sbcl-cl-ana-boot0)
9260     (name "sbcl-cl-ana.statistical-learning")
9261     (inputs
9262      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9263        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
9264        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9265        ("cl-ana.linear-algebra" ,sbcl-cl-ana.linear-algebra)
9266        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9267        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9268        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
9269        ("cl-ana.map" ,sbcl-cl-ana.map)
9270        ("cl-ana.statistics" ,sbcl-cl-ana.statistics)))
9271     (native-inputs
9272      `(("cl-fad" ,sbcl-cl-fad)))
9273     (arguments
9274      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9275        ((#:asd-file _ "")
9276         "statistical-learning/cl-ana.statistical-learning.asd")
9277        ((#:asd-system-name _ #f) "cl-ana.statistical-learning")))))
9278
9279 (define-public cl-ana.statistical-learning
9280   (sbcl-package->cl-source-package sbcl-cl-ana.statistical-learning))
9281
9282 (define-public sbcl-cl-ana
9283   (package
9284     (inherit sbcl-cl-ana-boot0)
9285     (name "sbcl-cl-ana")
9286     (inputs
9287      `(("cl-ana.binary-tree" ,sbcl-cl-ana.binary-tree)
9288        ("cl-ana.calculus" ,sbcl-cl-ana.calculus)
9289        ("cl-ana.clos-utils" ,sbcl-cl-ana.clos-utils)
9290        ("cl-ana.csv-table" ,sbcl-cl-ana.csv-table)
9291        ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
9292        ("cl-ana.file-utils" ,sbcl-cl-ana.file-utils)
9293        ("cl-ana.fitting" ,sbcl-cl-ana.fitting)
9294        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9295        ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
9296        ("cl-ana.hdf-table" ,sbcl-cl-ana.hdf-table)
9297        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9298        ("cl-ana.int-char" ,sbcl-cl-ana.int-char)
9299        ("cl-ana.linear-algebra" ,sbcl-cl-ana.linear-algebra)
9300        ("cl-ana.lorentz" ,sbcl-cl-ana.lorentz)
9301        ("cl-ana.map" ,sbcl-cl-ana.map)
9302        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)
9303        ("cl-ana.makeres-block" ,sbcl-cl-ana.makeres-block)
9304        ("cl-ana.makeres-branch" ,sbcl-cl-ana.makeres-branch)
9305        ("cl-ana.makeres-graphviz" ,sbcl-cl-ana.makeres-graphviz)
9306        ("cl-ana.makeres-macro" ,sbcl-cl-ana.makeres-macro)
9307        ("cl-ana.makeres-progress" ,sbcl-cl-ana.makeres-progress)
9308        ("cl-ana.makeres-table" ,sbcl-cl-ana.makeres-table)
9309        ("cl-ana.makeres-utils" ,sbcl-cl-ana.makeres-utils)
9310        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
9311        ("cl-ana.ntuple-table" ,sbcl-cl-ana.ntuple-table)
9312        ("cl-ana.package-utils" ,sbcl-cl-ana.package-utils)
9313        ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
9314        ("cl-ana.plotting" ,sbcl-cl-ana.plotting)
9315        ("cl-ana.quantity" ,sbcl-cl-ana.quantity)
9316        ("cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
9317        ("cl-ana.serialization" ,sbcl-cl-ana.serialization)
9318        ("cl-ana.statistics" ,sbcl-cl-ana.statistics)
9319        ("cl-ana.statistical-learning" ,sbcl-cl-ana.statistical-learning)
9320        ("cl-ana.table" ,sbcl-cl-ana.table)
9321        ("cl-ana.table-utils" ,sbcl-cl-ana.table-utils)
9322        ("cl-ana.table-viewing" ,sbcl-cl-ana.table-viewing)
9323        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
9324        ("libffi" ,libffi)))
9325     (native-inputs
9326      `(("cl-fad" ,sbcl-cl-fad)))
9327     (arguments
9328      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9329        ((#:asd-file _ "") "cl-ana.asd")
9330        ((#:asd-system-name _ #f) "cl-ana")))))
9331
9332 (define-public cl-ana
9333   (sbcl-package->cl-source-package sbcl-cl-ana))
9334
9335 (define-public sbcl-archive
9336   (let ((commit "631271c091ed02994bec3980cb288a2cf32c7cdc")
9337         (revision "1"))
9338     (package
9339       (name "sbcl-archive")
9340       (version (git-version "0.9" revision commit))
9341       (source (origin
9342                 (method git-fetch)
9343                 (uri (git-reference
9344                       (url "https://github.com/sharplispers/archive.git")
9345                       (commit commit)))
9346                 (file-name (git-file-name name version))
9347                 (sha256
9348                  (base32
9349                   "0pvsc9fmybx7rxd0kmzq4shi6hszdpwdc1sfy7jwyfxf8n3hnv4p"))))
9350       (build-system asdf-build-system/sbcl)
9351       (inputs
9352        `(("cl-fad" ,sbcl-cl-fad)
9353          ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
9354       (synopsis "Common Lisp library for tar and cpio archives")
9355       (description
9356        "This is a Common Lisp library to read and write disk-based file
9357 archives such as those generated by the tar and cpio programs on Unix.")
9358       (home-page "https://github.com/sharplispers/archive")
9359       (license license:bsd-3))))
9360
9361 (define-public cl-archive
9362   (sbcl-package->cl-source-package sbcl-archive))
9363
9364 (define-public ecl-archive
9365   (sbcl-package->ecl-package sbcl-archive))
9366
9367 (define-public sbcl-misc-extensions
9368   (let ((commit "101c05112bf2f1e1bbf527396822d2f50ca6327a")
9369         (revision "1"))
9370     (package
9371       (name "sbcl-misc-extensions")
9372       (version (git-version "3.3" revision commit))
9373       (source
9374        (origin
9375          (method git-fetch)
9376          (uri (git-reference
9377                (url "https://gitlab.common-lisp.net/misc-extensions/devel.git")
9378                (commit commit)))
9379          (file-name (git-file-name name version))
9380          (sha256
9381           (base32
9382            "0gz5f4p70qzilnxsnf5lih2n9m4wjcw8hlw4w8mpn9jyhyppyyv0"))))
9383       (build-system asdf-build-system/sbcl)
9384       (synopsis "Collection of small macros and extensions for Common Lisp")
9385       (description
9386        "This project is intended as a catchall for small, general-purpose
9387 extensions to Common Lisp.  It contains:
9388
9389 @itemize
9390 @item @code{new-let}, a macro that combines and generalizes @code{let},
9391 @code{let*} and @code{multiple-value-bind},
9392 @item @code{gmap}, an iteration macro that generalizes @code{map}.
9393 @end itemize\n")
9394       (home-page "https://common-lisp.net/project/misc-extensions/")
9395       (license license:public-domain))))
9396
9397 (define-public cl-misc-extensions
9398   (sbcl-package->cl-source-package sbcl-misc-extensions))
9399
9400 (define-public ecl-misc-extensions
9401   (sbcl-package->ecl-package sbcl-misc-extensions))
9402
9403 (define-public sbcl-mt19937
9404   (package
9405     (name "sbcl-mt19937")
9406     (version "1.1")
9407     (source
9408      (origin
9409        (method url-fetch)
9410        (uri (string-append "https://common-lisp.net/project/asdf-packaging/"
9411                            "mt19937-latest.tar.gz"))
9412        (sha256
9413         (base32
9414          "1iw636b0iw5ygkv02y8i41lh7xj0acglv0hg5agryn0zzi2nf1xv"))))
9415     (build-system asdf-build-system/sbcl)
9416     (synopsis "Mersenne Twister pseudo-random number generator")
9417     (description
9418      "MT19937 is a portable Mersenne Twister pseudo-random number generator
9419 for Common Lisp.")
9420     (home-page "https://www.cliki.net/mt19937")
9421     (license license:public-domain)))
9422
9423 (define-public cl-mt19937
9424   (sbcl-package->cl-source-package sbcl-mt19937))
9425
9426 (define-public ecl-mt19937
9427   (sbcl-package->ecl-package sbcl-mt19937))
9428
9429 (define-public sbcl-fset
9430   (let ((commit "6d2f9ded8934d2b42f2571a0ba5bda091037d852")
9431         (revision "1"))
9432     (package
9433       (name "sbcl-fset")
9434       (version (git-version "1.3.2" revision commit))
9435       (source
9436        (origin
9437          (method git-fetch)
9438          (uri (git-reference
9439                (url "https://github.com/slburson/fset")
9440                (commit commit)))
9441          (file-name (git-file-name name version))
9442          (sha256
9443           (base32
9444            "127acblwrbqicx47h6sgvknz1cqyfn8p4xkhkn1m7hxh8w5gk1zy"))
9445          (snippet '(begin
9446                      ;; Remove obsolete copy of system definition.
9447                      (delete-file "Code/fset.asd")
9448                      #t))))
9449       (build-system asdf-build-system/sbcl)
9450       (inputs
9451        `(("misc-extensions" ,sbcl-misc-extensions)
9452          ("mt19937" ,sbcl-mt19937)
9453          ("named-readtables" ,sbcl-named-readtables)))
9454       (synopsis "Functional set-theoretic collections library")
9455       (description
9456        "FSet is a functional set-theoretic collections library for Common Lisp.
9457 Functional means that all update operations return a new collection rather than
9458 modifying an existing one in place.  Set-theoretic means that collections may
9459 be nested arbitrarily with no additional programmer effort; for instance, sets
9460 may contain sets, maps may be keyed by sets, etc.")
9461       (home-page "https://common-lisp.net/project/fset/Site/index.html")
9462       (license license:llgpl))))
9463
9464 (define-public cl-fset
9465   (sbcl-package->cl-source-package sbcl-fset))
9466
9467 (define-public sbcl-cl-cont
9468   (let ((commit "fc1fa7e6eb64894fdca13e688e6015fad5290d2a")
9469         (revision "1"))
9470     (package
9471       (name "sbcl-cl-cont")
9472       (version (git-version "0.3.8" revision commit))
9473       (source
9474        (origin
9475          (method git-fetch)
9476          (uri (git-reference
9477                (url "https://gitlab.common-lisp.net/cl-cont/cl-cont.git")
9478                (commit commit)))
9479          (file-name (git-file-name name version))
9480          (sha256
9481           (base32
9482            "1zf8zvb0i6jm3hhfks4w74hibm6avgc6f9s1qwgjrn2bcik8lrvz"))))
9483       (build-system asdf-build-system/sbcl)
9484       (inputs
9485        `(("alexandria" ,sbcl-alexandria)
9486          ("closer-mop" ,sbcl-closer-mop)))
9487       (native-inputs
9488        `(("rt" ,sbcl-rt)))
9489       (synopsis "Delimited continuations for Common Lisp")
9490       (description
9491        "This is a library that implements delimited continuations by
9492 transforming Common Lisp code to continuation passing style.")
9493       (home-page "https://common-lisp.net/project/cl-cont/")
9494       (license license:llgpl))))
9495
9496 (define-public cl-cont
9497   (sbcl-package->cl-source-package sbcl-cl-cont))
9498
9499 (define-public ecl-cl-cont
9500   (sbcl-package->ecl-package sbcl-cl-cont))
9501
9502 (define-public sbcl-cl-coroutine
9503   (let ((commit "de098f8d5debd8b14ef6864b5bdcbbf5ddbcfd72")
9504         (revision "1"))
9505     (package
9506       (name "sbcl-cl-coroutine")
9507       (version (git-version "0.1" revision commit))
9508       (source
9509        (origin
9510          (method git-fetch)
9511          (uri (git-reference
9512                (url "https://github.com/takagi/cl-coroutine.git")
9513                (commit commit)))
9514          (file-name (git-file-name name version))
9515          (sha256
9516           (base32
9517            "1cqdhdjxffgfs116l1swjlsmcbly0xgcgrckvaajd566idj9yj4l"))))
9518       (build-system asdf-build-system/sbcl)
9519       (inputs
9520        `(("alexandria" ,sbcl-alexandria)
9521          ("cl-cont" ,sbcl-cl-cont)))
9522       (native-inputs
9523        `(("prove" ,sbcl-prove)))
9524       (arguments
9525        `(;; TODO: Fix the tests. They fail with:
9526          ;; "Component CL-COROUTINE-ASD::CL-COROUTINE-TEST not found"
9527          #:tests? #f
9528          #:phases
9529          (modify-phases %standard-phases
9530            (add-after 'unpack 'fix-tests
9531              (lambda _
9532                (substitute* "cl-coroutine-test.asd"
9533                  (("cl-test-more")
9534                   "prove"))
9535                #t)))))
9536       (synopsis "Coroutine library for Common Lisp")
9537       (description
9538        "This is a coroutine library for Common Lisp implemented using the
9539 continuations of the @code{cl-cont} library.")
9540       (home-page "https://github.com/takagi/cl-coroutine")
9541       (license license:llgpl))))
9542
9543 (define-public cl-coroutine
9544   (sbcl-package->cl-source-package sbcl-cl-coroutine))
9545
9546 (define-public ecl-cl-coroutine
9547   (sbcl-package->ecl-package sbcl-cl-coroutine))
9548
9549 (define-public sbcl-vom
9550   (let ((commit "1aeafeb5b74c53741b79497e0ef4acf85c92ff24")
9551         (revision "1"))
9552     (package
9553       (name "sbcl-vom")
9554       (version (git-version "0.1.4" revision commit))
9555       (source
9556        (origin
9557          (method git-fetch)
9558          (uri (git-reference
9559                (url "https://github.com/orthecreedence/vom.git")
9560                (commit commit)))
9561          (file-name (git-file-name name version))
9562          (sha256
9563           (base32
9564            "0536kppj76ax4lrxhv42npkfjsmx45km2g439vf9jmw3apinz9cy"))))
9565       (build-system asdf-build-system/sbcl)
9566       (synopsis "Tiny logging utility for Common Lisp")
9567       (description
9568        "Vom is a logging library for Common Lisp.  It's goal is to be useful
9569 and small.  It does not provide a lot of features as other loggers do, but
9570 has a small codebase that's easy to understand and use.")
9571       (home-page "https://github.com/orthecreedence/vom")
9572       (license license:expat))))
9573
9574 (define-public cl-vom
9575   (sbcl-package->cl-source-package sbcl-vom))
9576
9577 (define-public ecl-vom
9578   (sbcl-package->ecl-package sbcl-vom))
9579
9580 (define-public sbcl-cl-libuv
9581   (let ((commit "32100c023c518038d0670a103eaa4d50dd785d29")
9582         (revision "1"))
9583     (package
9584       (name "sbcl-cl-libuv")
9585       (version (git-version "0.1.6" revision commit))
9586       (source
9587        (origin
9588          (method git-fetch)
9589          (uri (git-reference
9590                (url "https://github.com/orthecreedence/cl-libuv.git")
9591                (commit commit)))
9592          (file-name (git-file-name name version))
9593          (sha256
9594           (base32
9595            "1kwix4si8a8hza34ab2k7whrh7z0yrmx39v2wc3qblv9m244jkh1"))))
9596       (build-system asdf-build-system/sbcl)
9597       (inputs
9598        `(("alexandria" ,sbcl-alexandria)
9599          ("cffi" ,sbcl-cffi)
9600          ("cffi-grovel" ,sbcl-cffi-grovel)
9601          ("libuv" ,libuv)))
9602       (arguments
9603        `(#:phases
9604          (modify-phases %standard-phases
9605            (add-after 'unpack 'fix-paths
9606              (lambda* (#:key inputs #:allow-other-keys)
9607                (substitute* "lib.lisp"
9608                  (("/usr/lib/libuv.so")
9609                   (string-append (assoc-ref inputs "libuv")
9610                                  "/lib/libuv.so")))
9611                #t))
9612            (add-after 'fix-paths 'fix-system-definition
9613              (lambda _
9614                (substitute* "cl-libuv.asd"
9615                  (("#:cffi #:alexandria")
9616                   "#:cffi #:cffi-grovel #:alexandria"))
9617                #t)))))
9618       (synopsis "Common Lisp bindings to libuv")
9619       (description
9620        "This library provides low-level libuv bindings for Common Lisp.")
9621       (home-page "https://github.com/orthecreedence/cl-libuv")
9622       (license license:expat))))
9623
9624 (define-public cl-libuv
9625   (sbcl-package->cl-source-package sbcl-cl-libuv))
9626
9627 (define-public ecl-cl-libuv
9628   (sbcl-package->ecl-package sbcl-cl-libuv))
9629
9630 (define-public sbcl-cl-async-base
9631   (let ((commit "f6423e44404a44434d803605e0d2e17199158e28")
9632         (revision "1"))
9633     (package
9634       (name "sbcl-cl-async-base")
9635       (version (git-version "0.6.1" revision commit))
9636       (source
9637        (origin
9638          (method git-fetch)
9639          (uri (git-reference
9640                (url "https://github.com/orthecreedence/cl-async.git")
9641                (commit commit)))
9642          (file-name (git-file-name name version))
9643          (sha256
9644           (base32
9645            "11xi9dxb8mjgwzrkj88i0xkgk26z9w9ddxzbv6xsvfc1d4x5cf4x"))))
9646       (build-system asdf-build-system/sbcl)
9647       (inputs
9648        `(("bordeaux-threads" ,sbcl-bordeaux-threads)
9649          ("cffi" ,sbcl-cffi)
9650          ("cl-libuv" ,sbcl-cl-libuv)))
9651       (arguments
9652        `(#:asd-file "cl-async.asd"))
9653       (synopsis "Base system for cl-async")
9654       (description
9655        "Cl-async is a library for general purpose, non-blocking programming in
9656 Common Lisp.  It uses the libuv library as backend.")
9657       (home-page "https://orthecreedence.github.io/cl-async/")
9658       (license license:expat))))
9659
9660 (define-public cl-async-base
9661   (sbcl-package->cl-source-package sbcl-cl-async-base))
9662
9663 (define-public ecl-cl-async-base
9664   (sbcl-package->ecl-package sbcl-cl-async-base))
9665
9666 (define-public sbcl-cl-async-util
9667   (package
9668     (inherit sbcl-cl-async-base)
9669     (name "sbcl-cl-async-util")
9670     (inputs
9671      `(("bordeaux-threads" ,sbcl-bordeaux-threads)
9672        ("cffi" ,sbcl-cffi)
9673        ("cl-async-base" ,sbcl-cl-async-base)
9674        ("cl-libuv" ,sbcl-cl-libuv)
9675        ("cl-ppcre" ,sbcl-cl-ppcre)
9676        ("fast-io" ,sbcl-fast-io)
9677        ("vom" ,sbcl-vom)))
9678     (synopsis "Internal utilities for cl-async")))
9679
9680 (define-public cl-async-util
9681   (sbcl-package->cl-source-package sbcl-cl-async-util))
9682
9683 (define-public ecl-cl-async-util
9684   (sbcl-package->ecl-package sbcl-cl-async-util))
9685
9686 (define-public sbcl-cl-async
9687   (package
9688     (inherit sbcl-cl-async-base)
9689     (name "sbcl-cl-async")
9690     (inputs
9691      `(("babel" ,sbcl-babel)
9692        ("cffi" ,sbcl-cffi)
9693        ("cl-async-base" ,sbcl-cl-async-base)
9694        ("cl-async-util" ,sbcl-cl-async-util)
9695        ("cl-libuv" ,sbcl-cl-libuv)
9696        ("cl-ppcre" ,sbcl-cl-ppcre)
9697        ("static-vectors" ,sbcl-static-vectors)
9698        ("trivial-features" ,sbcl-trivial-features)
9699        ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
9700     (synopsis "Asynchronous operations for Common Lisp")))
9701
9702 (define-public cl-async
9703   (sbcl-package->cl-source-package sbcl-cl-async))
9704
9705 (define-public ecl-cl-async
9706   (sbcl-package->ecl-package sbcl-cl-async))
9707
9708 (define-public sbcl-cl-async-repl
9709   (package
9710     (inherit sbcl-cl-async-base)
9711     (name "sbcl-cl-async-repl")
9712     (inputs
9713      `(("bordeaux-threads" ,sbcl-bordeaux-threads)
9714        ("cl-async" ,sbcl-cl-async)))
9715     (arguments
9716      (substitute-keyword-arguments (package-arguments sbcl-cl-async-base)
9717        ((#:asd-file _ "") "cl-async-repl.asd")))
9718     (synopsis "REPL integration for cl-async")))
9719
9720 (define-public cl-async-repl
9721   (sbcl-package->cl-source-package sbcl-cl-async-repl))
9722
9723 (define-public ecl-cl-async-repl
9724   (sbcl-package->ecl-package sbcl-cl-async-repl))
9725
9726 (define-public sbcl-cl-async-ssl
9727   (package
9728     (inherit sbcl-cl-async-base)
9729     (name "sbcl-cl-async-ssl")
9730     (inputs
9731      `(("cffi" ,sbcl-cffi)
9732        ("cl-async" ,sbcl-cl-async)
9733        ("openssl" ,openssl)
9734        ("vom" ,sbcl-vom)))
9735     (arguments
9736      (substitute-keyword-arguments (package-arguments sbcl-cl-async-base)
9737        ((#:asd-file _ "") "cl-async-ssl.asd")
9738        ((#:phases phases '%standard-phases)
9739         `(modify-phases ,phases
9740            (add-after 'unpack 'fix-paths
9741              (lambda* (#:key inputs #:allow-other-keys)
9742                (substitute* "src/ssl/package.lisp"
9743                  (("libcrypto\\.so")
9744                   (string-append (assoc-ref inputs "openssl")
9745                                  "/lib/libcrypto.so"))
9746                  (("libssl\\.so")
9747                   (string-append (assoc-ref inputs "openssl")
9748                                  "/lib/libssl.so")))
9749                #t))))))
9750     (synopsis "SSL wrapper around cl-async socket implementation")))
9751
9752 (define-public cl-async-ssl
9753   (sbcl-package->cl-source-package sbcl-cl-async-ssl))
9754
9755 (define-public ecl-cl-async-ssl
9756   (sbcl-package->ecl-package sbcl-cl-async-ssl))
9757
9758 (define-public sbcl-blackbird
9759   (let ((commit "d361f81c1411dec07f6c2dcb11c78f7aea9aaca8")
9760         (revision "1"))
9761     (package
9762       (name "sbcl-blackbird")
9763       (version (git-version "0.5.2" revision commit))
9764       (source
9765        (origin
9766          (method git-fetch)
9767          (uri (git-reference
9768                (url "https://github.com/orthecreedence/blackbird.git")
9769                (commit commit)))
9770          (file-name (git-file-name name version))
9771          (sha256
9772           (base32
9773            "0xfds5yaya64arzr7w1x38karyz11swzbhxx1afldpradj9dh19c"))))
9774       (build-system asdf-build-system/sbcl)
9775       (inputs
9776        `(("vom" ,sbcl-vom)))
9777       (native-inputs
9778        `(("cl-async" ,sbcl-cl-async)
9779          ("fiveam" ,sbcl-fiveam)))
9780       (synopsis "Promise implementation for Common Lisp")
9781       (description
9782        "This is a standalone promise implementation for Common Lisp.  It is
9783 the successor to the now-deprecated cl-async-future project.")
9784       (home-page "https://orthecreedence.github.io/blackbird/")
9785       (license license:expat))))
9786
9787 (define-public cl-blackbird
9788   (sbcl-package->cl-source-package sbcl-blackbird))
9789
9790 (define-public ecl-blackbird
9791   (sbcl-package->ecl-package sbcl-blackbird))
9792
9793 (define-public sbcl-cl-async-future
9794   (let ((commit "ee36c22a69a9516407458d2ed8b475f1fc473959")
9795         (revision "1"))
9796     (package
9797       (name "sbcl-cl-async-future")
9798       (version (git-version "0.4.4.1" revision commit))
9799       (source
9800        (origin
9801          (method git-fetch)
9802          (uri (git-reference
9803                (url "https://github.com/orthecreedence/cl-async-future.git")
9804                (commit commit)))
9805          (file-name (git-file-name name version))
9806          (sha256
9807           (base32
9808            "0z0sc7qlzzxk99f4l26zp6rai9kv0kj0f599sxai5s44p17zbbvh"))))
9809       (build-system asdf-build-system/sbcl)
9810       (inputs
9811        `(("blackbird" ,sbcl-blackbird)))
9812       (native-inputs
9813        `(("cl-async" ,sbcl-cl-async)
9814          ("eos" ,sbcl-eos)))
9815       (synopsis "Futures implementation for Common Lisp")
9816       (description
9817        "This is futures implementation for Common Lisp.  It plugs in nicely
9818 to cl-async.")
9819       (home-page "https://orthecreedence.github.io/cl-async/future")
9820       (license license:expat))))
9821
9822 (define-public cl-async-future
9823   (sbcl-package->cl-source-package sbcl-cl-async-future))
9824
9825 (define-public ecl-cl-async-future
9826   (sbcl-package->ecl-package sbcl-cl-async-future))
9827
9828 (define-public sbcl-green-threads
9829   (let ((commit "fff5ebecb441a37e5c511773716aafd84a3c5840")
9830         (revision "1"))
9831     (package
9832       (name "sbcl-green-threads")
9833       (version (git-version "0.3" revision commit))
9834       (source
9835        (origin
9836          (method git-fetch)
9837          (uri (git-reference
9838                (url "https://github.com/thezerobit/green-threads.git")
9839                (commit commit)))
9840          (file-name (git-file-name name version))
9841          (sha256
9842           (base32
9843            "1czw7nr0dwfps76h8hjvglk1wdh53yqbfbvv30whwbgqx33iippz"))))
9844       (build-system asdf-build-system/sbcl)
9845       (inputs
9846        `(("cl-async-future" ,sbcl-cl-async-future)
9847          ("cl-cont" ,sbcl-cl-cont)))
9848       (native-inputs
9849        `(("prove" ,sbcl-prove)))
9850       (arguments
9851        `(;; TODO: Fix the tests. They fail with:
9852          ;; "The function BLACKBIRD::PROMISE-VALUES is undefined"
9853          #:tests? #f
9854          #:phases
9855          (modify-phases %standard-phases
9856            (add-after 'unpack 'fix-tests
9857              (lambda _
9858                (substitute* "green-threads-test.asd"
9859                  (("cl-test-more")
9860                   "prove"))
9861                #t)))))
9862       (synopsis "Cooperative multitasking library for Common Lisp")
9863       (description
9864        "This library allows for cooperative multitasking with help of cl-cont
9865 for continuations.  It tries to mimic the API of bordeaux-threads as much as
9866 possible.")
9867       (home-page "https://github.com/thezerobit/green-threads")
9868       (license license:bsd-3))))
9869
9870 (define-public cl-green-threads
9871   (sbcl-package->cl-source-package sbcl-green-threads))
9872
9873 (define-public ecl-green-threads
9874   (sbcl-package->ecl-package sbcl-green-threads))
9875
9876 (define-public sbcl-cl-base32
9877   (let ((commit "8cdee06fab397f7b0a19583b57e7f0c98405be85")
9878         (revision "1"))
9879     (package
9880       (name "sbcl-cl-base32")
9881       (version (git-version "0.1" revision commit))
9882       (source
9883        (origin
9884          (method git-fetch)
9885          (uri (git-reference
9886                (url "https://github.com/hargettp/cl-base32.git")
9887                (commit commit)))
9888          (file-name (git-file-name name version))
9889          (sha256
9890           (base32 "17jrng8jb05d64ggyd11hp308c2fl5drvf9g175blgrkkl8l4mf8"))))
9891       (build-system asdf-build-system/sbcl)
9892       (native-inputs
9893        `(("lisp-unit" ,sbcl-lisp-unit)))
9894       (synopsis "Common Lisp library for base32 encoding and decoding")
9895       (description
9896        "This package provides functions for base32 encoding and decoding as
9897 defined in RFC4648.")
9898       (home-page "https://github.com/hargettp/cl-base32")
9899       (license license:expat))))
9900
9901 (define-public cl-base32
9902   (sbcl-package->cl-source-package sbcl-cl-base32))
9903
9904 (define-public ecl-cl-base32
9905   (sbcl-package->ecl-package sbcl-cl-base32))
9906
9907 (define-public sbcl-cl-z85
9908   (let ((commit "85b3951a9cfa2603acb6aee15567684f9a108098")
9909         (revision "1"))
9910     (package
9911       (name "sbcl-cl-z85")
9912       (version (git-version "1.0" revision commit))
9913       (source
9914        (origin
9915          (method git-fetch)
9916          (uri (git-reference
9917                (url "https://github.com/glv2/cl-z85.git")
9918                (commit commit)))
9919          (file-name (git-file-name name version))
9920          (sha256
9921           (base32 "0r27pidjaxbm7k1rr90nnajwl5xm2kp65g1fv0fva17lzy45z1mp"))))
9922       (build-system asdf-build-system/sbcl)
9923       (native-inputs
9924        `(("cl-octet-streams" ,sbcl-cl-octet-streams)
9925          ("fiveam" ,sbcl-fiveam)))
9926       (synopsis "Common Lisp library for Z85 encoding and decoding")
9927       (description
9928        "This package provides functions to encode or decode byte vectors or
9929 byte streams using the Z85 format, which is a base-85 encoding used by
9930 ZeroMQ.")
9931       (home-page "https://github.com/glv2/cl-z85")
9932       (license license:gpl3+))))
9933
9934 (define-public cl-z85
9935   (sbcl-package->cl-source-package sbcl-cl-z85))
9936
9937 (define-public ecl-cl-z85
9938   (sbcl-package->ecl-package sbcl-cl-z85))
9939
9940 (define-public sbcl-ltk
9941   (package
9942     (name "sbcl-ltk")
9943     (version "0.992")
9944     (source
9945      (origin
9946        (method git-fetch)
9947        (uri (git-reference
9948              (url "https://github.com/herth/ltk.git")
9949              (commit version)))
9950        (file-name (git-file-name name version))
9951        (sha256
9952         (base32 "13l2q4mskzilya9xh5wy2xvy30lwn104bd8wrq6ifds56r82iy3x"))))
9953     (build-system asdf-build-system/sbcl)
9954     (inputs
9955      `(("imagemagick" ,imagemagick)
9956        ("tk" ,tk)))
9957     (arguments
9958      `(#:asd-file "ltk/ltk.asd"
9959        #:tests? #f
9960        #:phases (modify-phases %standard-phases
9961                   (add-after 'unpack 'fix-paths
9962                     (lambda* (#:key inputs #:allow-other-keys)
9963                       (substitute* "ltk/ltk.lisp"
9964                         (("#-freebsd \"wish\"")
9965                          (string-append "#-freebsd \""
9966                                         (assoc-ref inputs "tk")
9967                                         "/bin/wish\""))
9968                         (("do-execute \"convert\"")
9969                          (string-append "do-execute \""
9970                                         (assoc-ref inputs "imagemagick")
9971                                         "/bin/convert\"")))
9972                       #t)))))
9973     (synopsis "Common Lisp bindings for the Tk GUI toolkit")
9974     (description
9975      "LTK is a Common Lisp binding for the Tk graphics toolkit.  It is written
9976 in pure Common Lisp and does not require any Tk knowledge for its usage.")
9977     (home-page "http://www.peter-herth.de/ltk/")
9978     (license license:llgpl)))
9979
9980 (define-public cl-ltk
9981   (sbcl-package->cl-source-package sbcl-ltk))
9982
9983 (define-public ecl-ltk
9984   (sbcl-package->ecl-package sbcl-ltk))
9985
9986 (define-public sbcl-ltk-mw
9987   (package
9988     (inherit sbcl-ltk)
9989     (name "sbcl-ltk-mw")
9990     (inputs
9991      `(("ltk" ,sbcl-ltk)))
9992     (arguments
9993      (substitute-keyword-arguments (package-arguments sbcl-ltk)
9994        ((#:asd-file _) "ltk/ltk-mw.asd")
9995        ((#:phases _) '%standard-phases)))
9996     (synopsis "Extra widgets for LTK")
9997     (description
9998      "This is a collection of higher-level widgets built on top of LTK.")))
9999
10000 (define-public cl-ltk-mw
10001   (sbcl-package->cl-source-package sbcl-ltk-mw))
10002
10003 (define-public ecl-ltk-mw
10004   (sbcl-package->ecl-package sbcl-ltk-mw))
10005
10006 (define-public sbcl-ltk-remote
10007   (package
10008     (inherit sbcl-ltk)
10009     (name "sbcl-ltk-remote")
10010     (inputs
10011      `(("ltk" ,sbcl-ltk)))
10012     (arguments
10013      (substitute-keyword-arguments (package-arguments sbcl-ltk)
10014        ((#:asd-file _) "ltk/ltk-remote.asd")
10015        ((#:phases _) '%standard-phases)))
10016     (synopsis "Remote GUI support for LTK")
10017     (description
10018      "This LTK extension allows the GUI to be displayed on a computer different
10019 from the one running the Lisp program by using a TCP connection.")))
10020
10021 (define-public cl-ltk-remote
10022   (sbcl-package->cl-source-package sbcl-ltk-remote))
10023
10024 (define-public sbcl-cl-lex
10025   (let ((commit "f2dbbe25ef553005fb402d9a6203180c3fa1093b")
10026         (revision "1"))
10027     (package
10028       (name "sbcl-cl-lex")
10029       (version (git-version "1.1.3" revision commit))
10030       (source
10031        (origin
10032          (method git-fetch)
10033          (uri (git-reference
10034                (url "https://github.com/djr7C4/cl-lex.git")
10035                (commit commit)))
10036          (file-name (git-file-name name version))
10037          (sha256
10038           (base32 "1kg50f76bfpfxcv4dfivq1n9a0xlsra2ajb0vd68lxwgbidgyc2y"))))
10039       (build-system asdf-build-system/sbcl)
10040       (inputs
10041        `(("cl-ppcre" ,sbcl-cl-ppcre)))
10042       (synopsis "Common Lisp macros for generating lexical analyzers")
10043       (description
10044        "This is a Common Lisp library providing a set of macros for generating
10045 lexical analyzers automatically.  The lexers generated using @code{cl-lex} can
10046 be used with @code{cl-yacc}.")
10047       (home-page "https://github.com/djr7C4/cl-lex")
10048       (license license:gpl3))))
10049
10050 (define-public cl-lex
10051   (sbcl-package->cl-source-package sbcl-cl-lex))
10052
10053 (define-public ecl-cl-lex
10054   (sbcl-package->ecl-package sbcl-cl-lex))
10055
10056 (define-public sbcl-clunit2
10057   (let ((commit "5e28343734eb9b7aee39306a614af92c1062d50b")
10058         (revision "1"))
10059     (package
10060       (name "sbcl-clunit2")
10061       (version (git-version "0.2.4" revision commit))
10062       (source
10063        (origin
10064          (method git-fetch)
10065          (uri (git-reference
10066                (url "https://notabug.org/cage/clunit2.git")
10067                (commit commit)))
10068          (file-name (git-file-name name version))
10069          (sha256
10070           (base32 "1ngiapfki6nm8a555mzhb5p7ch79i3w665za5bmb5j7q34fy80vw"))))
10071       (build-system asdf-build-system/sbcl)
10072       (synopsis "Unit testing framework for Common Lisp")
10073       (description
10074        "CLUnit is a Common Lisp unit testing framework.  It is designed to be
10075 easy to use so that you can quickly start testing.")
10076       (home-page "https://notabug.org/cage/clunit2")
10077       (license license:expat))))
10078
10079 (define-public cl-clunit2
10080   (sbcl-package->cl-source-package sbcl-clunit2))
10081
10082 (define-public ecl-clunit2
10083   (sbcl-package->ecl-package sbcl-clunit2))
10084
10085 (define-public sbcl-cl-colors2
10086   (let ((commit "795aedee593b095fecde574bd999b520dd03ed24")
10087         (revision "1"))
10088     (package
10089       (name "sbcl-cl-colors2")
10090       (version (git-version "0.2.1" revision commit))
10091       (source
10092        (origin
10093          (method git-fetch)
10094          (uri (git-reference
10095                (url "https://notabug.org/cage/cl-colors2.git")
10096                (commit commit)))
10097          (file-name (git-file-name name version))
10098          (sha256
10099           (base32 "0hlyf4h5chkjdp9armla5w4kw5acikk159sym7y8c4jbjp9x47ih"))))
10100       (build-system asdf-build-system/sbcl)
10101       (native-inputs
10102        `(("clunit2" ,sbcl-clunit2)))
10103       (inputs
10104        `(("alexandria" ,sbcl-alexandria)
10105          ("cl-ppcre" ,sbcl-cl-ppcre)))
10106       (synopsis "Color library for Common Lisp")
10107       (description
10108        "This is a very simple color library for Common Lisp, providing:
10109
10110 @itemize
10111 @item Types for representing colors in HSV and RGB spaces.
10112 @item Simple conversion functions between the above types (and also
10113 hexadecimal representation for RGB).
10114 @item Some predefined colors (currently X11 color names -- of course
10115 the library does not depend on X11).
10116 @end itemize\n")
10117       (home-page "https://notabug.org/cage/cl-colors2")
10118       (license license:boost1.0))))
10119
10120 (define-public cl-colors2
10121   (sbcl-package->cl-source-package sbcl-cl-colors2))
10122
10123 (define-public ecl-cl-colors2
10124   (sbcl-package->ecl-package sbcl-cl-colors2))
10125
10126 (define-public sbcl-cl-jpeg
10127   (let ((commit "ec557038128df6895fbfb743bfe8faf8ec2534af")
10128         (revision "1"))
10129     (package
10130       (name "sbcl-cl-jpeg")
10131       (version (git-version "2.8" revision commit))
10132       (source
10133        (origin
10134          (method git-fetch)
10135          (uri (git-reference
10136                (url "https://github.com/sharplispers/cl-jpeg.git")
10137                (commit commit)))
10138          (file-name (git-file-name name version))
10139          (sha256
10140           (base32 "1bkkiqz8fqldlj1wbmrccjsvxcwj98h6s4b6gslr3cg2wmdv5xmy"))))
10141       (build-system asdf-build-system/sbcl)
10142       (synopsis "JPEG image library for Common Lisp")
10143       (description
10144        "This is a baseline JPEG codec written in Common Lisp.  It can be used
10145 for reading and writing JPEG image files.")
10146       (home-page "https://github.com/sharplispers/cl-jpeg")
10147       (license license:bsd-3))))
10148
10149 (define-public cl-jpeg
10150   (sbcl-package->cl-source-package sbcl-cl-jpeg))
10151
10152 (define-public ecl-cl-jpeg
10153   (sbcl-package->ecl-package sbcl-cl-jpeg))
10154
10155 (define-public sbcl-nodgui
10156   (let ((commit "bc59ed9b787dfc9e68ae3bd7f7e8507c5c619212")
10157         (revision "1"))
10158     (package
10159       (name "sbcl-nodgui")
10160       (version (git-version "0.0.5" revision commit))
10161       (source
10162        (origin
10163          (method git-fetch)
10164          (uri (git-reference
10165                (url "https://notabug.org/cage/nodgui.git")
10166                (commit commit)))
10167          (file-name (git-file-name name version))
10168          (sha256
10169           (base32 "0xx0dk54d882i598ydnwmy7mnfk0b7vib3ddsgpqxhjck1rwq8l8"))))
10170       (build-system asdf-build-system/sbcl)
10171       (inputs
10172        `(("alexandria" ,sbcl-alexandria)
10173          ("bordeaux-threads" ,sbcl-bordeaux-threads)
10174          ("cl-colors2" ,sbcl-cl-colors2)
10175          ("cl-jpeg" ,sbcl-cl-jpeg)
10176          ("cl-lex" ,sbcl-cl-lex)
10177          ("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)
10178          ("cl-unicode" ,sbcl-cl-unicode)
10179          ("cl-yacc" ,sbcl-cl-yacc)
10180          ("clunit2" ,sbcl-clunit2)
10181          ("named-readtables" ,sbcl-named-readtables)
10182          ("parse-number" ,sbcl-parse-number)
10183          ("tk" ,tk)))
10184       (arguments
10185        `(#:phases (modify-phases %standard-phases
10186                     (add-after 'unpack 'fix-paths
10187                       (lambda* (#:key inputs #:allow-other-keys)
10188                         (substitute* "src/wish-communication.lisp"
10189                           (("#-freebsd \"wish\"")
10190                            (string-append "#-freebsd \""
10191                                           (assoc-ref inputs "tk")
10192                                           "/bin/wish\"")))
10193                         #t)))))
10194       (synopsis "Common Lisp bindings for the Tk GUI toolkit")
10195       (description
10196        "Nodgui (@emph{No Drama GUI}) is a Common Lisp binding for the Tk GUI
10197 toolkit.  It also provides a few additional widgets more than the standard Tk
10198 ones.")
10199       (home-page "https://www.autistici.org/interzona/nodgui.html")
10200       (license license:llgpl))))
10201
10202 (define-public cl-nodgui
10203   (sbcl-package->cl-source-package sbcl-nodgui))
10204
10205 (define-public ecl-nodgui
10206   (sbcl-package->ecl-package sbcl-nodgui))
10207
10208 (define-public sbcl-salza2
10209   (package
10210     (name "sbcl-salza2")
10211     (version "2.0.9")
10212     (source
10213      (origin
10214        (method git-fetch)
10215        (uri (git-reference
10216              (url "https://github.com/xach/salza2.git")
10217              (commit (string-append "release-" version))))
10218        (file-name (git-file-name name version))
10219        (sha256
10220         (base32 "0p38rj4gq7j5k807php7hrz7l2zyyfshv8i9yms7i8lkgg3433ki"))))
10221     (build-system asdf-build-system/sbcl)
10222     (synopsis "Common Lisp library for zlib, deflate and gzip compression")
10223     (description
10224      "Salza2 is a Common Lisp library for creating compressed data in the zlib,
10225 deflate, or gzip data formats, described in RFC 1950, RFC 1951, and RFC 1952,
10226 respectively.")
10227     (home-page "https://www.xach.com/lisp/salza2/")
10228     (license license:bsd-2)))
10229
10230 (define-public cl-salza2
10231   (sbcl-package->cl-source-package sbcl-salza2))
10232
10233 (define-public ecl-salza2
10234   (sbcl-package->ecl-package sbcl-salza2))
10235
10236 (define-public sbcl-png-read
10237   (let ((commit "ec29f38a689972b9f1373f13bbbcd6b05deada88")
10238         (revision "1"))
10239     (package
10240       (name "sbcl-png-read")
10241       (version (git-version "0.3.1" revision commit))
10242       (source
10243        (origin
10244          (method git-fetch)
10245          (uri (git-reference
10246                (url "https://github.com/Ramarren/png-read.git")
10247                (commit commit)))
10248          (file-name (git-file-name name version))
10249          (sha256
10250           (base32 "0vyczbcwskrygrf1hgrsnk0jil8skmvf1kiaalw5jps4fjrfdkw0"))))
10251       (build-system asdf-build-system/sbcl)
10252       (inputs
10253        `(("babel" ,sbcl-babel)
10254          ("chipz" ,sbcl-chipz)
10255          ("iterate" ,sbcl-iterate)))
10256       (synopsis "PNG decoder for Common Lisp")
10257       (description "This is a Common Lisp library for reading PNG images.")
10258       (home-page "https://github.com/Ramarren/png-read")
10259       (license license:bsd-3))))
10260
10261 (define-public cl-png-read
10262   (sbcl-package->cl-source-package sbcl-png-read))
10263
10264 (define-public ecl-png-read
10265   (sbcl-package->ecl-package sbcl-png-read))
10266
10267 (define-public sbcl-zpng
10268   (package
10269     (name "sbcl-zpng")
10270     (version "1.2.2")
10271     (source
10272      (origin
10273        (method git-fetch)
10274        (uri (git-reference
10275              (url "https://github.com/xach/zpng.git")
10276              (commit (string-append "release-" version))))
10277        (file-name (git-file-name name version))
10278        (sha256
10279         (base32 "0b3ag3jhl3z7kdls3ahdsdxsfhhw5qrizk769984f4wkxhb69rcm"))))
10280     (build-system asdf-build-system/sbcl)
10281     (inputs
10282      `(("salza2" ,sbcl-salza2)))
10283     (synopsis "PNG encoder for Common Lisp")
10284     (description "This is a Common Lisp library for creating PNG images.")
10285     (home-page "https://www.xach.com/lisp/zpng/")
10286     (license license:bsd-2)))
10287
10288 (define-public cl-zpng
10289   (sbcl-package->cl-source-package sbcl-zpng))
10290
10291 (define-public ecl-zpng
10292   (sbcl-package->ecl-package sbcl-zpng))
10293
10294 (define-public sbcl-cl-qrencode
10295   (package
10296     (name "sbcl-cl-qrencode")
10297     (version "0.1.2")
10298     (source
10299      (origin
10300        (method git-fetch)
10301        (uri (git-reference
10302              (url "https://github.com/jnjcc/cl-qrencode.git")
10303              (commit (string-append "v" version))))
10304        (file-name (git-file-name name version))
10305        (sha256
10306         (base32 "1l5k131dchbf6cj8a8xqa731790p01p3qa1kdy2wa9dawy3ymkxr"))))
10307     (build-system asdf-build-system/sbcl)
10308     (native-inputs
10309      `(("lisp-unit" ,sbcl-lisp-unit)))
10310     (inputs
10311      `(("zpng" ,sbcl-zpng)))
10312     (synopsis "QR code encoder for Common Lisp")
10313     (description
10314      "This Common Lisp library provides function to make QR codes and to save
10315 them as PNG files.")
10316     (home-page "https://github.com/jnjcc/cl-qrencode")
10317     (license license:gpl2+)))
10318
10319 (define-public cl-qrencode
10320   (sbcl-package->cl-source-package sbcl-cl-qrencode))
10321
10322 (define-public ecl-cl-qrencode
10323   (sbcl-package->ecl-package sbcl-cl-qrencode))
10324
10325 (define-public sbcl-hdf5-cffi
10326   (let ((commit "5b5c88f191e470e4fe96b462334e3ce0806eed5c")
10327         (revision "1"))
10328     (package
10329       (name "sbcl-hdf5-cffi")
10330       (version (git-version "1.8.18" revision commit))
10331       (source
10332        (origin
10333          (method git-fetch)
10334          (uri (git-reference
10335                (url "https://github.com/hdfgroup/hdf5-cffi.git")
10336                (commit commit)))
10337          (file-name (git-file-name name version))
10338          (sha256
10339           (base32
10340            "0vda3075423xz83qky998lpac5b04dwfv7bwgh9jq8cs5v0zrxjf"))))
10341       (build-system asdf-build-system/sbcl)
10342       (synopsis "Common Lisp bindings for the HDF5 library")
10343       (description
10344        "@code{hdf5-cffi} is a CFFI wrapper for the HDF5 library.")
10345       (home-page "https://github.com/hdfgroup/hdf5-cffi")
10346       (license (license:non-copyleft
10347                 (string-append "https://github.com/HDFGroup/hdf5-cffi/raw/"
10348                                commit
10349                                "/LICENSE")))
10350       (inputs
10351        `(("cffi" ,sbcl-cffi)
10352          ("cffi-grovel" ,sbcl-cffi-grovel)
10353          ("hdf5" ,hdf5-1.10)))
10354       (native-inputs
10355        `(("fiveam" ,sbcl-fiveam)))
10356       (arguments
10357        `(#:asd-system-name "hdf5-cffi"
10358          #:asd-file "hdf5-cffi.asd"
10359          #:test-asd-file "hdf5-cffi.test.asd"
10360          ;; Tests depend on hdf5-cffi.examples.asd in addition to hdf5-cffi.asd,
10361          ;; I don't know if there is a way to tell asdf-build-system to load
10362          ;; an additional system first, so tests are disabled.
10363          #:tests? #f
10364          #:phases
10365          (modify-phases %standard-phases
10366            (add-after 'unpack 'fix-paths
10367              (lambda* (#:key inputs #:allow-other-keys)
10368                (substitute* "src/library.lisp"
10369                  (("libhdf5.so")
10370                   (string-append
10371                    (assoc-ref inputs "hdf5")
10372                    "/lib/libhdf5.so")))))
10373            (add-after 'unpack 'fix-dependencies
10374              (lambda* (#:key inputs #:allow-other-keys)
10375                (substitute* "hdf5-cffi.asd"
10376                  ((":depends-on \\(:cffi\\)")
10377                   ":depends-on (:cffi :cffi-grovel)"))
10378                (substitute* "hdf5-cffi.test.asd"
10379                  ((":depends-on \\(:cffi :hdf5-cffi")
10380                   ":depends-on (:cffi :cffi-grovel :hdf5-cffi"))))))))))
10381
10382 (define-public cl-hdf5-cffi
10383   (sbcl-package->cl-source-package sbcl-hdf5-cffi))
10384
10385 (define-public ecl-hdf5-cffi
10386   (sbcl-package->ecl-package sbcl-hdf5-cffi))
10387
10388 (define-public sbcl-cl-randist
10389   (package
10390     (name "sbcl-cl-randist")
10391     (version "0.4.2")
10392     (source
10393      (origin
10394        (method git-fetch)
10395        (uri (git-reference
10396              (url "https://github.com/lvaruzza/cl-randist.git")
10397              (commit "f088a54b540a7adefab7c04094a6103f9edda3d0")))
10398        (file-name (git-file-name name version))
10399        (sha256
10400         (base32
10401          "0l8hyd6nbxb7f50vyxz3rbbm7kgr1fnadc40jywy4xj5vi5kpj5g"))))
10402     (build-system asdf-build-system/sbcl)
10403     (synopsis "Random distributions for Common Lisp")
10404     (description
10405      "Manual translation from C to Common Lisp of some random number
10406 generation functions from the GSL library.")
10407     (home-page "https://github.com/lvaruzza/cl-randist")
10408     (license license:bsd-2)
10409     (arguments
10410      `(#:asd-system-name "cl-randist"
10411        #:asd-file "cl-randist.asd"
10412        #:tests? #f))))
10413
10414 (define-public cl-randist
10415   (sbcl-package->cl-source-package sbcl-cl-randist))
10416
10417 (define-public ecl-cl-randist
10418   (sbcl-package->ecl-package sbcl-cl-randist))
10419
10420 (define-public sbcl-float-features
10421   (package
10422     (name "sbcl-float-features")
10423     (version "1.0.0")
10424     (source
10425      (origin
10426        (method git-fetch)
10427        (uri (git-reference
10428              (url "https://github.com/Shinmera/float-features.git")
10429              (commit "d3ef60181635b0849aa28cfc238053b7ca4644b0")))
10430        (file-name (git-file-name name version))
10431        (sha256
10432         (base32
10433          "0yj419k7n59x6rh3grwr6frgwwyria2il6f7wxpfazm8cskv4lzr"))))
10434     (build-system asdf-build-system/sbcl)
10435     (synopsis "Common Lisp IEEE float portability library")
10436     (description
10437      "Portability library for IEEE float features that are not
10438 covered by the Common Lisp standard.")
10439     (home-page "https://github.com/Shinmera/float-features")
10440     (license license:zlib)
10441     (inputs
10442      `(("documentation-utils" ,sbcl-documentation-utils)))
10443     (arguments
10444      `(#:asd-system-name "float-features"
10445        #:asd-file "float-features.asd"
10446        #:tests? #f))))
10447
10448 (define-public cl-float-features
10449   (sbcl-package->cl-source-package sbcl-float-features))
10450
10451 (define-public ecl-float-features
10452   (sbcl-package->ecl-package sbcl-float-features))
10453
10454 (define-public sbcl-function-cache
10455   (package
10456     (name "sbcl-function-cache")
10457     (version "1.0.3")
10458     (source
10459      (origin
10460        (method git-fetch)
10461        (uri (git-reference
10462              (url "https://github.com/AccelerationNet/function-cache.git")
10463              (commit "6a5ada401e57da2c8abf046f582029926e61fce8")))
10464        (file-name (git-file-name name version))
10465        (sha256
10466         (base32
10467          "000vmd3f5rx5hs9nvphfric0gkzaadns31c6mxaslpv0k7pkrmc6"))))
10468     (build-system asdf-build-system/sbcl)
10469     (synopsis "Function caching / memoization library for Common Lisp")
10470     (description
10471      "A common lisp library that provides extensible function result
10472 caching based on arguments (an expanded form of memoization).")
10473     (home-page "https://github.com/AccelerationNet/function-cache")
10474     (license
10475      (license:non-copyleft
10476       "https://github.com/AccelerationNet/function-cache/blob/master/README.md"))
10477     (inputs
10478      `(("alexandria" ,sbcl-alexandria)
10479        ("cl-interpol" ,sbcl-cl-interpol)
10480        ("iterate" ,sbcl-iterate)
10481        ("symbol-munger" ,sbcl-symbol-munger)
10482        ("closer-mop" ,sbcl-closer-mop)))
10483     (arguments
10484      `(#:asd-system-name "function-cache"
10485        #:asd-file "function-cache.asd"
10486        #:tests? #f))))
10487
10488 (define-public cl-function-cache
10489   (sbcl-package->cl-source-package sbcl-function-cache))
10490
10491 (define-public ecl-function-cache
10492   (sbcl-package->ecl-package sbcl-function-cache))
10493
10494 (define-public sbcl-type-r
10495   (let ((commit "83c89e38f2f7a7b16f1012777ecaf878cfa6a267")
10496         (revision "1"))
10497     (package
10498       (name "sbcl-type-r")
10499       (version (git-version "0.0.0" revision commit))
10500       (source
10501        (origin
10502          (method git-fetch)
10503          (uri (git-reference
10504                (url "https://github.com/guicho271828/type-r.git")
10505                (commit commit)))
10506          (file-name (git-file-name name version))
10507          (sha256
10508           (base32
10509            "1arsxc2539rg8vbrdirz4xxj1b06mc6g6rqndz7a02g127qvk2sm"))))
10510       (build-system asdf-build-system/sbcl)
10511       (synopsis "Parser interface for Common Lisp built-in compound types")
10512       (description
10513        "Collections of accessor functions and patterns to access
10514 the elements in compound type specifier, e.g. @code{dimensions} in
10515 @code{(array element-type dimensions)}")
10516       (home-page "https://github.com/guicho271828/type-r")
10517       (license license:lgpl3+)
10518       (inputs
10519        `(("trivia" ,sbcl-trivia)
10520          ("alexandria" ,sbcl-alexandria)))
10521       (native-inputs
10522        `(("fiveam" ,sbcl-fiveam)))
10523       (arguments
10524        `(#:asd-system-name "type-r"
10525          #:asd-file "type-r.asd"
10526          #:test-asd-file "type-r.test.asd")))))
10527
10528 (define-public cl-type-r
10529   (sbcl-package->cl-source-package sbcl-type-r))
10530
10531 (define-public sbcl-trivialib-type-unify
10532   (let ((commit "62492ebf04db567dcf435ae84c50b7b8202ecf99")
10533         (revision "1"))
10534     (package
10535       (name "sbcl-trivialib-type-unify")
10536       (version (git-version "0.1" revision commit))
10537       (source
10538        (origin
10539          (method git-fetch)
10540          (uri (git-reference
10541                (url "https://github.com/guicho271828/trivialib.type-unify.git")
10542                (commit commit)))
10543          (file-name (git-file-name name version))
10544          (sha256
10545           (base32
10546            "1bkyfzbwv75p50zp8n1n9rh2r29pw3vgz91gmn2gzzkyq3khj1vh"))))
10547       (build-system asdf-build-system/sbcl)
10548       (synopsis "Common Lisp type unification")
10549       (description
10550        "Unifies a parametrized type specifier against an actual type specifier.
10551 Importantly, it handles complicated array-subtypes and number-related types
10552 correctly.")
10553       (home-page "https://github.com/guicho271828/trivialib.type-unify")
10554       (license license:lgpl3+)
10555       (inputs
10556        `(("alexandria" ,sbcl-alexandria)
10557          ("trivia" ,sbcl-trivia)
10558          ("introspect-environment" ,sbcl-introspect-environment)
10559          ("type-r" ,sbcl-type-r)))
10560       (native-inputs
10561        `(("fiveam" ,sbcl-fiveam)))
10562       (arguments
10563        `(#:asd-system-name "trivialib.type-unify"
10564          #:asd-file "trivialib.type-unify.asd"
10565          #:test-asd-file "trivialib.type-unify.test.asd")))))
10566
10567 (define-public cl-trivialib-type-unify
10568   (sbcl-package->cl-source-package sbcl-trivialib-type-unify))
10569
10570 (define-public sbcl-specialized-function
10571   (let ((commit "b96b6afaf8358bf91cc0703e62a5a4ee20d2b7bc")
10572         (revision "1"))
10573     (package
10574       (name "sbcl-specialized-function")
10575       (version (git-version "0.0.0" revision commit))
10576       (source
10577        (origin
10578          (method git-fetch)
10579          (uri (git-reference
10580                (url "https://github.com/numcl/specialized-function.git")
10581                (commit commit)))
10582          (file-name (git-file-name name version))
10583          (sha256
10584           (base32
10585            "12j45ff0n26578vmfbhb9mfbdchw4wy023k0m2ppgl9s0z4bhjaj"))))
10586       (build-system asdf-build-system/sbcl)
10587       (synopsis "Julia-like dispatch for Common Lisp")
10588       (description
10589        "This library is part of NUMCL.  It provides a macro
10590 @code{SPECIALIZED} that performs a Julia-like dispatch on the arguments,
10591 lazily compiling a type-specific version of the function from the same
10592 code.  The main target of this macro is speed.")
10593       (home-page "https://github.com/numcl/specialized-function")
10594       (license license:lgpl3+)
10595       (inputs
10596        `(("trivia" ,sbcl-trivia)
10597          ("alexandria" ,sbcl-alexandria)
10598          ("iterate" ,sbcl-iterate)
10599          ("lisp-namespace" ,sbcl-lisp-namespace)
10600          ("type-r" ,sbcl-type-r)
10601          ("trivial-cltl2" ,sbcl-trivial-cltl2)))
10602       (native-inputs
10603        `(("fiveam" ,sbcl-fiveam)))
10604       (arguments
10605        `(#:asd-system-name "specialized-function"
10606          #:asd-file "specialized-function.asd"
10607          #:test-asd-file "specialized-function.test.asd")))))
10608
10609 (define-public cl-specialized-function
10610   (sbcl-package->cl-source-package sbcl-specialized-function))
10611
10612 (define-public sbcl-constantfold
10613   (let ((commit "0ff1d97a3fbcb89264f6a2af6ce62b73e7b421f4")
10614         (revision "1"))
10615     (package
10616       (name "sbcl-constantfold")
10617       (version (git-version "0.1" revision commit))
10618       (source
10619        (origin
10620          (method git-fetch)
10621          (uri (git-reference
10622                (url "https://github.com/numcl/constantfold.git")
10623                (commit commit)))
10624          (file-name (git-file-name name version))
10625          (sha256
10626           (base32
10627            "153h0569z6bff1qbad0bdssplwwny75l7ilqwcfqfdvzsxf9jh06"))))
10628       (build-system asdf-build-system/sbcl)
10629       (synopsis "Support library for numcl")
10630       (description
10631        "Support library for numcl.  Registers a function as an
10632 additional form that is considered as a candidate for a constant.")
10633       (home-page "https://github.com/numcl/constantfold")
10634       (license license:lgpl3+)
10635       (inputs
10636        `(("trivia" ,sbcl-trivia)
10637          ("alexandria" ,sbcl-alexandria)
10638          ("iterate" ,sbcl-iterate)
10639          ("lisp-namespace" ,sbcl-lisp-namespace)))
10640       (native-inputs
10641        `(("fiveam" ,sbcl-fiveam)))
10642       (arguments
10643        `(#:asd-system-name "constantfold"
10644          #:asd-file "constantfold.asd"
10645          #:test-asd-file "constantfold.test.asd")))))
10646
10647 (define-public cl-constantfold
10648   (sbcl-package->cl-source-package sbcl-constantfold))
10649
10650 (define-public sbcl-gtype
10651   (let ((commit "42275e3606242ae91e9c8dfa30c18ced50a35b66")
10652         (revision "1"))
10653     (package
10654       (name "sbcl-gtype")
10655       (version (git-version "0.1" revision commit))
10656       (source
10657        (origin
10658          (method git-fetch)
10659          (uri (git-reference
10660                (url "https://github.com/numcl/gtype.git")
10661                (commit commit)))
10662          (file-name (git-file-name name version))
10663          (sha256
10664           (base32
10665            "1f56dba998v945jcxhha391557n6md1ql25b7icfwwfivhmlaa9b"))))
10666       (build-system asdf-build-system/sbcl)
10667       (synopsis "C++/Julia-like parametric types in Common Lisp")
10668       (description
10669        "Support library for numcl that provides Julia-like runtime parametric
10670 type correctness in Common Lisp.  It is based on CLtL2 extensions.")
10671       (home-page "https://github.com/numcl/gtype")
10672       (license license:lgpl3+)
10673       (inputs
10674        `(("trivialib.type-unify" ,sbcl-trivialib-type-unify)
10675          ("trivial-cltl2" ,sbcl-trivial-cltl2)
10676          ("trivia" ,sbcl-trivia)
10677          ("alexandria" ,sbcl-alexandria)
10678          ("iterate" ,sbcl-iterate)
10679          ("type-r" ,sbcl-type-r)))
10680       (native-inputs
10681        `(("fiveam" ,sbcl-fiveam)))
10682       (arguments
10683        `(#:asd-system-name "gtype"
10684          #:asd-file "gtype.asd"
10685          #:test-asd-file "gtype.test.asd")))))
10686
10687 (define-public cl-gtype
10688   (sbcl-package->cl-source-package sbcl-gtype))
10689
10690 (define-public sbcl-numcl
10691   (let ((commit "1cf7dfa59f763a24a501092870e9c5ee745d0c17")
10692         (revision "1"))
10693     (package
10694       (name "sbcl-numcl")
10695       (version (git-version "0.1.0" revision commit))
10696       (source
10697        (origin
10698          (method git-fetch)
10699          (uri (git-reference
10700                (url "https://github.com/numcl/numcl.git")
10701                (commit commit)))
10702          (file-name (git-file-name name version))
10703          (sha256
10704           (base32
10705            "0i3jby9hf4ii7blivgyza80g0vmjfhk8537i5i7kqqk0i5sdnym2"))))
10706       (build-system asdf-build-system/sbcl)
10707       (synopsis "Numpy clone in Common Lisp")
10708       (description
10709        "This is a Numpy clone in Common Lisp.  At the moment the
10710 library is written in pure Common Lisp, focusing more on correctness
10711 and usefulness, not speed.  Track the progress at
10712 @url{https://github.com/numcl/numcl/projects/1}.")
10713       (home-page "https://github.com/numcl/numcl")
10714       (license license:lgpl3+)
10715       (inputs
10716        `(("trivia" ,sbcl-trivia)
10717          ("alexandria" ,sbcl-alexandria)
10718          ("iterate" ,sbcl-iterate)
10719          ("lisp-namespace" ,sbcl-lisp-namespace)
10720          ("type-r" ,sbcl-type-r)
10721          ("constantfold" ,sbcl-constantfold)
10722          ("cl-randist" ,sbcl-cl-randist)
10723          ("float-features" ,sbcl-float-features)
10724          ("function-cache" ,sbcl-function-cache)
10725          ("specialized-function" ,sbcl-specialized-function)
10726          ("gtype" ,sbcl-gtype)))
10727       (native-inputs
10728        `(("fiveam" ,sbcl-fiveam)))
10729       (arguments
10730        `(#:asd-system-name "numcl"
10731          #:asd-file "numcl.asd"
10732          #:test-asd-file "numcl.test.asd")))))
10733
10734 (define-public cl-numcl
10735   (sbcl-package->cl-source-package sbcl-numcl))
10736
10737 (define-public sbcl-pzmq
10738   (let ((commit "7c7390eedc469d033c72dc497984d1536ee75826")
10739         (revision "1"))
10740     (package
10741       (name "sbcl-pzmq")
10742       (version (git-version "0.0.0" revision commit))
10743       (source
10744        (origin
10745          (method git-fetch)
10746          (uri (git-reference
10747                (url "https://github.com/orivej/pzmq.git")
10748                (commit commit)))
10749          (file-name (git-file-name name version))
10750          (sha256
10751           (base32 "0gmwzf7h90wa7v4wnk49g0hv2mdalljpwhyigxcb967wzv8lqci9"))))
10752       (build-system asdf-build-system/sbcl)
10753       (native-inputs
10754        `(("bordeaux-threads" ,sbcl-bordeaux-threads)
10755          ("fiveam" ,sbcl-fiveam)
10756          ("let-plus" ,sbcl-let-plus)))
10757       (inputs
10758        `(("cffi" ,sbcl-cffi)
10759          ("cffi-grovel" ,sbcl-cffi-grovel)
10760          ("zeromq" ,zeromq)))
10761       (arguments
10762        `(#:phases (modify-phases %standard-phases
10763                     (add-after 'unpack 'fix-paths
10764                       (lambda* (#:key inputs #:allow-other-keys)
10765                         (substitute* "c-api.lisp"
10766                           (("\"libzmq")
10767                            (string-append "\""
10768                                           (assoc-ref inputs "zeromq")
10769                                           "/lib/libzmq")))
10770                         #t)))))
10771       (synopsis "Common Lisp bindings for the ZeroMQ library")
10772       (description "This Common Lisp library provides bindings for the ZeroMQ
10773 lightweight messaging kernel.")
10774       (home-page "https://github.com/orivej/pzmq")
10775       (license license:unlicense))))
10776
10777 (define-public cl-pzmq
10778   (sbcl-package->cl-source-package sbcl-pzmq))
10779
10780 (define-public ecl-pzmq
10781   (sbcl-package->ecl-package sbcl-pzmq))
10782
10783 (define-public sbcl-clss
10784   (let ((revision "1")
10785         (commit "2a8e8615ab55870d4ca01928f3ed3bbeb4e75c8d"))
10786     (package
10787       (name "sbcl-clss")
10788       (version (git-version "0.3.1" revision commit))
10789       (source
10790        (origin
10791          (method git-fetch)
10792          (uri
10793           (git-reference
10794            (url "https://github.com/Shinmera/clss.git")
10795            (commit commit)))
10796          (sha256
10797           (base32 "0la4dbcda78x29szanylccrsljqrn9d1mhh569sqkyp44ni5fv91"))
10798          (file-name (git-file-name name version))))
10799       (inputs
10800        `(("array-utils" ,sbcl-array-utils)
10801          ("plump" ,sbcl-plump)))
10802       (build-system asdf-build-system/sbcl)
10803       (synopsis "DOM tree searching engine based on CSS selectors")
10804       (description "CLSS is a DOM traversal engine based on CSS
10805 selectors.  It makes use of the Plump-DOM and is used by lQuery.")
10806       (home-page "https://github.com/Shinmera/clss")
10807       (license license:zlib))))
10808
10809 (define-public cl-clss
10810   (sbcl-package->cl-source-package sbcl-clss))
10811
10812 (define-public ecl-clss
10813   (sbcl-package->ecl-package sbcl-clss))
10814
10815 (define-public sbcl-lquery
10816   (let ((revision "1")
10817         (commit "8048111c6b83956daa632e7a3ffbd8c9c203bd8d"))
10818     (package
10819       (name "sbcl-lquery")
10820       (version (git-version "3.2.1" revision commit))
10821       (source
10822        (origin
10823          (method git-fetch)
10824          (uri
10825           (git-reference
10826            (url "https://github.com/Shinmera/lquery.git")
10827            (commit commit)))
10828          (sha256
10829           (base32 "0520mcpxc2d6fdm8z61arpgd2z38kan7cf06qs373n5r64rakz6w"))
10830          (file-name (git-file-name name version))))
10831       (native-inputs
10832        `(("fiveam" ,sbcl-fiveam)))
10833       (inputs
10834        `(("array-utils" ,sbcl-array-utils)
10835          ("form-fiddle" ,sbcl-form-fiddle)
10836          ("plump" ,sbcl-plump)
10837          ("clss" ,sbcl-clss)))
10838       (build-system asdf-build-system/sbcl)
10839       (synopsis "Library to allow jQuery-like HTML/DOM manipulation")
10840       (description "@code{lQuery} is a DOM manipulation library written in
10841 Common Lisp, inspired by and based on the jQuery syntax and
10842 functions.  It uses Plump and CLSS as DOM and selector engines.  The
10843 main idea behind lQuery is to provide a simple interface for crawling
10844 and modifying HTML sites, as well as to allow for an alternative
10845 approach to templating.")
10846       (home-page "https://github.com/Shinmera/lquery")
10847       (license license:zlib))))
10848
10849 (define-public cl-lquery
10850   (sbcl-package->cl-source-package sbcl-lquery))
10851
10852 (define-public ecl-lquery
10853   (sbcl-package->ecl-package sbcl-lquery))
10854
10855 (define-public sbcl-cl-mysql
10856   (let ((commit "ab56c279c1815aec6ca0bfe85164ff7e85cfb6f9")
10857         (revision "1"))
10858     (package
10859       (name "sbcl-cl-mysql")
10860       (version (git-version "0.1" revision commit))
10861       (source
10862        (origin
10863          (method git-fetch)
10864          (uri (git-reference
10865                (url "https://github.com/hackinghat/cl-mysql.git")
10866                (commit commit)))
10867          (file-name (git-file-name name version))
10868          (sha256
10869           (base32 "0dg5ynx2ww94d0qfwrdrm7plkn43h64hs4iiq9mj2s1s4ixnp3lr"))))
10870       (build-system asdf-build-system/sbcl)
10871       (native-inputs
10872        `(("stefil" ,sbcl-stefil)))
10873       (inputs
10874        `(("cffi" ,sbcl-cffi)
10875          ("mariadb-lib" ,mariadb "lib")))
10876       (arguments
10877        `(#:tests? #f ; TODO: Tests require a running server
10878          #:phases
10879          (modify-phases %standard-phases
10880            (add-after 'unpack 'fix-paths
10881              (lambda* (#:key inputs #:allow-other-keys)
10882                (substitute* "system.lisp"
10883                  (("libmysqlclient_r" all)
10884                   (string-append (assoc-ref inputs "mariadb-lib")
10885                                  "/lib/"
10886                                  all)))
10887                #t)))))
10888       (synopsis "Common Lisp wrapper for MySQL")
10889       (description
10890        "@code{cl-mysql} is a Common Lisp implementation of a MySQL wrapper.")
10891       (home-page "http://www.hackinghat.com/index.php/cl-mysql")
10892       (license license:expat))))
10893
10894 (define-public cl-mysql
10895   (sbcl-package->cl-source-package sbcl-cl-mysql))
10896
10897 (define-public sbcl-simple-date
10898   (let ((commit "74469b25bbda990ec9b77e0d0eccdba0cd7e721a")
10899         (revision "1"))
10900     (package
10901       (name "sbcl-simple-date")
10902       (version (git-version "1.19" revision commit))
10903       (source
10904        (origin
10905          (method git-fetch)
10906          (uri (git-reference
10907                (url "https://github.com/marijnh/Postmodern.git")
10908                (commit commit)))
10909          (file-name (git-file-name name version))
10910          (sha256
10911           (base32 "0im7ymnyxjhn2w74jfg76k5gpr0gl33n31akx33hl28722ljd0hd"))))
10912       (build-system asdf-build-system/sbcl)
10913       (native-inputs
10914        `(("fiveam" ,sbcl-fiveam)))
10915       (synopsis "Basic date and time objects for Common Lisp")
10916       (description
10917        "@code{simple-date} is a very basic implementation of date and time
10918 objects, used to support storing and retrieving time-related SQL types.")
10919       (home-page "https://marijnhaverbeke.nl/postmodern/")
10920       (license license:zlib))))
10921
10922 (define-public cl-simple-date
10923   (sbcl-package->cl-source-package sbcl-simple-date))
10924
10925 (define-public ecl-simple-date
10926   (sbcl-package->ecl-package sbcl-simple-date))
10927
10928 (define-public sbcl-cl-postgres
10929   (package
10930     (inherit sbcl-simple-date)
10931     (name "sbcl-cl-postgres")
10932     (native-inputs
10933      `(("fiveam" ,sbcl-fiveam)
10934        ("simple-date" ,sbcl-simple-date)))
10935     (inputs
10936      `(("md5" ,sbcl-md5)
10937        ("split-sequence" ,sbcl-split-sequence)
10938        ("usocket" ,sbcl-usocket)))
10939     (arguments
10940      `(#:tests? #f)) ; TODO: Break simple-date/postgres-glue circular dependency
10941     (synopsis "Common Lisp interface for PostgreSQL")
10942     (description
10943      "@code{cl-postgres} is a low-level library used for interfacing with
10944 a PostgreSQL server over a socket.")))
10945
10946 (define-public cl-postgres
10947   (sbcl-package->cl-source-package sbcl-cl-postgres))
10948
10949 (define-public sbcl-simple-date-postgres-glue
10950   (package
10951     (inherit sbcl-simple-date)
10952     (name "sbcl-simple-date-postgres-glue")
10953     (inputs
10954      `(("cl-postgres" ,sbcl-cl-postgres)
10955        ("simple-date" ,sbcl-simple-date)))
10956     (arguments
10957      `(#:asd-file "simple-date.asd"
10958        #:asd-system-name "simple-date/postgres-glue"))))
10959
10960 (define-public cl-simple-date-postgres-glue
10961   (sbcl-package->cl-source-package sbcl-simple-date-postgres-glue))
10962
10963 (define-public sbcl-s-sql
10964   (package
10965     (inherit sbcl-simple-date)
10966     (name "sbcl-s-sql")
10967     (inputs
10968      `(("alexandria" ,sbcl-alexandria)
10969        ("cl-postgres" ,sbcl-cl-postgres)))
10970     (arguments
10971      `(#:tests? #f)) ; TODO: Break postmodern circular dependency
10972     (synopsis "Lispy DSL for SQL")
10973     (description
10974      "@code{s-sql} is a Common Lisp library that can be used to compile
10975 s-expressions to strings of SQL code, escaping any Lisp values inside, and
10976 doing as much as possible of the work at compile time.")))
10977
10978 (define-public cl-s-sql
10979   (sbcl-package->cl-source-package sbcl-s-sql))
10980
10981 (define-public sbcl-postmodern
10982   (package
10983     (inherit sbcl-simple-date)
10984     (name "sbcl-postmodern")
10985     (native-inputs
10986      `(("fiveam" ,sbcl-fiveam)
10987        ("simple-date" ,sbcl-simple-date)
10988        ("simple-date-postgres-glue" ,sbcl-simple-date-postgres-glue)))
10989     (inputs
10990      `(("alexandria" ,sbcl-alexandria)
10991        ("bordeaux-threads" ,sbcl-bordeaux-threads)
10992        ("cl-postgres" ,sbcl-cl-postgres)
10993        ("closer-mop" ,sbcl-closer-mop)
10994        ("global-vars" ,sbcl-global-vars)
10995        ("s-sql" ,sbcl-s-sql)
10996        ("split-sequence" ,sbcl-split-sequence)))
10997     (arguments
10998      ;; TODO: Fix missing dependency errors for simple-date/postgres-glue,
10999      ;; cl-postgres/tests and s-sql/tests.
11000      `(#:tests? #f))
11001     (synopsis "Common Lisp library for interacting with PostgreSQL")
11002     (description
11003      "@code{postmodern} is a Common Lisp library for interacting with
11004 PostgreSQL databases.  It provides the following features:
11005
11006 @itemize
11007 @item Efficient communication with the database server without need for
11008 foreign libraries.
11009 @item Support for UTF-8 on Unicode-aware Lisp implementations.
11010 @item A syntax for mixing SQL and Lisp code.
11011 @item Convenient support for prepared statements and stored procedures.
11012 @item A metaclass for simple database-access objects.
11013 @end itemize\n")))
11014
11015 (define-public cl-postmodern
11016   (sbcl-package->cl-source-package sbcl-postmodern))
11017
11018 (define-public sbcl-dbi
11019   (package
11020     (name "sbcl-dbi")
11021     (version "0.9.4")
11022     (source
11023      (origin
11024        (method git-fetch)
11025        (uri (git-reference
11026              (url "https://github.com/fukamachi/cl-dbi.git")
11027              (commit version)))
11028        (file-name (git-file-name name version))
11029        (sha256
11030         (base32 "0m1fsravfaizamdak84adh3jxc4j91maqnrb4m08bfbmb04cdqhs"))))
11031     (build-system asdf-build-system/sbcl)
11032     (inputs
11033      `(("bordeaux-threads" ,sbcl-bordeaux-threads)
11034        ("closer-mop" ,sbcl-closer-mop)
11035        ("split-sequence" ,sbcl-split-sequence)))
11036     (arguments
11037      `(#:tests? #f)) ; TODO: Break circular dependency with dbd-*
11038     (synopsis "Database independent interface for Common Lisp")
11039     (description
11040      "@code{dbi} is a Common Lisp library providing a database independent
11041 interface for MySQL, PostgreSQL and SQLite.")
11042     (home-page "https://github.com/fukamachi/cl-dbi")
11043     (license license:llgpl)))
11044
11045 (define-public cl-dbi
11046   (sbcl-package->cl-source-package sbcl-dbi))
11047
11048 (define-public sbcl-dbd-mysql
11049   (package
11050    (inherit sbcl-dbi)
11051    (name "sbcl-dbd-mysql")
11052    (inputs
11053     `(("cl-mysql" ,sbcl-cl-mysql)
11054       ("dbi" ,sbcl-dbi)))
11055    (synopsis "Database driver for MySQL")))
11056
11057 (define-public cl-dbd-mysql
11058   (sbcl-package->cl-source-package sbcl-dbd-mysql))
11059
11060 (define-public sbcl-dbd-postgres
11061   (package
11062    (inherit sbcl-dbi)
11063    (name "sbcl-dbd-postgres")
11064    (inputs
11065     `(("cl-postgres" ,sbcl-cl-postgres)
11066       ("dbi" ,sbcl-dbi)
11067       ("trivial-garbage" ,sbcl-trivial-garbage)))
11068    (synopsis "Database driver for PostgreSQL")))
11069
11070 (define-public cl-dbd-postgres
11071   (sbcl-package->cl-source-package sbcl-dbd-postgres))
11072
11073 (define-public sbcl-dbd-sqlite3
11074   (package
11075    (inherit sbcl-dbi)
11076    (name "sbcl-dbd-sqlite3")
11077    (inputs
11078     `(("cl-sqlite" ,sbcl-cl-sqlite)
11079       ("dbi" ,sbcl-dbi)
11080       ("trivial-garbage" ,sbcl-trivial-garbage)))
11081    (synopsis "Database driver for SQLite3")))
11082
11083 (define-public cl-dbd-sqlite3
11084   (sbcl-package->cl-source-package sbcl-dbd-sqlite3))
11085
11086 (define-public sbcl-uffi
11087   (package
11088     (name "sbcl-uffi")
11089     (version "2.1.2")
11090     (source
11091      (origin
11092        (method git-fetch)
11093        (uri (git-reference
11094              (url "http://git.kpe.io/uffi.git")
11095              (commit (string-append "v" version))))
11096        (file-name (git-file-name name version))
11097        (sha256
11098         (base32 "1hqszvz0a3wk4s9faa83sc3vjxcb5rxmjclyr17yzwg55z733kry"))))
11099     (build-system asdf-build-system/sbcl)
11100     (arguments
11101      `(#:tests? #f ; TODO: Fix use of deprecated ASDF functions
11102        #:phases
11103        (modify-phases %standard-phases
11104          (add-after 'unpack 'fix-permissions
11105            (lambda _
11106              (make-file-writable "doc/html.tar.gz")
11107              #t)))))
11108     (synopsis "Universal foreign function library for Common Lisp")
11109     (description
11110      "UFFI provides a universal foreign function interface (FFI)
11111  for Common Lisp.")
11112     (home-page "http://quickdocs.org/uffi/")
11113     (license license:llgpl)))
11114
11115 (define-public cl-uffi
11116   (package
11117     (inherit (sbcl-package->cl-source-package sbcl-uffi))
11118     (arguments
11119      `(#:phases
11120        ;; asdf-build-system/source has its own phases and does not inherit
11121        ;; from asdf-build-system/sbcl phases.
11122        (modify-phases %standard-phases/source
11123          (add-after 'unpack 'fix-permissions
11124            (lambda _
11125              (make-file-writable "doc/html.tar.gz")
11126              #t)))))))
11127
11128 (define-public sbcl-clsql
11129   (package
11130     (name "sbcl-clsql")
11131     (version "6.7.0")
11132     (source
11133      (origin
11134        (method git-fetch)
11135        (uri (git-reference
11136              (url "http://git.kpe.io/clsql.git")
11137              (commit (string-append "v" version))))
11138        (file-name (git-file-name name version))
11139        (sha256
11140         (base32 "1v1k3s5bsy3lgd9gk459bzpb1r0kdjda25s29samxw4gsgf1fqvp"))
11141        (snippet
11142         '(begin
11143            ;; Remove precompiled libraries.
11144            (delete-file "db-mysql/clsql_mysql.dll")
11145            (delete-file "uffi/clsql_uffi.dll")
11146            (delete-file "uffi/clsql_uffi.lib")
11147            #t))))
11148     (build-system asdf-build-system/sbcl)
11149     (native-inputs
11150      `(("cffi-uffi-compat" ,sbcl-cffi-uffi-compat)
11151        ("rt" ,sbcl-rt)
11152        ("uffi" ,sbcl-uffi)))
11153     (arguments
11154      `(#:phases
11155        (modify-phases %standard-phases
11156          (add-after 'unpack 'fix-permissions
11157            (lambda _
11158              (make-file-writable "doc/html.tar.gz")
11159              #t))
11160          (add-after 'unpack 'fix-tests
11161            (lambda _
11162              (substitute* "clsql.asd"
11163                (("clsql-tests :force t")
11164                 "clsql-tests"))
11165              #t)))))
11166     (synopsis "Common Lisp SQL Interface library")
11167     (description
11168      "@code{clsql} is a Common Lisp interface to SQL RDBMS based on the
11169 Xanalys CommonSQL interface for Lispworks.  It provides low-level database
11170 interfaces as well as a functional and an object oriented interface.")
11171     (home-page "http://clsql.kpe.io/")
11172     (license license:llgpl)))
11173
11174 (define-public cl-clsql
11175   (package
11176     (inherit (sbcl-package->cl-source-package sbcl-clsql))
11177     (native-inputs
11178      `(("rt" ,cl-rt)))
11179     (inputs
11180      `(("mysql" ,mysql)
11181        ("postgresql" ,postgresql)
11182        ("sqlite" ,sqlite)
11183        ("zlib" ,zlib)))
11184     (propagated-inputs
11185      `(("cl-postgres" ,cl-postgres)
11186        ("cffi-uffi-compat" ,cl-cffi-uffi-compat)
11187        ("md5" ,cl-md5)
11188        ("uffi" ,cl-uffi)))
11189     (arguments
11190      `(#:phases
11191        ;; asdf-build-system/source has its own phases and does not inherit
11192        ;; from asdf-build-system/sbcl phases.
11193        (modify-phases %standard-phases/source
11194          (add-after 'unpack 'fix-permissions
11195            (lambda _
11196              (make-file-writable "doc/html.tar.gz")
11197              #t)))))))
11198
11199 (define-public sbcl-clsql-uffi
11200   (package
11201     (inherit sbcl-clsql)
11202     (name "sbcl-clsql-uffi")
11203     (inputs
11204      `(("cffi-uffi-compat" ,sbcl-cffi-uffi-compat)
11205        ("clsql" ,sbcl-clsql)
11206        ("uffi" ,sbcl-uffi)))
11207     (synopsis "UFFI helper functions for Common Lisp SQL interface library")))
11208
11209 (define-public sbcl-clsql-sqlite3
11210   (package
11211     (inherit sbcl-clsql)
11212     (name "sbcl-clsql-sqlite3")
11213     (inputs
11214      `(("clsql" ,sbcl-clsql)
11215        ("clsql-uffi" ,sbcl-clsql-uffi)
11216        ("sqlite" ,sqlite)))
11217     (arguments
11218      (substitute-keyword-arguments (package-arguments sbcl-clsql)
11219        ((#:phases phases '%standard-phases)
11220         `(modify-phases ,phases
11221            (add-after 'unpack 'fix-paths
11222              (lambda* (#:key inputs #:allow-other-keys)
11223                (substitute* "db-sqlite3/sqlite3-loader.lisp"
11224                  (("libsqlite3")
11225                   (string-append (assoc-ref inputs "sqlite")
11226                                  "/lib/libsqlite3")))
11227                #t))))))
11228     (synopsis "SQLite3 driver for Common Lisp SQL interface library")))
11229
11230 (define-public sbcl-clsql-postgresql
11231   (package
11232     (inherit sbcl-clsql)
11233     (name "sbcl-clsql-postgresql")
11234     (inputs
11235      `(("clsql" ,sbcl-clsql)
11236        ("clsql-uffi" ,sbcl-clsql-uffi)
11237        ("postgresql" ,postgresql)))
11238     (arguments
11239      (substitute-keyword-arguments (package-arguments sbcl-clsql)
11240        ((#:phases phases '%standard-phases)
11241         `(modify-phases ,phases
11242            (add-after 'unpack 'fix-paths
11243              (lambda* (#:key inputs #:allow-other-keys)
11244                (substitute* "db-postgresql/postgresql-loader.lisp"
11245                  (("libpq")
11246                   (string-append (assoc-ref inputs "postgresql")
11247                                  "/lib/libpq")))
11248                #t))))))
11249     (synopsis "PostgreSQL driver for Common Lisp SQL interface library")))
11250
11251 (define-public sbcl-clsql-postgresql-socket3
11252   (package
11253     (inherit sbcl-clsql)
11254     (name "sbcl-clsql-postgresql-socket3")
11255     (inputs
11256      `(("cl-postgres" ,sbcl-cl-postgres)
11257        ("clsql" ,sbcl-clsql)
11258        ("md5" ,sbcl-md5)))
11259     (arguments
11260      (substitute-keyword-arguments (package-arguments sbcl-clsql)
11261        ((#:phases phases '%standard-phases)
11262         `(modify-phases ,phases
11263            (add-after 'create-asd-file 'fix-asd-file
11264              (lambda* (#:key outputs #:allow-other-keys)
11265                (let* ((out (assoc-ref outputs "out"))
11266                       (lib (string-append out "/lib/" (%lisp-type)))
11267                       (asd (string-append lib "/clsql-postgresql-socket3.asd")))
11268                  (substitute* asd
11269                    (("CLSQL-POSTGRESQL-SOCKET-SYSTEM::")
11270                     "")))
11271                #t))))))
11272     (synopsis "PostgreSQL driver for Common Lisp SQL interface library")))
11273
11274 (define-public sbcl-clsql-mysql
11275   (package
11276     (inherit sbcl-clsql)
11277     (name "sbcl-clsql-mysql")
11278     (inputs
11279      `(("mysql" ,mysql)
11280        ("sbcl-clsql" ,sbcl-clsql)
11281        ("sbcl-clsql-uffi" ,sbcl-clsql-uffi)
11282        ("zlib" ,zlib)))
11283     (arguments
11284      (substitute-keyword-arguments (package-arguments sbcl-clsql)
11285        ((#:phases phases '%standard-phases)
11286         `(modify-phases ,phases
11287            (add-after 'unpack 'fix-paths
11288              (lambda* (#:key inputs outputs #:allow-other-keys)
11289                (let ((lib (string-append "#p\""
11290                                          (assoc-ref outputs "out")
11291                                          "/lib/\"")))
11292                  (substitute* "clsql-mysql.asd"
11293                    (("#p\"/usr/lib/clsql/clsql_mysql\\.so\"")
11294                     lib))
11295                  (substitute* "db-mysql/mysql-loader.lisp"
11296                    (("libmysqlclient" all)
11297                     (string-append (assoc-ref inputs "mysql") "/lib/" all))
11298                    (("clsql-mysql-system::\\*library-file-dir\\*")
11299                     lib)))
11300                #t))
11301            (add-before 'build 'build-helper-library
11302              (lambda* (#:key inputs outputs #:allow-other-keys)
11303                (let* ((mysql (assoc-ref inputs "mysql"))
11304                       (inc-dir (string-append mysql "/include/mysql"))
11305                       (lib-dir (string-append mysql "/lib"))
11306                       (shared-lib-dir (string-append (assoc-ref outputs "out")
11307                                                      "/lib"))
11308                       (shared-lib (string-append shared-lib-dir
11309                                                  "/clsql_mysql.so")))
11310                  (mkdir-p shared-lib-dir)
11311                  (invoke "gcc" "-fPIC" "-shared"
11312                          "-I" inc-dir
11313                          "db-mysql/clsql_mysql.c"
11314                          "-Wl,-soname=clsql_mysql"
11315                          "-L" lib-dir "-lmysqlclient" "-lz"
11316                          "-o" shared-lib)
11317                  #t)))))))
11318     (synopsis "MySQL driver for Common Lisp SQL interface library")))
11319
11320 (define-public sbcl-sycamore
11321   (let ((commit "fd2820fec165ad514493426dea209728f64e6d18"))
11322     (package
11323       (name "sbcl-sycamore")
11324       (version "0.0.20120604")
11325       (source
11326        (origin
11327          (method git-fetch)
11328          (uri (git-reference
11329                (url "https://github.com/ndantam/sycamore/")
11330                (commit commit)))
11331          (file-name (git-file-name name version))
11332          (sha256
11333           (base32 "00bv1aj89q5vldmq92zp2364jq312zjq2mbd3iyz1s2b4widzhl7"))))
11334       (build-system asdf-build-system/sbcl)
11335       (arguments
11336        `(#:asd-file "src/sycamore.asd"))
11337       (inputs
11338        `(("alexandria" ,sbcl-alexandria)
11339          ("cl-ppcre" ,sbcl-cl-ppcre)))
11340       (synopsis "Purely functional data structure library in Common Lisp")
11341       (description
11342        "Sycamore is a fast, purely functional data structure library in Common Lisp.
11343 If features:
11344
11345 @itemize
11346 @item Fast, purely functional weight-balanced binary trees.
11347 @item Leaf nodes are simple-vectors, greatly reducing tree height.
11348 @item Interfaces for tree Sets and Maps (dictionaries).
11349 @item Ropes.
11350 @item Purely functional pairing heaps.
11351 @item Purely functional amortized queue.
11352 @end itemize\n")
11353       (home-page "http://ndantam.github.io/sycamore/")
11354       (license license:bsd-3))))
11355
11356 (define-public cl-sycamore
11357   (sbcl-package->cl-source-package sbcl-sycamore))
11358
11359 (define-public sbcl-trivial-package-local-nicknames
11360   (package
11361     (name "sbcl-trivial-package-local-nicknames")
11362     (version "0.2")
11363     (home-page "https://github.com/phoe/trivial-package-local-nicknames")
11364     (source
11365      (origin
11366        (method git-fetch)
11367        (uri (git-reference
11368              (url home-page)
11369              (commit "16b7ad4c2b120f50da65154191f468ea5598460e")))
11370        (file-name (git-file-name name version))
11371        (sha256
11372         (base32 "18qc27xkjzdcqrilpk3pm7djldwq5rm3ggd5h9cr8hqcd54i2fqg"))))
11373     (build-system asdf-build-system/sbcl)
11374     (synopsis "Common Lisp compatibility library for package local nicknames")
11375     (description
11376      "This library is a portable compatibility layer around package local nicknames (PLN).
11377 This was done so there is a portability library for the PLN API not included
11378 in DEFPACKAGE.")
11379     (license license:unlicense)))
11380
11381 (define-public cl-trivial-package-local-nicknames
11382   (sbcl-package->cl-source-package sbcl-trivial-package-local-nicknames))
11383
11384 (define-public sbcl-enchant
11385   (let ((commit "6af162a7bf10541cbcfcfa6513894900329713fa"))
11386     (package
11387       (name "sbcl-enchant")
11388       (version (git-version "0.0.0" "1" commit))
11389       (home-page "https://github.com/tlikonen/cl-enchant")
11390       (source
11391        (origin
11392          (method git-fetch)
11393          (uri (git-reference
11394                (url home-page)
11395                (commit commit)))
11396          (file-name (git-file-name name version))
11397          (sha256
11398           (base32 "19yh5ihirzi1d8xqy1cjqipzd6ly3245cfxa5s9xx496rryz0s01"))))
11399       (build-system asdf-build-system/sbcl)
11400       (inputs
11401        `(("enchant" ,enchant)
11402          ("cffi" ,sbcl-cffi)))
11403       (arguments
11404        `(#:phases
11405          (modify-phases %standard-phases
11406            (add-after 'unpack 'fix-paths
11407              (lambda* (#:key inputs #:allow-other-keys)
11408                (substitute* "load-enchant.lisp"
11409                  (("libenchant")
11410                   (string-append
11411                    (assoc-ref inputs "enchant") "/lib/libenchant-2"))))))))
11412       (synopsis "Common Lisp interface for the Enchant spell-checker library")
11413       (description
11414        "Enchant is a Common Lisp interface for the Enchant spell-checker
11415 library.  The Enchant library is a generic spell-checker library which uses
11416 other spell-checkers transparently as back-end.  The library supports the
11417 multiple checkers, including Aspell and Hunspell.")
11418       (license license:public-domain))))
11419
11420 (define-public cl-enchant
11421   (sbcl-package->cl-source-package sbcl-enchant))
11422
11423 (define-public sbcl-cl-change-case
11424   (let ((commit "5ceff2a5f8bd845b6cb510c6364176b27a238fd3"))
11425     (package
11426       (name "sbcl-cl-change-case")
11427       (version (git-version "0.1.0" "1" commit))
11428       (home-page "https://github.com/rudolfochrist/cl-change-case")
11429       (source
11430        (origin
11431          (method git-fetch)
11432          (uri (git-reference
11433                (url home-page)
11434                (commit commit)))
11435          (file-name (git-file-name name version))
11436          (sha256
11437           (base32 "1afyglglk9z3yg8gylcl301bl2r8vq3sllyznzj9s5xi5gs6qyf2"))))
11438       (build-system asdf-build-system/sbcl)
11439       (inputs
11440        `(("cl-ppcre" ,sbcl-cl-ppcre)
11441          ("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)))
11442       (native-inputs
11443        `(("fiveam" ,sbcl-fiveam)))
11444       (arguments
11445        '(;; FIXME: Test pass but phase fails with 'Component
11446          ;; "cl-change-case-test" not found, required by'.
11447          #:tests? #f
11448          #:test-asd-file "cl-change-case-test.asd"))
11449       (synopsis "Convert Common Lisp strings between camelCase, PascalCase and more")
11450       (description
11451        "@code{cl-change-case} is library to convert strings between camelCase,
11452 PascalCase, snake_case, param-case, CONSTANT_CASE and more.")
11453       (license license:llgpl))))
11454
11455 (define-public cl-change-case
11456   (sbcl-package->cl-source-package sbcl-cl-change-case))
11457
11458 (define-public sbcl-moptilities
11459   (let ((commit "a436f16b357c96b82397ec018ea469574c10dd41"))
11460     (package
11461       (name "sbcl-moptilities")
11462       (version (git-version "0.3.13" "1" commit))
11463       (home-page "https://github.com/gwkkwg/moptilities/")
11464       (source
11465        (origin
11466          (method git-fetch)
11467          (uri (git-reference
11468                (url home-page)
11469                (commit commit)))
11470          (file-name (git-file-name name version))
11471          (sha256
11472           (base32 "1q12bqjbj47lx98yim1kfnnhgfhkl80102fkgp9pdqxg0fp6g5fc"))))
11473       (build-system asdf-build-system/sbcl)
11474       (inputs
11475        `(("closer-mop" ,sbcl-closer-mop)))
11476       (native-inputs
11477        `(("lift" ,sbcl-lift)))
11478       (synopsis "Compatibility layer for Common Lisp MOP implementation differences")
11479       (description
11480        "MOP utilities provide a common interface between Lisps and make the
11481 MOP easier to use.")
11482       (license license:expat))))
11483
11484 (define-public cl-moptilities
11485   (sbcl-package->cl-source-package sbcl-moptilities))
11486
11487 (define-public sbcl-osicat
11488   (let ((commit "de0c18a367eedc857e1902a7319828af072a0d97"))
11489     (package
11490       (name "sbcl-osicat")
11491       (version (git-version "0.7.0" "1" commit))
11492       (home-page "http://www.common-lisp.net/project/osicat/")
11493       (source
11494        (origin
11495          (method git-fetch)
11496          (uri (git-reference
11497                (url "https://github.com/osicat/osicat")
11498                (commit commit)))
11499          (file-name (git-file-name name version))
11500          (sha256
11501           (base32 "15viw5pi5sa7qq9b4n2rr3dj2jkqr180rh9z1lh8w3rgl42i2adc"))))
11502       (build-system asdf-build-system/sbcl)
11503       (arguments
11504        `(#:phases
11505          (modify-phases %standard-phases
11506            (add-before 'validate-runpath 'cleanup-files
11507              (lambda* (#:key outputs #:allow-other-keys)
11508                (let* ((out (assoc-ref outputs "out"))
11509                       (lib (string-append out "/lib/sbcl")))
11510                  (for-each
11511                   delete-file
11512                   (filter (lambda (file)
11513                             (not (member (basename file)
11514                                          '("basic-unixint__grovel"
11515                                            "libosicat.so"
11516                                            "osicat--system.fasl"
11517                                            "osicat.asd"
11518                                            "unixint__grovel"))))
11519                           (find-files lib ".*")))
11520                  #t))))))
11521       (inputs
11522        `(("alexandria" ,sbcl-alexandria)
11523          ("cffi" ,sbcl-cffi)
11524          ("trivial-features" ,sbcl-trivial-features)))
11525       (native-inputs
11526        `(("cffi-grovel" ,sbcl-cffi-grovel)
11527          ("rt" ,sbcl-rt)))
11528       (synopsis "Operating system interface for Common Lisp")
11529       (description
11530        "Osicat is a lightweight operating system interface for Common Lisp on
11531 Unix-platforms.  It is not a POSIX-style API, but rather a simple lispy
11532 accompaniment to the standard ANSI facilities.")
11533       (license license:expat))))
11534
11535 (define-public cl-osicat
11536   (sbcl-package->cl-source-package sbcl-osicat))