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   ;; No release since 2014.
1246   (let ((commit "aeed2d1b76358db48e6b70a64399c05678a6b9ea"))
1247     (package
1248       (name "sbcl-babel")
1249       (version (git-version "0.5.0" "1" commit))
1250       (source
1251        (origin
1252          (method git-fetch)
1253          (uri (git-reference
1254                (url "https://github.com/cl-babel/babel.git")
1255                (commit commit)))
1256          (file-name (git-file-name "babel" version))
1257          (sha256
1258           (base32 "0lkvv4xdpv4cv1y2bqillmabx8sdb2y4l6pbinq6mjh33w2brpvb"))))
1259       (build-system asdf-build-system/sbcl)
1260       (native-inputs
1261        `(("tests:cl-hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
1262       (inputs
1263        `(("sbcl-alexandria" ,sbcl-alexandria)
1264          ("sbcl-trivial-features" ,sbcl-trivial-features)))
1265       (home-page "https://common-lisp.net/project/babel/")
1266       (synopsis "Charset encoding and decoding library")
1267       (description "Babel is a charset encoding and decoding library, not unlike
1268 GNU libiconv, but completely written in Common Lisp.")
1269       (license license:expat))))
1270
1271 (define-public cl-babel
1272   (sbcl-package->cl-source-package sbcl-babel))
1273
1274 (define-public ecl-babel
1275   (sbcl-package->ecl-package sbcl-babel))
1276
1277 (define-public sbcl-cl-yacc
1278   (package
1279     (name "sbcl-cl-yacc")
1280     (version "0.3")
1281     (source
1282      (origin
1283        (method git-fetch)
1284        (uri (git-reference
1285              (url "https://github.com/jech/cl-yacc")
1286              (commit (string-append "cl-yacc-" version))))
1287        (sha256
1288         (base32
1289          "16946pzf8vvadnyfayvj8rbh4zjzw90h0azz2qk1mxrvhh5wklib"))
1290        (file-name (string-append "cl-yacc-" version "-checkout"))))
1291     (build-system asdf-build-system/sbcl)
1292     (arguments
1293      `(#:asd-file "yacc.asd"
1294        #:asd-system-name "yacc"))
1295     (synopsis "LALR(1) parser generator for Common Lisp, similar in spirit to Yacc")
1296     (description
1297      "CL-Yacc is a LALR(1) parser generator for Common Lisp, similar in spirit
1298 to AT&T Yacc, Berkeley Yacc, GNU Bison, Zebu, lalr.cl or lalr.scm.
1299
1300 CL-Yacc uses the algorithm due to Aho and Ullman, which is the one also used
1301 by AT&T Yacc, Berkeley Yacc and Zebu.  It does not use the faster algorithm due
1302 to DeRemer and Pennello, which is used by Bison and lalr.scm (not lalr.cl).")
1303     (home-page "https://www.irif.fr/~jch//software/cl-yacc/")
1304     (license license:expat)))
1305
1306 (define-public cl-yacc
1307   (sbcl-package->cl-source-package sbcl-cl-yacc))
1308
1309 (define-public ecl-cl-yacc
1310   (sbcl-package->ecl-package sbcl-cl-yacc))
1311
1312 (define-public sbcl-jpl-util
1313   (let ((commit "0311ed374e19a49d43318064d729fe3abd9a3b62"))
1314     (package
1315       (name "sbcl-jpl-util")
1316       (version "20151005")
1317       (source
1318        (origin
1319          (method git-fetch)
1320          (uri (git-reference
1321                ;; Quicklisp uses this fork.
1322                (url "https://github.com/hawkir/cl-jpl-util")
1323                (commit commit)))
1324          (file-name
1325           (git-file-name "jpl-util" version))
1326          (sha256
1327           (base32
1328            "0nc0rk9n8grkg3045xsw34whmcmddn2sfrxki4268g7kpgz0d2yz"))))
1329       (build-system asdf-build-system/sbcl)
1330       (synopsis "Collection of Common Lisp utility functions and macros")
1331       (description
1332        "@command{cl-jpl-util} is a collection of Common Lisp utility functions
1333 and macros, primarily for software projects written in CL by the author.")
1334       (home-page "https://www.thoughtcrime.us/software/cl-jpl-util/")
1335       (license license:isc))))
1336
1337 (define-public cl-jpl-util
1338   (sbcl-package->cl-source-package sbcl-jpl-util))
1339
1340 (define-public ecl-jpl-util
1341   (sbcl-package->ecl-package sbcl-jpl-util))
1342
1343 (define-public sbcl-jpl-queues
1344   (package
1345     (name "sbcl-jpl-queues")
1346     (version "0.1")
1347     (source
1348      (origin
1349        (method url-fetch)
1350        (uri (string-append
1351              "http://www.thoughtcrime.us/software/jpl-queues/jpl-queues-"
1352              version
1353              ".tar.gz"))
1354        (sha256
1355         (base32
1356          "1wvvv7j117h9a42qaj1g4fh4mji28xqs7s60rn6d11gk9jl76h96"))))
1357     (build-system asdf-build-system/sbcl)
1358     (inputs
1359      `(("jpl-util" ,sbcl-jpl-util)
1360        ("bordeaux-threads" ,sbcl-bordeaux-threads)))
1361     (arguments
1362      ;; Tests seem to be broken.
1363      `(#:tests? #f))
1364     (synopsis "Common Lisp library implementing a few different kinds of queues")
1365     (description
1366      "A Common Lisp library implementing a few different kinds of queues:
1367
1368 @itemize
1369 @item Bounded and unbounded FIFO queues.
1370 @item Lossy bounded FIFO queues that drop elements when full.
1371 @item Unbounded random-order queues that use less memory than unbounded FIFO queues.
1372 @end itemize
1373
1374 Additionally, a synchronization wrapper is provided to make any queue
1375 conforming to the @command{jpl-queues} API thread-safe for lightweight
1376 multithreading applications.  (See Calispel for a more sophisticated CL
1377 multithreaded message-passing library with timeouts and alternation among
1378 several blockable channels.)")
1379     (home-page "https://www.thoughtcrime.us/software/jpl-queues/")
1380     (license license:isc)))
1381
1382 (define-public cl-jpl-queues
1383   (sbcl-package->cl-source-package sbcl-jpl-queues))
1384
1385 (define-public ecl-jpl-queues
1386   (sbcl-package->ecl-package sbcl-jpl-queues))
1387
1388 (define-public sbcl-eos
1389   (let ((commit "b0faca83781ead9a588661e37bd47f90362ccd94"))
1390     (package
1391       (name "sbcl-eos")
1392       (version (git-version "0.0.0" "1" commit))
1393       (source
1394        (origin
1395          (method git-fetch)
1396          (uri (git-reference
1397                (url "https://github.com/adlai/Eos")
1398                (commit commit)))
1399          (sha256
1400           (base32
1401            "1bq8cfg087iyxmxi1mwgx5cfgy3b8ydrf81xljcis8qbgb2vszph"))
1402          (file-name (git-file-name "eos" version))))
1403       (build-system asdf-build-system/sbcl)
1404       (synopsis "Unit Testing for Common Lisp")
1405       (description
1406        "Eos was a unit testing library for Common Lisp.
1407 It began as a fork of FiveAM; however, FiveAM development has continued, while
1408 that of Eos has not.  Thus, Eos is now deprecated in favor of FiveAM.")
1409       (home-page "https://github.com/adlai/Eos")
1410       (license license:expat))))
1411
1412 (define-public cl-eos
1413   (sbcl-package->cl-source-package sbcl-eos))
1414
1415 (define-public ecl-eos
1416   (sbcl-package->ecl-package sbcl-eos))
1417
1418 (define-public sbcl-esrap
1419   (let ((commit "133be8b05c2aae48696fe5b739eea2fa573fa48d"))
1420     (package
1421       (name "sbcl-esrap")
1422       (version (git-version "0.0.0" "1" commit))
1423       (source
1424        (origin
1425          (method git-fetch)
1426          (uri (git-reference
1427                (url "https://github.com/nikodemus/esrap")
1428                (commit commit)))
1429          (sha256
1430           (base32
1431            "02d5clihsdryhf7pix8c5di2571fdsffh75d40fkzhws90r5mksl"))
1432          (file-name (git-file-name "esrap" version))))
1433       (build-system asdf-build-system/sbcl)
1434       (native-inputs
1435        `(("eos" ,sbcl-eos)))            ;For testing only.
1436       (inputs
1437        `(("alexandria" ,sbcl-alexandria)))
1438       (synopsis "Common Lisp packrat parser")
1439       (description
1440        "A packrat parser for Common Lisp.
1441 In addition to regular Packrat / Parsing Grammar / TDPL features ESRAP supports:
1442
1443 @itemize
1444 @item dynamic redefinition of nonterminals
1445 @item inline grammars
1446 @item semantic predicates
1447 @item introspective facilities (describing grammars, tracing, setting breaks)
1448 @end itemize\n")
1449       (home-page "https://nikodemus.github.io/esrap/")
1450       (license license:expat))))
1451
1452 (define-public cl-esrap
1453   (sbcl-package->cl-source-package sbcl-esrap))
1454
1455 (define-public ecl-esrap
1456   (sbcl-package->ecl-package sbcl-esrap))
1457
1458 (define-public sbcl-split-sequence
1459   (package
1460     (name "sbcl-split-sequence")
1461     (version "2.0.0")
1462     (source
1463      (origin
1464        (method git-fetch)
1465        (uri (git-reference
1466              (url "https://github.com/sharplispers/split-sequence")
1467              (commit (string-append "v" version))))
1468        (sha256
1469         (base32
1470          "0jcpnx21hkfwqj5fvp7kc6pn1qcz9hk7g2s5x8h0349x1j2irln0"))
1471        (file-name (git-file-name "split-sequence" version))))
1472     (build-system asdf-build-system/sbcl)
1473     (native-inputs
1474      `(("fiveam" ,sbcl-fiveam)))
1475     (synopsis "Member of the Common Lisp Utilities family of programs")
1476     (description
1477      "Splits sequence into a list of subsequences delimited by objects
1478 satisfying the test.")
1479     (home-page "https://cliki.net/split-sequence")
1480     (license license:expat)))
1481
1482 (define-public cl-split-sequence
1483   (sbcl-package->cl-source-package sbcl-split-sequence))
1484
1485 (define-public ecl-split-sequence
1486   (sbcl-package->ecl-package sbcl-split-sequence))
1487
1488 (define-public sbcl-html-encode
1489   (package
1490     (name "sbcl-html-encode")
1491     (version "1.2")
1492     (source
1493      (origin
1494        (method url-fetch)
1495        (uri (string-append
1496              "http://beta.quicklisp.org/archive/html-encode/2010-10-06/html-encode-"
1497              version ".tgz"))
1498        (sha256
1499         (base32
1500          "06mf8wn95yf5swhmzk4vp0xr4ylfl33dgfknkabbkd8n6jns8gcf"))
1501        (file-name (string-append "colorize" version "-checkout"))))
1502     (build-system asdf-build-system/sbcl)
1503     (synopsis "Common Lisp library for encoding text in various web-savvy encodings")
1504     (description
1505      "A library for encoding text in various web-savvy encodings.")
1506     (home-page "http://quickdocs.org/html-encode/")
1507     (license license:expat)))
1508
1509 (define-public cl-html-encode
1510   (sbcl-package->cl-source-package sbcl-html-encode))
1511
1512 (define-public ecl-html-encode
1513   (sbcl-package->ecl-package sbcl-html-encode))
1514
1515 (define-public sbcl-colorize
1516   (let ((commit "ea676b584e0899cec82f21a9e6871172fe3c0eb5"))
1517     (package
1518       (name "sbcl-colorize")
1519       (version (git-version "0.0.0" "1" commit))
1520       (source
1521        (origin
1522          (method git-fetch)
1523          (uri (git-reference
1524                (url "https://github.com/kingcons/colorize")
1525                (commit commit)))
1526          (sha256
1527           (base32
1528            "1pdg4kiaczmr3ivffhirp7m3lbr1q27rn7dhaay0vwghmi31zcw9"))
1529          (file-name (git-file-name "colorize" version))))
1530       (build-system asdf-build-system/sbcl)
1531       (inputs
1532        `(("alexandria" ,sbcl-alexandria)
1533          ("split-sequence" ,sbcl-split-sequence)
1534          ("html-encode" ,sbcl-html-encode)))
1535       (synopsis "Common Lisp for syntax highlighting")
1536       (description
1537        "@command{colorize} is a Lisp library for syntax highlighting
1538 supporting the following languages: Common Lisp, Emacs Lisp, Scheme, Clojure,
1539 C, C++, Java, Python, Erlang, Haskell, Objective-C, Diff, Webkit.")
1540       (home-page "https://github.com/kingcons/colorize")
1541       ;; TODO: Missing license?
1542       (license license:expat))))
1543
1544 (define-public cl-colorize
1545   (sbcl-package->cl-source-package sbcl-colorize))
1546
1547 (define-public ecl-colorize
1548   (sbcl-package->ecl-package sbcl-colorize))
1549
1550 (define-public sbcl-3bmd
1551   (let ((commit "192ea13435b605a96ef607df51317056914cabbd"))
1552     (package
1553       (name "sbcl-3bmd")
1554       (version (git-version "0.0.0" "1" commit))
1555       (source
1556        (origin
1557          (method git-fetch)
1558          (uri (git-reference
1559                (url "https://github.com/3b/3bmd")
1560                (commit commit)))
1561          (sha256
1562           (base32
1563            "1rgv3gi7wf963ikmmpk132wgn0icddf226gq3bmcnk1fr3v9gf2f"))
1564          (file-name (git-file-name "3bmd" version))))
1565       (build-system asdf-build-system/sbcl)
1566       (arguments
1567        ;; FIXME: We need to specify the name because the build-system thinks
1568        ;; "3" is a version marker.
1569        `(#:asd-system-name "3bmd"))
1570       (inputs
1571        `(("esrap" ,sbcl-esrap)
1572          ("split-sequence" ,sbcl-split-sequence)))
1573       (synopsis "Markdown processor in Command Lisp using esrap parser")
1574       (description
1575        "Common Lisp Markdown -> HTML converter, using @command{esrap} for
1576 parsing, and grammar based on @command{peg-markdown}.")
1577       (home-page "https://github.com/3b/3bmd")
1578       (license license:expat))))
1579
1580 (define-public cl-3bmd
1581   (sbcl-package->cl-source-package sbcl-3bmd))
1582
1583 (define-public ecl-3bmd
1584   (sbcl-package->ecl-package sbcl-3bmd))
1585
1586 (define-public sbcl-3bmd-ext-code-blocks
1587   (let ((commit "192ea13435b605a96ef607df51317056914cabbd"))
1588     (package
1589       (inherit sbcl-3bmd)
1590       (name "sbcl-3bmd-ext-code-blocks")
1591       (arguments
1592        `(#:asd-system-name "3bmd-ext-code-blocks"
1593          #:asd-file "3bmd-ext-code-blocks.asd"))
1594       (inputs
1595        `(("3bmd" ,sbcl-3bmd)
1596          ("colorize" ,sbcl-colorize)))
1597       (synopsis "3bmd extension which adds support for GitHub-style fenced
1598 code blocks")
1599       (description
1600        "3bmd extension which adds support for GitHub-style fenced code blocks,
1601 with @command{colorize} support."))))
1602
1603 (define-public cl-3bmd-ext-code-blocks
1604   (sbcl-package->cl-source-package sbcl-3bmd-ext-code-blocks))
1605
1606 (define-public ecl-3bmd-ext-code-blocks
1607   (sbcl-package->ecl-package sbcl-3bmd-ext-code-blocks))
1608
1609 (define-public sbcl-cl-fad
1610   (package
1611     (name "sbcl-cl-fad")
1612     (version "0.7.6")
1613     (source
1614      (origin
1615        (method git-fetch)
1616        (uri (git-reference
1617              (url "https://github.com/edicl/cl-fad/")
1618              (commit (string-append "v" version))))
1619        (sha256
1620         (base32
1621          "1gc8i82v6gks7g0lnm54r4prk2mklidv2flm5fvbr0a7rsys0vpa"))
1622        (file-name (string-append "cl-fad" version "-checkout"))))
1623     (build-system asdf-build-system/sbcl)
1624     (inputs
1625      `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
1626     (synopsis "Portable pathname library for Common Lisp")
1627     (description
1628      "CL-FAD (for \"Files and Directories\") is a thin layer atop Common
1629 Lisp's standard pathname functions.  It is intended to provide some
1630 unification between current CL implementations on Windows, OS X, Linux, and
1631 Unix.  Most of the code was written by Peter Seibel for his book Practical
1632 Common Lisp.")
1633     (home-page "https://edicl.github.io/cl-fad/")
1634     (license license:bsd-2)))
1635
1636 (define-public cl-fad
1637   (sbcl-package->cl-source-package sbcl-cl-fad))
1638
1639 (define-public ecl-cl-fad
1640   (sbcl-package->ecl-package sbcl-cl-fad))
1641
1642 (define-public sbcl-rt
1643   (let ((commit "a6a7503a0b47953bc7579c90f02a6dba1f6e4c5a")
1644         (revision "1"))
1645     (package
1646       (name "sbcl-rt")
1647       (version (git-version "1990.12.19" revision commit))
1648       (source
1649        (origin
1650          (method git-fetch)
1651          (uri (git-reference
1652                (url "http://git.kpe.io/rt.git")
1653                (commit commit)))
1654          (file-name (git-file-name name version))
1655          (sha256
1656           (base32 "13si2rrxaagbr0bkvg6sqicxxpyshabx6ad6byc9n2ik5ysna69b"))))
1657       (build-system asdf-build-system/sbcl)
1658       (synopsis "MIT Regression Tester")
1659       (description
1660        "RT provides a framework for writing regression test suites.")
1661       (home-page "https://www.cliki.net/rt")
1662       (license license:expat))))
1663
1664 (define-public cl-rt
1665   (sbcl-package->cl-source-package sbcl-rt))
1666
1667 (define-public ecl-rt
1668   (sbcl-package->ecl-package sbcl-rt))
1669
1670 (define-public sbcl-nibbles
1671   (package
1672     (name "sbcl-nibbles")
1673     (version "0.14")
1674     (source
1675      (origin
1676        (method git-fetch)
1677        (uri (git-reference
1678              (url "https://github.com/sharplispers/nibbles/")
1679              (commit (string-append "v" version))))
1680        (sha256
1681         (base32
1682          "1v7qfgpvdr6nz7v63dj69d26dis0kff3rd8xamr1llfdvza2pm8f"))
1683        (file-name (git-file-name "nibbles" version))))
1684     (build-system asdf-build-system/sbcl)
1685     (native-inputs
1686      ;; Tests only.
1687      `(("rt" ,sbcl-rt)))
1688     (synopsis "Common Lisp library for accessing octet-addressed blocks of data")
1689     (description
1690      "When dealing with network protocols and file formats, it's common to
1691 have to read or write 16-, 32-, or 64-bit datatypes in signed or unsigned
1692 flavors.  Common Lisp sort of supports this by specifying :element-type for
1693 streams, but that facility is underspecified and there's nothing similar for
1694 read/write from octet vectors.  What most people wind up doing is rolling their
1695 own small facility for their particular needs and calling it a day.
1696
1697 This library attempts to be comprehensive and centralize such
1698 facilities.  Functions to read 16-, 32-, and 64-bit quantities from octet
1699 vectors in signed or unsigned flavors are provided; these functions are also
1700 SETFable.  Since it's sometimes desirable to read/write directly from streams,
1701 functions for doing so are also provided.  On some implementations,
1702 reading/writing IEEE singles/doubles (i.e. single-float and double-float) will
1703 also be supported.")
1704     (home-page "https://github.com/sharplispers/nibbles")
1705     (license license:bsd-3)))
1706
1707 (define-public cl-nibbles
1708   (sbcl-package->cl-source-package sbcl-nibbles))
1709
1710 (define-public ecl-nibbles
1711   (sbcl-package->ecl-package sbcl-nibbles))
1712
1713 (define-public sbcl-ironclad
1714   (package
1715     (name "sbcl-ironclad")
1716     (version "0.49")
1717     (source
1718      (origin
1719        (method git-fetch)
1720        (uri (git-reference
1721              (url "https://github.com/sharplispers/ironclad/")
1722              (commit (string-append "v" version))))
1723        (sha256
1724         (base32 "0kbzqg2aasrhjwy3nrzy2ddy809n1j045w4qkyc3r2syqd203d4q"))
1725        (file-name (git-file-name name version))))
1726     (build-system asdf-build-system/sbcl)
1727     (native-inputs
1728      ;; Tests only.
1729      `(("rt" ,sbcl-rt)))
1730     (inputs
1731      `(("bordeaux-threads" ,sbcl-bordeaux-threads)
1732        ("flexi-streams" ,sbcl-flexi-streams)
1733        ("trivial-garbage" ,sbcl-trivial-garbage)))
1734     (synopsis "Cryptographic toolkit written in Common Lisp")
1735     (description
1736      "Ironclad is a cryptography library written entirely in Common Lisp.
1737 It includes support for several popular ciphers, digests, MACs and public key
1738 cryptography algorithms.  For several implementations that support Gray
1739 streams, support is included for convenient stream wrappers.")
1740     (home-page "https://github.com/sharplispers/ironclad")
1741     (license license:bsd-3)))
1742
1743 (define-public cl-ironclad
1744   (sbcl-package->cl-source-package sbcl-ironclad))
1745
1746 (define-public ecl-ironclad
1747   (sbcl-package->ecl-package sbcl-ironclad))
1748
1749 (define-public sbcl-named-readtables
1750   (let ((commit "4dfb89fa1af6b305b6492b8af042f5190c11e9fc")
1751         (revision "1"))
1752     (package
1753       (name "sbcl-named-readtables")
1754       (version (string-append "0.9-" revision "." (string-take commit 7)))
1755       (source
1756        (origin
1757          (method git-fetch)
1758          (uri (git-reference
1759                (url "https://github.com/melisgl/named-readtables.git")
1760                (commit commit)))
1761          (sha256
1762           (base32 "083kgh5462iqbb4px6kq8s7sggvpvkm36hx4qi9rnaw53b6ilqkk"))
1763          (file-name (git-file-name "named-readtables" version))))
1764       (build-system asdf-build-system/sbcl)
1765       (arguments
1766        ;; Tests seem to be broken.
1767        `(#:tests? #f))
1768       (home-page "https://github.com/melisgl/named-readtables/")
1769       (synopsis "Library that creates a namespace for named readtables")
1770       (description "Named readtables is a library that creates a namespace for
1771 named readtables, which is akin to package namespacing in Common Lisp.")
1772       (license license:bsd-3))))
1773
1774 (define-public cl-named-readtables
1775   (sbcl-package->cl-source-package sbcl-named-readtables))
1776
1777 (define-public ecl-named-readtables
1778   (sbcl-package->ecl-package sbcl-named-readtables))
1779
1780 (define-public sbcl-pythonic-string-reader
1781   (let ((commit "47a70ba1e32362e03dad6ef8e6f36180b560f86a"))
1782     (package
1783       (name "sbcl-pythonic-string-reader")
1784       (version (git-version "0.0.0" "1" commit))
1785       (source
1786        (origin
1787          (method git-fetch)
1788          (uri (git-reference
1789                (url "https://github.com/smithzvk/pythonic-string-reader/")
1790                (commit commit)))
1791          (sha256
1792           (base32 "1b5iryqw8xsh36swckmz8rrngmc39k92si33fgy5pml3n9l5rq3j"))
1793          (file-name (git-file-name "pythonic-string-reader" version))))
1794       (build-system asdf-build-system/sbcl)
1795       (inputs
1796        `(("named-readtables" ,sbcl-named-readtables)))
1797       (home-page "https://github.com/smithzvk/pythonic-string-reader")
1798       (synopsis "Read table modification inspired by Python's three quote strings")
1799       (description "This piece of code sets up some reader macros that make it
1800 simpler to input string literals which contain backslashes and double quotes
1801 This is very useful for writing complicated docstrings and, as it turns out,
1802 writing code that contains string literals that contain code themselves.")
1803       (license license:bsd-3))))
1804
1805 (define-public cl-pythonic-string-reader
1806   (sbcl-package->cl-source-package sbcl-pythonic-string-reader))
1807
1808 (define-public ecl-pythonic-string-reader
1809   (sbcl-package->ecl-package sbcl-pythonic-string-reader))
1810
1811 ;; SLIME does not have a ASDF system definition to build all of Swank.  As a
1812 ;; result, the asdf-build-system/sbcl will produce an almost empty package.
1813 ;; Some work was done to fix this at
1814 ;; https://github.com/sionescu/slime/tree/swank-asdf but it was never merged
1815 ;; and is now lagging behind.  Building SBCL fasls might not be worth the
1816 ;; hassle, so let's just ship the source then.
1817 (define-public cl-slime-swank
1818   (package
1819     (name "cl-slime-swank")
1820     (version "2.24")
1821     (source
1822      (origin
1823        (file-name (string-append name "-" version ".tar.gz"))
1824        (method git-fetch)
1825        (uri (git-reference
1826              (url "https://github.com/slime/slime/")
1827              (commit (string-append "v" version))))
1828        (sha256
1829         (base32
1830          "0js24x42m7b5iymb4rxz501dff19vav5pywnzv50b673rbkaaqvh"))))
1831     (build-system asdf-build-system/source)
1832     (home-page "https://github.com/slime/slime")
1833     (synopsis "Common Lisp Swank server")
1834     (description
1835      "This is only useful if you want to start a Swank server in a Lisp
1836 processes that doesn't run under Emacs.  Lisp processes created by
1837 @command{M-x slime} automatically start the server.")
1838     (license (list license:gpl2+ license:public-domain))))
1839
1840 (define-public sbcl-slime-swank
1841   (deprecated-package "sbcl-slime-swank" cl-slime-swank))
1842
1843 (define-public sbcl-mgl-pax
1844   (let ((commit "818448418d6b9de74620f606f5b23033c6082769"))
1845     (package
1846       (name "sbcl-mgl-pax")
1847       (version (git-version "0.0.0" "1" commit))
1848       (source
1849        (origin
1850          (method git-fetch)
1851          (uri (git-reference
1852                (url "https://github.com/melisgl/mgl-pax")
1853                (commit commit)))
1854          (sha256
1855           (base32
1856            "1p97zfkh130bdxqqxwaw2j9psv58751wakx7czbfpq410lg7dd7i"))
1857          (file-name (git-file-name "mgl-pax" version))))
1858       (build-system asdf-build-system/sbcl)
1859       (inputs
1860        `(("3bmd" ,sbcl-3bmd)
1861          ("3bmd-ext-code-blocks" ,sbcl-3bmd-ext-code-blocks)
1862          ("babel" ,sbcl-babel)
1863          ("cl-fad" ,sbcl-cl-fad)
1864          ("ironclad" ,sbcl-ironclad)
1865          ("named-readtables" ,sbcl-named-readtables)
1866          ("pythonic-string-reader" ,sbcl-pythonic-string-reader)))
1867       (propagated-inputs
1868        ;; Packages having mgl-pax as input complain that it can't find
1869        ;; swank if we put it in inputs, so let's put it in propageted-inputs.
1870        `(("swank" ,cl-slime-swank)))
1871       (synopsis "Exploratory programming environment and documentation generator")
1872       (description
1873        "PAX provides an extremely poor man's Explorable Programming
1874 environment.  Narrative primarily lives in so called sections that mix markdown
1875 docstrings with references to functions, variables, etc, all of which should
1876 probably have their own docstrings.
1877
1878 The primary focus is on making code easily explorable by using SLIME's
1879 @command{M-.} (@command{slime-edit-definition}).  See how to enable some
1880 fanciness in Emacs Integration.  Generating documentation from sections and all
1881 the referenced items in Markdown or HTML format is also implemented.
1882
1883 With the simplistic tools provided, one may accomplish similar effects as with
1884 Literate Programming, but documentation is generated from code, not vice versa
1885 and there is no support for chunking yet.  Code is first, code must look
1886 pretty, documentation is code.")
1887       (home-page "http://quotenil.com/")
1888       (license license:expat))))
1889
1890 (define-public cl-mgl-pax
1891   (sbcl-package->cl-source-package sbcl-mgl-pax))
1892
1893 (define-public ecl-mgl-pax
1894   (sbcl-package->ecl-package sbcl-mgl-pax))
1895
1896 (define-public sbcl-lisp-unit
1897   (let ((commit "89653a232626b67400bf9a941f9b367da38d3815"))
1898     (package
1899       (name "sbcl-lisp-unit")
1900       (version (git-version "0.0.0" "1" commit))
1901       (source
1902        (origin
1903          (method git-fetch)
1904          (uri (git-reference
1905                (url "https://github.com/OdonataResearchLLC/lisp-unit")
1906                (commit commit)))
1907          (sha256
1908           (base32
1909            "0p6gdmgr7p383nvd66c9y9fp2bjk4jx1lpa5p09g43hr9y9pp9ry"))
1910          (file-name (git-file-name "lisp-unit" version))))
1911       (build-system asdf-build-system/sbcl)
1912       (synopsis "Common Lisp Test framework inspired by JUnit to be simple of use")
1913       (description
1914        "@command{lisp-unit} is a Common Lisp library that supports unit
1915 testing.  It is an extension of the library written by Chris Riesbeck.")
1916       (home-page "https://github.com/OdonataResearchLLC/lisp-unit")
1917       (license license:expat))))
1918
1919 (define-public cl-lisp-unit
1920   (sbcl-package->cl-source-package sbcl-lisp-unit))
1921
1922 (define-public ecl-lisp-unit
1923   (sbcl-package->ecl-package sbcl-lisp-unit))
1924
1925 (define-public sbcl-anaphora
1926   (package
1927     (name "sbcl-anaphora")
1928     (version "0.9.6")
1929     (source
1930      (origin
1931        (method git-fetch)
1932        (uri (git-reference
1933              (url "https://github.com/tokenrove/anaphora")
1934              (commit version)))
1935        (sha256
1936         (base32
1937          "19wfrk3asimznkli0x2rfy637hwpdgqyvwj3vhq9x7vjvyf5vv6x"))
1938        (file-name (git-file-name "anaphora" version))))
1939     (build-system asdf-build-system/sbcl)
1940     (native-inputs
1941      `(("rt" ,sbcl-rt)))
1942     (synopsis "The anaphoric macro collection from Hell")
1943     (description
1944      "Anaphora is the anaphoric macro collection from Hell: it includes many
1945 new fiends in addition to old friends like @command{aif} and
1946 @command{awhen}.")
1947     (home-page "https://github.com/tokenrove/anaphora")
1948     (license license:public-domain)))
1949
1950 (define-public cl-anaphora
1951   (sbcl-package->cl-source-package sbcl-anaphora))
1952
1953 (define-public ecl-anaphora
1954   (sbcl-package->ecl-package sbcl-anaphora))
1955
1956 (define-public sbcl-lift
1957   (let ((commit "7d49a66c62759535624037826891152223d4206c"))
1958     (package
1959       (name "sbcl-lift")
1960       (version (git-version "1.7.1" "1" commit))
1961       (source
1962        (origin
1963          (method git-fetch)
1964          (uri (git-reference
1965                (url "https://github.com/gwkkwg/lift")
1966                (commit commit)))
1967          (sha256
1968           (base32
1969            "127v5avpz1i4m0lkaxqrq8hrl69rdazqaxf6s8awf0nd7wj2g4dp"))
1970          (file-name (git-file-name "lift" version))
1971          (modules '((guix build utils)))
1972          (snippet
1973           ;; Don't keep the bundled website
1974           `(begin
1975              (delete-file-recursively "website")
1976              #t))))
1977       (build-system asdf-build-system/sbcl)
1978       (arguments
1979        ;; The tests require a debugger, but we run with the debugger disabled.
1980        '(#:tests? #f))
1981       (synopsis "LIsp Framework for Testing")
1982       (description
1983        "The LIsp Framework for Testing (LIFT) is a unit and system test tool for LISP.
1984 Though inspired by SUnit and JUnit, it's built with Lisp in mind.  In LIFT,
1985 testcases are organized into hierarchical testsuites each of which can have
1986 its own fixture.  When run, a testcase can succeed, fail, or error.  LIFT
1987 supports randomized testing, benchmarking, profiling, and reporting.")
1988       (home-page "https://github.com/gwkkwg/lift")
1989       (license license:expat))))
1990
1991 (define-public cl-lift
1992   (sbcl-package->cl-source-package sbcl-lift))
1993
1994 (define-public ecl-lift
1995   (sbcl-package->ecl-package sbcl-lift))
1996
1997 (define-public sbcl-let-plus
1998   (let ((commit "5f14af61d501ecead02ec6b5a5c810efc0c9fdbb"))
1999     (package
2000       (name "sbcl-let-plus")
2001       (version (git-version "0.0.0" "1" commit))
2002       (source
2003        (origin
2004          (method git-fetch)
2005          (uri (git-reference
2006                (url "https://github.com/sharplispers/let-plus")
2007                (commit commit)))
2008          (sha256
2009           (base32
2010            "0i050ca2iys9f5mb7dgqgqdxfnc3b0rnjdwv95sqd490vkiwrsaj"))
2011          (file-name (git-file-name "let-plus" version))))
2012       (build-system asdf-build-system/sbcl)
2013       (inputs
2014        `(("alexandria" ,sbcl-alexandria)
2015          ("anaphora" ,sbcl-anaphora)))
2016       (native-inputs
2017        `(("lift" ,sbcl-lift)))
2018       (synopsis "Destructuring extension of let*")
2019       (description
2020        "This library implements the let+ macro, which is a dectructuring
2021 extension of let*.  It features:
2022
2023 @itemize
2024 @item Clean, consistent syntax and small implementation (less than 300 LOC,
2025 not counting tests)
2026 @item Placeholder macros allow editor hints and syntax highlighting
2027 @item @command{&ign} for ignored values (in forms where that makes sense)
2028 @item Very easy to extend
2029 @end itemize\n")
2030       (home-page "https://github.com/sharplispers/let-plus")
2031       (license license:boost1.0))))
2032
2033 (define-public cl-let-plus
2034   (sbcl-package->cl-source-package sbcl-let-plus))
2035
2036 (define-public ecl-let-plus
2037   (sbcl-package->ecl-package sbcl-let-plus))
2038
2039 (define-public sbcl-cl-colors
2040   (let ((commit "827410584553f5c717eec6182343b7605f707f75"))
2041     (package
2042       (name "sbcl-cl-colors")
2043       (version (git-version "0.0.0" "1" commit))
2044       (source
2045        (origin
2046          (method git-fetch)
2047          (uri (git-reference
2048                (url "https://github.com/tpapp/cl-colors")
2049                (commit commit)))
2050          (sha256
2051           (base32
2052            "0l446lday4hybsm9bq3jli97fvv8jb1d33abg79vbylpwjmf3y9a"))
2053          (file-name (git-file-name "cl-colors" version))))
2054       (build-system asdf-build-system/sbcl)
2055       (inputs
2056        `(("alexandria" ,sbcl-alexandria)
2057          ("let-plus" ,sbcl-let-plus)))
2058       (synopsis "Simple color library for Common Lisp")
2059       (description
2060        "This is a very simple color library for Common Lisp, providing
2061
2062 @itemize
2063 @item Types for representing colors in HSV and RGB spaces.
2064 @item Simple conversion functions between the above types (and also
2065 hexadecimal representation for RGB).
2066 @item Some predefined colors (currently X11 color names – of course the
2067 library does not depend on X11).Because color in your terminal is nice.
2068 @end itemize
2069
2070 This library is no longer supported by its author.")
2071       (home-page "https://github.com/tpapp/cl-colors")
2072       (license license:boost1.0))))
2073
2074 (define-public cl-colors
2075   (sbcl-package->cl-source-package sbcl-cl-colors))
2076
2077 (define-public ecl-cl-colors
2078   (sbcl-package->ecl-package sbcl-cl-colors))
2079
2080 (define-public sbcl-cl-ansi-text
2081   (let ((commit "53badf7878f27f22f2d4a2a43e6df458e43acbe9"))
2082     (package
2083       (name "sbcl-cl-ansi-text")
2084       (version (git-version "1.0.0" "1" commit))
2085       (source
2086        (origin
2087          (method git-fetch)
2088          (uri (git-reference
2089                (url "https://github.com/pnathan/cl-ansi-text")
2090                (commit commit)))
2091          (sha256
2092           (base32
2093            "11i27n0dbz5lmygiw65zzr8lx0rac6b6yysqranphn31wls6ja3v"))
2094          (file-name (git-file-name "cl-ansi-text" version))))
2095       (build-system asdf-build-system/sbcl)
2096       (inputs
2097        `(("alexandria" ,sbcl-alexandria)
2098          ("cl-colors" ,sbcl-cl-colors)))
2099       (native-inputs
2100        `(("fiveam" ,sbcl-fiveam)))
2101       (synopsis "ANSI terminal color implementation for Common Lisp")
2102       (description
2103        "@command{cl-ansi-text} provides utilities which enable printing to an
2104 ANSI terminal with colored text.  It provides the macro @command{with-color}
2105 which causes everything printed in the body to be displayed with the provided
2106 color.  It further provides functions which will print the argument with the
2107 named color.")
2108       (home-page "https://github.com/pnathan/cl-ansi-text")
2109       (license license:llgpl))))
2110
2111 (define-public cl-ansi-text
2112   (sbcl-package->cl-source-package sbcl-cl-ansi-text))
2113
2114 (define-public ecl-cl-ansi-text
2115   (sbcl-package->ecl-package sbcl-cl-ansi-text))
2116
2117 (define-public sbcl-prove-asdf
2118   (let ((commit "4f9122bd393e63c5c70c1fba23070622317cfaa0"))
2119     (package
2120       (name "sbcl-prove-asdf")
2121       (version (git-version "1.0.0" "1" commit))
2122       (source
2123        (origin
2124          (method git-fetch)
2125          (uri (git-reference
2126                (url "https://github.com/fukamachi/prove")
2127                (commit commit)))
2128          (sha256
2129           (base32
2130            "07sbfw459z8bbjvx1qlmfa8qk2mvbjnnzi2mi0x72blaj8bkl4vc"))
2131          (file-name (git-file-name "prove" version))))
2132       (build-system asdf-build-system/sbcl)
2133       (arguments
2134        `(#:asd-file "prove-asdf.asd"))
2135       (synopsis "Test requirement for the Common Lisp 'prove' library")
2136       (description
2137        "Test requirement for the Common Lisp @command{prove} library.")
2138       (home-page "https://github.com/fukamachi/prove")
2139       (license license:expat))))
2140
2141 (define-public cl-prove-asdf
2142   (sbcl-package->cl-source-package sbcl-prove-asdf))
2143
2144 (define-public ecl-prove-asdf
2145   (sbcl-package->ecl-package sbcl-prove-asdf))
2146
2147 (define-public sbcl-prove
2148   (package
2149     (inherit sbcl-prove-asdf)
2150     (name "sbcl-prove")
2151     (inputs
2152      `(("alexandria" ,sbcl-alexandria)
2153        ("cl-ppcre" ,sbcl-cl-ppcre)
2154        ("cl-ansi-text" ,sbcl-cl-ansi-text)))
2155     (native-inputs
2156      `(("prove-asdf" ,sbcl-prove-asdf)))
2157     (arguments
2158      `(#:asd-file "prove.asd"))
2159     (synopsis "Yet another unit testing framework for Common Lisp")
2160     (description
2161      "This project was originally called @command{cl-test-more}.
2162 @command{prove} is yet another unit testing framework for Common Lisp.  The
2163 advantages of @command{prove} are:
2164
2165 @itemize
2166 @item Various simple functions for testing and informative error messages
2167 @item ASDF integration
2168 @item Extensible test reporters
2169 @item Colorizes the report if it's available (note for SLIME)
2170 @item Reports test durations
2171 @end itemize\n")))
2172
2173 (define-public cl-prove
2174   (sbcl-package->cl-source-package sbcl-prove))
2175
2176 (define-public ecl-prove
2177   (sbcl-package->ecl-package sbcl-prove))
2178
2179 (define-public sbcl-proc-parse
2180   (let ((commit "ac3636834d561bdc2686c956dbd82494537285fd"))
2181     (package
2182       (name "sbcl-proc-parse")
2183       (version (git-version "0.0.0" "1" commit))
2184       (source
2185        (origin
2186          (method git-fetch)
2187          (uri (git-reference
2188                (url "https://github.com/fukamachi/proc-parse")
2189                (commit commit)))
2190          (sha256
2191           (base32
2192            "06rnl0h4cx6xv2wj3jczmmcxqn2703inmmvg1s4npbghmijsybfh"))
2193          (file-name (git-file-name "proc-parse" version))))
2194       (build-system asdf-build-system/sbcl)
2195       (inputs
2196        `(("alexandria" ,sbcl-alexandria)
2197          ("babel" ,sbcl-babel)))
2198       (native-inputs
2199        `(("prove" ,sbcl-prove)
2200          ("prove-asdf" ,sbcl-prove-asdf)))
2201       (arguments
2202        ;; TODO: Tests don't find "proc-parse-test", why?
2203        `(#:tests? #f))
2204       (synopsis "Procedural vector parser")
2205       (description
2206        "This is a string/octets parser library for Common Lisp with speed and
2207 readability in mind.  Unlike other libraries, the code is not a
2208 pattern-matching-like, but a char-by-char procedural parser.")
2209       (home-page "https://github.com/fukamachi/proc-parse")
2210       (license license:bsd-2))))
2211
2212 (define-public cl-proc-parse
2213   (sbcl-package->cl-source-package sbcl-proc-parse))
2214
2215 (define-public ecl-proc-parse
2216   (sbcl-package->ecl-package sbcl-proc-parse))
2217
2218 (define-public sbcl-parse-float
2219   (let ((commit "2aae569f2a4b2eb3bfb5401a959425dcf151b09c"))
2220     (package
2221       (name "sbcl-parse-float")
2222       (version (git-version "0.0.0" "1" commit))
2223       (source
2224        (origin
2225          (method git-fetch)
2226          (uri (git-reference
2227                (url "https://github.com/soemraws/parse-float")
2228                (commit commit)))
2229          (sha256
2230           (base32
2231            "08xw8cchhmqcc0byng69m3f5a2izc9y2290jzz2k0qrbibp1fdk7"))
2232          (file-name (git-file-name "proc-parse" version))))
2233       (build-system asdf-build-system/sbcl)
2234       (inputs
2235        `(("alexandria" ,sbcl-alexandria)
2236          ("babel" ,sbcl-babel)))
2237       (native-inputs
2238        `(("prove" ,sbcl-prove)
2239          ("prove-asdf" ,sbcl-prove-asdf)))
2240       (arguments
2241        ;; TODO: Tests don't find "proc-parse-test", why?
2242        `(#:tests? #f))
2243       (synopsis "Parse a floating point value from a string in Common Lisp")
2244       (description
2245        "This package exports the following function to parse floating-point
2246 values from a string in Common Lisp.")
2247       (home-page "https://github.com/soemraws/parse-float")
2248       (license license:public-domain))))
2249
2250 (define-public cl-parse-float
2251   (sbcl-package->cl-source-package sbcl-parse-float))
2252
2253 (define-public ecl-parse-float
2254   (sbcl-package->ecl-package sbcl-parse-float))
2255
2256 (define-public sbcl-ascii-strings
2257   (let ((revision "1")
2258         (changeset "5048480a61243e6f1b02884012c8f25cdbee6d97"))
2259     (package
2260       (name "sbcl-ascii-strings")
2261       (version (string-append "0-" revision "." (string-take changeset 7)))
2262       (source
2263        (origin
2264          (method hg-fetch)
2265          (uri (hg-reference
2266                (url "https://bitbucket.org/vityok/cl-string-match/")
2267                (changeset changeset)))
2268          (sha256
2269           (base32
2270            "01wn5qx562w43ssy92xlfgv79w7p0nv0wbl76mpmba131n9ziq2y"))
2271          (file-name (git-file-name "cl-string-match" version))))
2272       (build-system asdf-build-system/sbcl)
2273       (inputs
2274        `(("alexandria" ,sbcl-alexandria)
2275          ("babel" ,sbcl-babel)))
2276       (arguments
2277        `(#:asd-file "ascii-strings.asd"))
2278       (synopsis "Operations on ASCII strings")
2279       (description
2280        "Operations on ASCII strings.  Essentially this can be any kind of
2281 single-byte encoded strings.")
2282       (home-page "https://bitbucket.org/vityok/cl-string-match/")
2283       (license license:bsd-3))))
2284
2285 (define-public cl-ascii-strings
2286   (sbcl-package->cl-source-package sbcl-ascii-strings))
2287
2288 (define-public ecl-ascii-strings
2289   (sbcl-package->ecl-package sbcl-ascii-strings))
2290
2291 (define-public sbcl-simple-scanf
2292   (package
2293     (inherit sbcl-ascii-strings)
2294     (name "sbcl-simple-scanf")
2295     (inputs
2296      `(("alexandria" ,sbcl-alexandria)
2297        ("iterate" ,sbcl-iterate)
2298        ("proc-parse" ,sbcl-proc-parse)
2299        ("parse-float" ,sbcl-parse-float)))
2300     (arguments
2301      `(#:asd-file "simple-scanf.asd"))
2302     (synopsis "Simple scanf-like functionality implementation")
2303     (description
2304      "A simple scanf-like functionality implementation.")))
2305
2306 (define-public cl-simple-scanf
2307   (sbcl-package->cl-source-package sbcl-simple-scanf))
2308
2309 (define-public ecl-simple-scanf
2310   (sbcl-package->ecl-package sbcl-simple-scanf))
2311
2312 (define-public sbcl-cl-string-match
2313   (package
2314     (inherit sbcl-ascii-strings)
2315     (name "sbcl-cl-string-match")
2316     (inputs
2317      `(("alexandria" ,sbcl-alexandria)
2318        ("ascii-strings" ,sbcl-ascii-strings)
2319        ("yacc" ,sbcl-cl-yacc)
2320        ("jpl-util" ,sbcl-jpl-util)
2321        ("jpl-queues" ,sbcl-jpl-queues)
2322        ("mgl-pax" ,sbcl-mgl-pax)
2323        ("iterate" ,sbcl-iterate)))
2324     ;; TODO: Tests are not evaluated properly.
2325     (native-inputs
2326      ;; For testing:
2327      `(("lisp-unit" ,sbcl-lisp-unit)
2328        ("simple-scanf" ,sbcl-simple-scanf)))
2329     (arguments
2330      `(#:tests? #f
2331        #:asd-file "cl-string-match.asd"))
2332     (synopsis "Portable, dependency-free set of utilities to manipulate strings in Common Lisp")
2333     (description
2334      "@command{cl-strings} is a small, portable, dependency-free set of
2335 utilities that make it even easier to manipulate text in Common Lisp.  It has
2336 100% test coverage and works at least on sbcl, ecl, ccl, abcl and clisp.")))
2337
2338 (define-public cl-string-match
2339   (sbcl-package->cl-source-package sbcl-cl-string-match))
2340
2341 (define-public ecl-cl-string-match
2342   (sbcl-package->ecl-package sbcl-cl-string-match))
2343
2344 (define-public sbcl-ptester
2345   (let ((commit "fe69fde54f4bce00ce577feb918796c293fc7253")
2346         (revision "1"))
2347     (package
2348       (name "sbcl-ptester")
2349       (version (git-version "2.1.3" revision commit))
2350       (source
2351        (origin
2352          (method git-fetch)
2353          (uri (git-reference
2354                (url "http://git.kpe.io/ptester.git")
2355                (commit commit)))
2356          (file-name (git-file-name name version))
2357          (sha256
2358           (base32 "1l0lfl7cdnr2qf4zh38hi4llxg22c49zkm639bdkmvlkzwj3ndwf"))))
2359       (build-system asdf-build-system/sbcl)
2360       (home-page "http://quickdocs.org/ptester/")
2361       (synopsis "Portable test harness package")
2362       (description
2363        "@command{ptester} is a portable testing framework based on Franz's
2364 tester module.")
2365       (license license:llgpl))))
2366
2367 (define-public cl-ptester
2368   (sbcl-package->cl-source-package sbcl-ptester))
2369
2370 (define-public ecl-ptester
2371   (sbcl-package->ecl-package sbcl-ptester))
2372
2373 (define-public sbcl-puri
2374   (let ((commit "ef5afb9e5286c8e952d4344f019c1a636a717b97")
2375         (revision "1"))
2376     (package
2377       (name "sbcl-puri")
2378       (version (git-version "1.5.7" revision commit))
2379       (source
2380        (origin
2381          (method git-fetch)
2382          (uri (git-reference
2383                (url "http://git.kpe.io/puri.git")
2384                (commit commit)))
2385          (file-name (git-file-name name version))
2386          (sha256
2387           (base32 "1vm25pdl92laj72p5vyd538kf3cjy2655z6bdc99h20ana2p231s"))))
2388       (build-system asdf-build-system/sbcl)
2389       (native-inputs
2390        `(("ptester" ,sbcl-ptester)))
2391       (home-page "http://quickdocs.org/puri/")
2392       (synopsis "Portable URI Library")
2393       (description
2394        "This is a portable Universal Resource Identifier library for Common
2395 Lisp programs.  It parses URI according to the RFC 2396 specification.")
2396       (license license:llgpl))))
2397
2398 (define-public cl-puri
2399   (sbcl-package->cl-source-package sbcl-puri))
2400
2401 (define-public ecl-puri
2402   (sbcl-package->ecl-package sbcl-puri))
2403
2404 (define-public sbcl-queues
2405   (let ((commit "47d4da65e9ea20953b74aeeab7e89a831b66bc94"))
2406     (package
2407       (name "sbcl-queues")
2408       (version (git-version "0.0.0" "1" commit))
2409       (source
2410        (origin
2411          (method git-fetch)
2412          (uri (git-reference
2413                (url "https://github.com/oconnore/queues")
2414                (commit commit)))
2415          (file-name (git-file-name "queues" version))
2416          (sha256
2417           (base32
2418            "0wdhfnzi4v6d97pggzj2aw55si94w4327br94jrmyvwf351wqjvv"))))
2419       (build-system asdf-build-system/sbcl)
2420       (home-page "https://github.com/oconnore/queues")
2421       (synopsis "Common Lisp queue library")
2422       (description
2423        "This is a simple queue library for Common Lisp with features such as
2424 non-consing thread safe queues and fibonacci priority queues.")
2425       (license license:expat))))
2426
2427 (define-public cl-queues
2428   (sbcl-package->cl-source-package sbcl-queues))
2429
2430 (define-public ecl-queues
2431   (sbcl-package->ecl-package sbcl-queues))
2432
2433 (define-public sbcl-queues.simple-queue
2434   (package
2435     (inherit sbcl-queues)
2436     (name "sbcl-queues.simple-queue")
2437     (inputs
2438      `(("sbcl-queues" ,sbcl-queues)))
2439     (arguments
2440      `(#:asd-file "queues.simple-queue.asd"))
2441     (synopsis "Simple queue implementation")
2442     (description
2443      "This is a simple queue library for Common Lisp with features such as
2444 non-consing thread safe queues and fibonacci priority queues.")
2445     (license license:expat)))
2446
2447 (define-public cl-queues.simple-queue
2448   (sbcl-package->cl-source-package sbcl-queues.simple-queue))
2449
2450 (define-public ecl-queues.simple-queue
2451   (sbcl-package->ecl-package sbcl-queues.simple-queue))
2452
2453 (define-public sbcl-queues.simple-cqueue
2454   (package
2455     (inherit sbcl-queues)
2456     (name "sbcl-queues.simple-cqueue")
2457     (inputs
2458      `(("sbcl-queues" ,sbcl-queues)
2459        ("sbcl-queues.simple-queue" ,sbcl-queues.simple-queue)
2460        ("bordeaux-threads" ,sbcl-bordeaux-threads)))
2461     (arguments
2462      `(#:asd-file "queues.simple-cqueue.asd"))
2463     (synopsis "Thread safe queue implementation")
2464     (description
2465      "This is a simple queue library for Common Lisp with features such as
2466 non-consing thread safe queues and fibonacci priority queues.")
2467     (license license:expat)))
2468
2469 (define-public cl-queues.simple-cqueue
2470   (sbcl-package->cl-source-package sbcl-queues.simple-cqueue))
2471
2472 (define-public ecl-queues.simple-cqueue
2473   (sbcl-package->ecl-package sbcl-queues.simple-cqueue))
2474
2475 (define-public sbcl-queues.priority-queue
2476   (package
2477     (inherit sbcl-queues)
2478     (name "sbcl-queues.priority-queue")
2479     (inputs
2480      `(("sbcl-queues" ,sbcl-queues)))
2481     (arguments
2482      `(#:asd-file "queues.priority-queue.asd"))
2483     (synopsis "Priority queue (Fibonacci) implementation")
2484     (description
2485      "This is a simple queue library for Common Lisp with features such as
2486 non-consing thread safe queues and fibonacci priority queues.")
2487     (license license:expat)))
2488
2489 (define-public cl-queues.priority-queue
2490   (sbcl-package->cl-source-package sbcl-queues.priority-queue))
2491
2492 (define-public ecl-queues.priority-queue
2493   (sbcl-package->ecl-package sbcl-queues.priority-queue))
2494
2495 (define-public sbcl-queues.priority-cqueue
2496   (package
2497     (inherit sbcl-queues)
2498     (name "sbcl-queues.priority-cqueue")
2499     (inputs
2500      `(("sbcl-queues" ,sbcl-queues)
2501        ("sbcl-queues.priority-queue" ,sbcl-queues.priority-queue)
2502        ("bordeaux-threads" ,sbcl-bordeaux-threads)))
2503     (arguments
2504      `(#:asd-file "queues.priority-cqueue.asd"))
2505     (synopsis "Thread safe fibonacci priority queue implementation")
2506     (description
2507      "This is a simple queue library for Common Lisp with features such as
2508 non-consing thread safe queues and fibonacci priority queues.")
2509     (license license:expat)))
2510
2511 (define-public cl-queues.priority-cqueue
2512   (sbcl-package->cl-source-package sbcl-queues.priority-cqueue))
2513
2514 (define-public ecl-queues.priority-cqueue
2515   (sbcl-package->ecl-package sbcl-queues.priority-cqueue))
2516
2517 (define sbcl-cffi-bootstrap
2518   (package
2519     (name "sbcl-cffi-bootstrap")
2520     (version "0.21.0")
2521     (source
2522      (origin
2523        (method git-fetch)
2524        (uri (git-reference
2525              (url "https://github.com/cffi/cffi.git")
2526              (commit (string-append "v" version))))
2527        (file-name (git-file-name "cffi-bootstrap" version))
2528        (sha256
2529         (base32 "1qalargz9bhp850qv60ffwpdqi4xirzar4l3g6qcg8yc6xqf2cjk"))))
2530     (build-system asdf-build-system/sbcl)
2531     (inputs
2532      `(("libffi" ,libffi)
2533        ("alexandria" ,sbcl-alexandria)
2534        ("babel" ,sbcl-babel)
2535        ("trivial-features" ,sbcl-trivial-features)))
2536     (native-inputs
2537      `(("pkg-config" ,pkg-config)))
2538     (arguments
2539      '(#:phases
2540        (modify-phases %standard-phases
2541          (add-after 'unpack 'fix-paths
2542            (lambda* (#:key inputs #:allow-other-keys)
2543              (substitute* "libffi/libffi.lisp"
2544                (("libffi.so.6" all) (string-append
2545                                      (assoc-ref inputs "libffi")
2546                                      "/lib/" all)))
2547              (substitute* "toolchain/c-toolchain.lisp"
2548                (("\"cc\"") (format #f "~S" (which "gcc")))))))
2549        #:asd-system-name "cffi"
2550        #:tests? #f))
2551     (home-page "https://common-lisp.net/project/cffi/")
2552     (synopsis "Common Foreign Function Interface for Common Lisp")
2553     (description "The Common Foreign Function Interface (CFFI)
2554 purports to be a portable foreign function interface for Common Lisp.
2555 The CFFI library is composed of a Lisp-implementation-specific backend
2556 in the CFFI-SYS package, and a portable frontend in the CFFI
2557 package.")
2558     (license license:expat)))
2559
2560 (define-public sbcl-cffi-toolchain
2561   (package
2562     (inherit sbcl-cffi-bootstrap)
2563     (name "sbcl-cffi-toolchain")
2564     (inputs
2565      `(("libffi" ,libffi)
2566        ("sbcl-cffi" ,sbcl-cffi-bootstrap)))
2567     (arguments
2568      (substitute-keyword-arguments (package-arguments sbcl-cffi-bootstrap)
2569        ((#:asd-system-name _) #f)
2570        ((#:tests? _) #t)))))
2571
2572 (define-public sbcl-cffi-libffi
2573   (package
2574     (inherit sbcl-cffi-toolchain)
2575     (name "sbcl-cffi-libffi")
2576     (inputs
2577      `(("cffi" ,sbcl-cffi-bootstrap)
2578        ("cffi-grovel" ,sbcl-cffi-grovel)
2579        ("trivial-features" ,sbcl-trivial-features)
2580        ("libffi" ,libffi)))))
2581
2582 (define-public sbcl-cffi-grovel
2583   (package
2584     (inherit sbcl-cffi-toolchain)
2585     (name "sbcl-cffi-grovel")
2586     (inputs
2587      `(("libffi" ,libffi)
2588        ("cffi" ,sbcl-cffi-bootstrap)
2589        ("cffi-toolchain" ,sbcl-cffi-toolchain)
2590        ("alexandria" ,sbcl-alexandria)))
2591     (arguments
2592      (substitute-keyword-arguments (package-arguments sbcl-cffi-toolchain)
2593        ((#:phases phases)
2594         `(modify-phases ,phases
2595            (add-after 'build 'install-headers
2596              (lambda* (#:key outputs #:allow-other-keys)
2597                (install-file "grovel/common.h"
2598                              (string-append
2599                               (assoc-ref outputs "out")
2600                               "/include/grovel"))))))))))
2601
2602 (define-public sbcl-cffi
2603   (package
2604     (inherit sbcl-cffi-toolchain)
2605     (name "sbcl-cffi")
2606     (inputs (package-inputs sbcl-cffi-bootstrap))
2607     (native-inputs
2608      `(("cffi-grovel" ,sbcl-cffi-grovel)
2609        ("cffi-libffi" ,sbcl-cffi-libffi)
2610        ("rt" ,sbcl-rt)
2611        ("bordeaux-threads" ,sbcl-bordeaux-threads)
2612        ,@(package-native-inputs sbcl-cffi-bootstrap)))))
2613
2614 (define-public cl-cffi
2615   (sbcl-package->cl-source-package sbcl-cffi))
2616
2617 (define-public sbcl-cffi-uffi-compat
2618   (package
2619     (inherit sbcl-cffi-toolchain)
2620     (name "sbcl-cffi-uffi-compat")
2621     (native-inputs
2622      `(,@(package-inputs sbcl-cffi-bootstrap))) ; For fix-paths phase
2623     (inputs
2624      `(("cffi" ,sbcl-cffi)))
2625     (synopsis "UFFI Compatibility Layer for CFFI")))
2626
2627 (define-public cl-cffi-uffi-compat
2628   (sbcl-package->cl-source-package sbcl-cffi-uffi-compat))
2629
2630 (define-public sbcl-cl-sqlite
2631   (let ((commit "c738e66d4266ef63a1debc4ef4a1b871a068c112"))
2632     (package
2633       (name "sbcl-cl-sqlite")
2634       (version (git-version "0.2" "1" commit))
2635       (source
2636        (origin
2637          (method git-fetch)
2638          (uri (git-reference
2639                (url "https://github.com/dmitryvk/cl-sqlite")
2640                (commit commit)))
2641          (file-name (git-file-name "cl-sqlite" version))
2642          (sha256
2643           (base32
2644            "1ng45k1hdb84sqjryrfx93g66bsbybmpy301wd0fdybnc5jzr36q"))))
2645       (build-system asdf-build-system/sbcl)
2646       (inputs
2647        `(("iterate" ,sbcl-iterate)
2648          ("cffi" ,sbcl-cffi)
2649          ("sqlite" ,sqlite)))
2650       (native-inputs
2651        `(("fiveam" ,sbcl-fiveam)
2652          ("bordeaux-threads" ,sbcl-bordeaux-threads)))
2653       (arguments
2654        `(#:tests? #f                    ; Upstream seems to have issues with tests: https://github.com/dmitryvk/cl-sqlite/issues/7
2655          #:asd-file "sqlite.asd"
2656          #:asd-system-name "sqlite"
2657          #:phases
2658          (modify-phases %standard-phases
2659            (add-after 'unpack 'fix-paths
2660              (lambda* (#:key inputs #:allow-other-keys)
2661                (substitute* "sqlite-ffi.lisp"
2662                  (("libsqlite3" all) (string-append
2663                                       (assoc-ref inputs "sqlite")"/lib/" all))))))))
2664       (home-page "https://common-lisp.net/project/cl-sqlite/")
2665       (synopsis "Common Lisp binding for SQLite")
2666       (description
2667        "The @command{cl-sqlite} package is an interface to the SQLite embedded
2668 relational database engine.")
2669       (license license:public-domain))))
2670
2671 (define-public cl-sqlite
2672   (sbcl-package->cl-source-package sbcl-cl-sqlite))
2673
2674 (define-public sbcl-parenscript
2675   ;; Source archives are overwritten on every release, we use the Git repo instead.
2676   (let ((commit "7a1ac46353cecd144fc91915ba9f122aafcf4766"))
2677     (package
2678       (name "sbcl-parenscript")
2679       (version (git-version "2.7.1" "1" commit))
2680       (source
2681        (origin
2682          (method git-fetch)
2683          (uri (git-reference
2684                (url "https://gitlab.common-lisp.net/parenscript/parenscript")
2685                (commit commit)))
2686          (file-name (git-file-name "parenscript" version))
2687          (sha256
2688           (base32
2689            "0c22lqarrpbq82dg1sb3y6mp6w2faczp34ymzhnmff88yfq1xzsf"))))
2690       (build-system asdf-build-system/sbcl)
2691       (inputs
2692        `(("cl-ppcre" ,sbcl-cl-ppcre)
2693          ("anaphora" ,sbcl-anaphora)
2694          ("named-readtables" ,sbcl-named-readtables)))
2695       (home-page "https://common-lisp.net/project/parenscript/")
2696       (synopsis "Translator from a subset of Common Lisp to JavaScript")
2697       (description
2698        "Parenscript is a translator from an extended subset of Common Lisp to
2699 JavaScript.  Parenscript code can run almost identically on both the
2700 browser (as JavaScript) and server (as Common Lisp).
2701
2702 Parenscript code is treated the same way as Common Lisp code, making the full
2703 power of Lisp macros available for JavaScript.  This provides a web
2704 development environment that is unmatched in its ability to reduce code
2705 duplication and provide advanced meta-programming facilities to web
2706 developers.
2707
2708 At the same time, Parenscript is different from almost all other \"language
2709 X\" to JavaScript translators in that it imposes almost no overhead:
2710
2711 @itemize
2712 @item No run-time dependencies: Any piece of Parenscript code is runnable
2713 as-is.  There are no JavaScript files to include.
2714 @item Native types: Parenscript works entirely with native JavaScript data
2715 types.  There are no new types introduced, and object prototypes are not
2716 touched.
2717 @item Native calling convention: Any JavaScript code can be called without the
2718 need for bindings.  Likewise, Parenscript can be used to make efficient,
2719 self-contained JavaScript libraries.
2720 @item Readable code: Parenscript generates concise, formatted, idiomatic
2721 JavaScript code.  Identifier names are preserved.  This enables seamless
2722 debugging in tools like Firebug.
2723 @item Efficiency: Parenscript introduces minimal overhead for advanced Common
2724 Lisp features.  The generated code is almost as fast as hand-written
2725 JavaScript.
2726 @end itemize\n")
2727       (license license:bsd-3))))
2728
2729 (define-public cl-parenscript
2730   (sbcl-package->cl-source-package sbcl-parenscript))
2731
2732 (define-public ecl-parenscript
2733   (sbcl-package->ecl-package sbcl-parenscript))
2734
2735 (define-public sbcl-cl-json
2736   (let ((commit "6dfebb9540bfc3cc33582d0c03c9ec27cb913e79"))
2737     (package
2738       (name "sbcl-cl-json")
2739       (version (git-version "0.5" "1" commit))
2740       (source
2741        (origin
2742          (method git-fetch)
2743          (uri (git-reference
2744                (url "https://github.com/hankhero/cl-json")
2745                (commit commit)))
2746          (file-name (git-file-name "cl-json" version))
2747          (sha256
2748           (base32
2749            "0fx3m3x3s5ji950yzpazz4s0img3l6b3d6l3jrfjv0lr702496lh"))))
2750       (build-system asdf-build-system/sbcl)
2751       (native-inputs
2752        `(("fiveam" ,sbcl-fiveam)))
2753       (home-page "https://github.com/hankhero/cl-json")
2754       (synopsis "JSON encoder and decoder for Common-Lisp")
2755       (description
2756        "@command{cl-json} provides an encoder of Lisp objects to JSON format
2757 and a corresponding decoder of JSON data to Lisp objects.  Both the encoder
2758 and the decoder are highly customizable; at the same time, the default
2759 settings ensure a very simple mode of operation, similar to that provided by
2760 @command{yason} or @command{st-json}.")
2761       (license license:expat))))
2762
2763 (define-public cl-json
2764   (sbcl-package->cl-source-package sbcl-cl-json))
2765
2766 (define-public ecl-cl-json
2767   (sbcl-package->ecl-package sbcl-cl-json))
2768
2769 (define-public sbcl-unix-opts
2770   (package
2771     (name "sbcl-unix-opts")
2772     (version "0.1.7")
2773     (source
2774      (origin
2775        (method git-fetch)
2776        (uri (git-reference
2777              (url "https://github.com/libre-man/unix-opts")
2778              (commit version)))
2779        (file-name (git-file-name "unix-opts" version))
2780        (sha256
2781         (base32
2782          "08djdi1ard09fijb7w9bdmhmwd98b1hzmcnjw9fqjiqa0g3b44rr"))))
2783     (build-system asdf-build-system/sbcl)
2784     (home-page "https://github.com/hankhero/cl-json")
2785     (synopsis "Unix-style command line options parser")
2786     (description
2787      "This is a minimalistic parser of command line options.  The main
2788 advantage of the library is the ability to concisely define command line
2789 options once and then use this definition for parsing and extraction of
2790 command line arguments, as well as printing description of command line
2791 options (you get --help for free).  This way you don't need to repeat
2792 yourself.  Also, @command{unix-opts} doesn't depend on anything and
2793 precisely controls the behavior of the parser via Common Lisp restarts.")
2794     (license license:expat)))
2795
2796 (define-public cl-unix-opts
2797   (sbcl-package->cl-source-package sbcl-unix-opts))
2798
2799 (define-public ecl-unix-opts
2800   (sbcl-package->ecl-package sbcl-unix-opts))
2801
2802 (define-public sbcl-trivial-garbage
2803   (package
2804     (name "sbcl-trivial-garbage")
2805     (version "0.21")
2806     (source
2807      (origin
2808        (method git-fetch)
2809        (uri (git-reference
2810              (url "https://github.com/trivial-garbage/trivial-garbage.git")
2811              (commit (string-append "v" version))))
2812        (file-name (git-file-name "trivial-garbage" version))
2813        (sha256
2814         (base32 "0122jicfg7pca1wxw8zak1n92h5friqy60988ns0ysksj3fphw9n"))))
2815     (build-system asdf-build-system/sbcl)
2816     (native-inputs
2817      `(("rt" ,sbcl-rt)))
2818     (home-page "https://common-lisp.net/project/trivial-garbage/")
2819     (synopsis "Portable GC-related APIs for Common Lisp")
2820     (description "@command{trivial-garbage} provides a portable API to
2821 finalizers, weak hash-tables and weak pointers on all major implementations of
2822 the Common Lisp programming language.")
2823     (license license:public-domain)))
2824
2825 (define-public cl-trivial-garbage
2826   (sbcl-package->cl-source-package sbcl-trivial-garbage))
2827
2828 (define-public ecl-trivial-garbage
2829   (sbcl-package->ecl-package sbcl-trivial-garbage))
2830
2831 (define-public sbcl-closer-mop
2832   (let ((commit "19c9d33f576e10715fd79cc1d4f688dab0f241d6"))
2833     (package
2834       (name "sbcl-closer-mop")
2835       (version (git-version  "1.0.0" "2" commit))
2836       (source
2837        (origin
2838          (method git-fetch)
2839          (uri (git-reference
2840                (url "https://github.com/pcostanza/closer-mop")
2841                (commit commit)))
2842          (sha256
2843           (base32 "1w3x087wvlwkd6swfdgbvjfs6kazf0la8ax4pjfzikwjch4snn2c"))
2844          (file-name (git-file-name "closer-mop" version ))))
2845       (build-system asdf-build-system/sbcl)
2846       (home-page "https://github.com/pcostanza/closer-mop")
2847       (synopsis "Rectifies absent or incorrect CLOS MOP features")
2848       (description "Closer to MOP is a compatibility layer that rectifies many
2849 of the absent or incorrect CLOS MOP features across a broad range of Common
2850 Lisp implementations.")
2851       (license license:expat))))
2852
2853 (define-public cl-closer-mop
2854   (sbcl-package->cl-source-package sbcl-closer-mop))
2855
2856 (define-public ecl-closer-mop
2857   (sbcl-package->ecl-package sbcl-closer-mop))
2858
2859 (define sbcl-cl-cffi-gtk-boot0
2860   (let ((commit "29443c5aaca975709df8025c4649366d882033cb"))
2861     (package
2862       (name "sbcl-cl-cffi-gtk-boot0")
2863       (version (git-version "0.11.2" "1" commit))
2864       (source
2865        (origin
2866          (method git-fetch)
2867          (uri (git-reference
2868                (url "https://github.com/Ferada/cl-cffi-gtk/")
2869                (commit commit)))
2870          (file-name (git-file-name "cl-cffi-gtk" version))
2871          (sha256
2872           (base32
2873            "0f6s92sf8xyzh1yksqx8bsy1sv0zmy0c13j3b8bavaba5hlxpxah"))))
2874       (build-system asdf-build-system/sbcl)
2875       (inputs
2876        `(("iterate" ,sbcl-iterate)
2877          ("cffi" ,sbcl-cffi)
2878          ("trivial-features" ,sbcl-trivial-features)))
2879       (home-page "https://github.com/Ferada/cl-cffi-gtk/")
2880       (synopsis "Common Lisp binding for GTK+3")
2881       (description
2882        "@command{cl-cffi-gtk} is a Lisp binding to GTK+ 3 (GIMP Toolkit) which
2883 is a library for creating graphical user interfaces.")
2884       (license license:lgpl3))))
2885
2886 (define-public sbcl-cl-cffi-gtk-glib
2887   (package
2888     (inherit sbcl-cl-cffi-gtk-boot0)
2889     (name "sbcl-cl-cffi-gtk-glib")
2890     (inputs
2891      `(("glib" ,glib)
2892        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2893     (arguments
2894      `(#:asd-file "glib/cl-cffi-gtk-glib.asd"
2895        #:phases
2896        (modify-phases %standard-phases
2897          (add-after 'unpack 'fix-paths
2898            (lambda* (#:key inputs #:allow-other-keys)
2899              (substitute* "glib/glib.init.lisp"
2900                (("libglib|libgthread" all) (string-append
2901                                             (assoc-ref inputs "glib") "/lib/" all))))))))))
2902
2903 (define-public sbcl-cl-cffi-gtk-gobject
2904   (package
2905     (inherit sbcl-cl-cffi-gtk-boot0)
2906     (name "sbcl-cl-cffi-gtk-gobject")
2907     (inputs
2908      `(("glib" ,glib)
2909        ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
2910        ("trivial-garbage" ,sbcl-trivial-garbage)
2911        ("bordeaux-threads" ,sbcl-bordeaux-threads)
2912        ("closer-mop" ,sbcl-closer-mop)
2913        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2914     (arguments
2915      `(#:asd-file "gobject/cl-cffi-gtk-gobject.asd"
2916        #:phases
2917        (modify-phases %standard-phases
2918          (add-after 'unpack 'fix-paths
2919            (lambda* (#:key inputs #:allow-other-keys)
2920              (substitute* "gobject/gobject.init.lisp"
2921                (("libgobject" all) (string-append
2922                                     (assoc-ref inputs "glib") "/lib/" all)))))
2923          (add-after 'install 'link-source
2924            ;; Since source is particularly heavy (16MiB+), let's reuse it
2925            ;; across the different components of cl-ffi-gtk.
2926            (lambda* (#:key inputs outputs #:allow-other-keys)
2927              (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
2928                                                "/share/common-lisp/sbcl-source/"
2929                                                "cl-cffi-gtk-glib"))
2930                    (out-source (string-append (assoc-ref outputs "out")
2931                                               "/share/common-lisp/sbcl-source/"
2932                                               "cl-cffi-gtk-gobject")))
2933                (delete-file-recursively out-source)
2934                (symlink glib-source out-source)
2935                #t))))))))
2936
2937 (define-public sbcl-cl-cffi-gtk-gio
2938   (package
2939     (inherit sbcl-cl-cffi-gtk-boot0)
2940     (name "sbcl-cl-cffi-gtk-gio")
2941     (inputs
2942      `(("glib" ,glib)
2943        ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
2944        ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
2945        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2946     (arguments
2947      `(#:asd-file "gio/cl-cffi-gtk-gio.asd"
2948        #:phases
2949        (modify-phases %standard-phases
2950          (add-after 'unpack 'fix-paths
2951            (lambda* (#:key inputs #:allow-other-keys)
2952              (substitute* "gio/gio.init.lisp"
2953                (("libgio" all)
2954                 (string-append
2955                  (assoc-ref inputs "glib") "/lib/" all)))))
2956          (add-after 'install 'link-source
2957            ;; Since source is particularly heavy (16MiB+), let's reuse it
2958            ;; across the different components of cl-ffi-gtk.
2959            (lambda* (#:key inputs outputs #:allow-other-keys)
2960              (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
2961                                                "/share/common-lisp/sbcl-source/"
2962                                                "cl-cffi-gtk-glib"))
2963                    (out-source (string-append (assoc-ref outputs "out")
2964                                               "/share/common-lisp/sbcl-source/"
2965                                               "cl-cffi-gtk-gio")))
2966                (delete-file-recursively out-source)
2967                (symlink glib-source out-source)
2968                #t))))))))
2969
2970 (define-public sbcl-cl-cffi-gtk-cairo
2971   (package
2972     (inherit sbcl-cl-cffi-gtk-boot0)
2973     (name "sbcl-cl-cffi-gtk-cairo")
2974     (inputs
2975      `(("cairo" ,cairo)
2976        ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
2977        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2978     (arguments
2979      `(#:asd-file "cairo/cl-cffi-gtk-cairo.asd"
2980        #:phases
2981        (modify-phases %standard-phases
2982          (add-after 'unpack 'fix-paths
2983            (lambda* (#:key inputs #:allow-other-keys)
2984              (substitute* "cairo/cairo.init.lisp"
2985                (("libcairo" all)
2986                 (string-append
2987                  (assoc-ref inputs "cairo") "/lib/" all)))))
2988          (add-after 'install 'link-source
2989            ;; Since source is particularly heavy (16MiB+), let's reuse it
2990            ;; across the different components of cl-ffi-gtk.
2991            (lambda* (#:key inputs outputs #:allow-other-keys)
2992              (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
2993                                                "/share/common-lisp/sbcl-source/"
2994                                                "cl-cffi-gtk-glib"))
2995                    (out-source (string-append (assoc-ref outputs "out")
2996                                               "/share/common-lisp/sbcl-source/"
2997                                               "cl-cffi-gtk-cairo")))
2998                (delete-file-recursively out-source)
2999                (symlink glib-source out-source)
3000                #t))))))))
3001
3002 (define-public sbcl-cl-cffi-gtk-pango
3003   (package
3004     (inherit sbcl-cl-cffi-gtk-boot0)
3005     (name "sbcl-cl-cffi-gtk-pango")
3006     (inputs
3007      `(("pango" ,pango)
3008        ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
3009        ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
3010        ("cl-cffi-gtk-cairo" ,sbcl-cl-cffi-gtk-cairo)
3011        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
3012     (arguments
3013      `(#:asd-file "pango/cl-cffi-gtk-pango.asd"
3014        #:phases
3015        (modify-phases %standard-phases
3016          (add-after 'unpack 'fix-paths
3017            (lambda* (#:key inputs #:allow-other-keys)
3018              (substitute* "pango/pango.init.lisp"
3019                (("libpango" all)
3020                 (string-append
3021                  (assoc-ref inputs "pango") "/lib/" all)))))
3022          (add-after 'install 'link-source
3023            ;; Since source is particularly heavy (16MiB+), let's reuse it
3024            ;; across the different components of cl-ffi-gtk.
3025            (lambda* (#:key inputs outputs #:allow-other-keys)
3026              (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
3027                                                "/share/common-lisp/sbcl-source/"
3028                                                "cl-cffi-gtk-glib"))
3029                    (out-source (string-append (assoc-ref outputs "out")
3030                                               "/share/common-lisp/sbcl-source/"
3031                                               "cl-cffi-gtk-pango")))
3032                (delete-file-recursively out-source)
3033                (symlink glib-source out-source)
3034                #t))))))))
3035
3036 (define-public sbcl-cl-cffi-gtk-gdk-pixbuf
3037   (package
3038     (inherit sbcl-cl-cffi-gtk-boot0)
3039     (name "sbcl-cl-cffi-gtk-gdk-pixbuf")
3040     (inputs
3041      `(("gdk-pixbuf" ,gdk-pixbuf)
3042        ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
3043        ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
3044        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
3045     (arguments
3046      `(#:asd-file "gdk-pixbuf/cl-cffi-gtk-gdk-pixbuf.asd"
3047        #:phases
3048        (modify-phases %standard-phases
3049          (add-after 'unpack 'fix-paths
3050            (lambda* (#:key inputs #:allow-other-keys)
3051              (substitute* "gdk-pixbuf/gdk-pixbuf.init.lisp"
3052                (("libgdk_pixbuf" all)
3053                 (string-append
3054                  (assoc-ref inputs "gdk-pixbuf") "/lib/" all)))))
3055          (add-after 'install 'link-source
3056            ;; Since source is particularly heavy (16MiB+), let's reuse it
3057            ;; across the different components of cl-ffi-gtk.
3058            (lambda* (#:key inputs outputs #:allow-other-keys)
3059              (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
3060                                                "/share/common-lisp/sbcl-source/"
3061                                                "cl-cffi-gtk-glib"))
3062                    (out-source (string-append (assoc-ref outputs "out")
3063                                               "/share/common-lisp/sbcl-source/"
3064                                               "cl-cffi-gtk-gdk-pixbuf")))
3065                (delete-file-recursively out-source)
3066                (symlink glib-source out-source)
3067                #t))))))))
3068
3069 (define-public sbcl-cl-cffi-gtk-gdk
3070   (package
3071     (inherit sbcl-cl-cffi-gtk-boot0)
3072     (name "sbcl-cl-cffi-gtk-gdk")
3073     (inputs
3074      `(("gtk" ,gtk+)
3075        ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
3076        ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
3077        ("cl-cffi-gtk-gio" ,sbcl-cl-cffi-gtk-gio)
3078        ("cl-cffi-gtk-gdk-pixbuf" ,sbcl-cl-cffi-gtk-gdk-pixbuf)
3079        ("cl-cffi-gtk-cairo" ,sbcl-cl-cffi-gtk-cairo)
3080        ("cl-cffi-gtk-pango" ,sbcl-cl-cffi-gtk-pango)
3081        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
3082     (arguments
3083      `(#:asd-file "gdk/cl-cffi-gtk-gdk.asd"
3084        #:phases
3085        (modify-phases %standard-phases
3086          (add-after 'unpack 'fix-paths
3087            (lambda* (#:key inputs #:allow-other-keys)
3088              (substitute* "gdk/gdk.init.lisp"
3089                (("libgdk" all)
3090                 (string-append
3091                  (assoc-ref inputs "gtk") "/lib/" all)))
3092              (substitute* "gdk/gdk.package.lisp"
3093                (("libgtk" all)
3094                 (string-append
3095                  (assoc-ref inputs "gtk") "/lib/" all)))))
3096          (add-after 'install 'link-source
3097            ;; Since source is particularly heavy (16MiB+), let's reuse it
3098            ;; across the different components of cl-ffi-gtk.
3099            (lambda* (#:key inputs outputs #:allow-other-keys)
3100              (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
3101                                                "/share/common-lisp/sbcl-source/"
3102                                                "cl-cffi-gtk-glib"))
3103                    (out-source (string-append (assoc-ref outputs "out")
3104                                               "/share/common-lisp/sbcl-source/"
3105                                               "cl-cffi-gtk-gdk")))
3106                (delete-file-recursively out-source)
3107                (symlink glib-source out-source)
3108                #t))))))))
3109
3110 (define-public sbcl-cl-cffi-gtk
3111   (package
3112     (inherit sbcl-cl-cffi-gtk-boot0)
3113     (name "sbcl-cl-cffi-gtk")
3114     (inputs
3115      `(("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
3116        ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
3117        ("cl-cffi-gtk-gio" ,sbcl-cl-cffi-gtk-gio)
3118        ("cl-cffi-gtk-gdk" ,sbcl-cl-cffi-gtk-gdk)
3119        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
3120     (native-inputs
3121      `(("fiveam" ,sbcl-fiveam)))
3122     (arguments
3123      `(#:asd-file "gtk/cl-cffi-gtk.asd"
3124        #:test-asd-file "test/cl-cffi-gtk-test.asd"
3125        ;; TODO: Tests fail with memory fault.
3126        ;; See https://github.com/Ferada/cl-cffi-gtk/issues/24.
3127        #:tests? #f
3128        #:phases
3129        (modify-phases %standard-phases
3130          (add-after 'install 'link-source
3131            ;; Since source is particularly heavy (16MiB+), let's reuse it
3132            ;; across the different components of cl-ffi-gtk.
3133            (lambda* (#:key inputs outputs #:allow-other-keys)
3134              (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
3135                                                "/share/common-lisp/sbcl-source/"
3136                                                "cl-cffi-gtk-glib"))
3137                    (out-source (string-append (assoc-ref outputs "out")
3138                                               "/share/common-lisp/sbcl-source/"
3139                                               "cl-cffi-gtk")))
3140                (delete-file-recursively out-source)
3141                (symlink glib-source out-source)
3142                #t))))))))
3143
3144 (define-public cl-cffi-gtk
3145   (sbcl-package->cl-source-package sbcl-cl-cffi-gtk))
3146
3147 (define-public sbcl-cl-webkit
3148   (let ((commit "f93cb9697e8813068795fe4dc39ac950d814102d"))
3149     (package
3150       (name "sbcl-cl-webkit")
3151       (version (git-version "2.4" "3" commit))
3152       (source
3153        (origin
3154          (method git-fetch)
3155          (uri (git-reference
3156                (url "https://github.com/joachifm/cl-webkit")
3157                (commit commit)))
3158          (file-name (git-file-name "cl-webkit" version))
3159          (sha256
3160           (base32
3161            "1sjcw08kjpd5h83sms7zcq2nymddjygk9hm2rpgzrl524an9ziwc"))))
3162       (build-system asdf-build-system/sbcl)
3163       (inputs
3164        `(("cffi" ,sbcl-cffi)
3165          ("cl-cffi-gtk" ,sbcl-cl-cffi-gtk)
3166          ("webkitgtk" ,webkitgtk)))
3167       (arguments
3168        `(#:asd-file "webkit2/cl-webkit2.asd"
3169          #:asd-system-name "cl-webkit2"
3170          #:phases
3171          (modify-phases %standard-phases
3172            (add-after 'unpack 'fix-paths
3173              (lambda* (#:key inputs #:allow-other-keys)
3174                (substitute* "webkit2/webkit2.init.lisp"
3175                  (("libwebkit2gtk" all)
3176                   (string-append
3177                    (assoc-ref inputs "webkitgtk") "/lib/" all))))))))
3178       (home-page "https://github.com/joachifm/cl-webkit")
3179       (synopsis "Binding to WebKitGTK+ for Common Lisp")
3180       (description
3181        "@command{cl-webkit} is a binding to WebKitGTK+ for Common Lisp,
3182 currently targeting WebKit version 2.  The WebKitGTK+ library adds web
3183 browsing capabilities to an application, leveraging the full power of the
3184 WebKit browsing engine.")
3185       (license license:expat))))
3186
3187 (define-public cl-webkit
3188   (sbcl-package->cl-source-package sbcl-cl-webkit))
3189
3190 (define-public sbcl-lparallel
3191   (package
3192     (name "sbcl-lparallel")
3193     (version "2.8.4")
3194     (source
3195      (origin
3196        (method git-fetch)
3197        (uri (git-reference
3198              (url "https://github.com/lmj/lparallel/")
3199              (commit (string-append "lparallel-" version))))
3200        (file-name (git-file-name "lparallel" version))
3201        (sha256
3202         (base32
3203          "0g0aylrbbrqsz0ahmwhvnk4cmc2931fllbpcfgzsprwnqqd7vwq9"))))
3204     (build-system asdf-build-system/sbcl)
3205     (inputs
3206      `(("alexandria" ,sbcl-alexandria)
3207        ("bordeaux-threads" ,sbcl-bordeaux-threads)
3208        ("trivial-garbage" ,sbcl-trivial-garbage)))
3209     (home-page "https://lparallel.org/")
3210     (synopsis "Parallelism for Common Lisp")
3211     (description
3212      "@command{lparallel} is a library for parallel programming in Common
3213 Lisp, featuring:
3214
3215 @itemize
3216 @item a simple model of task submission with receiving queue,
3217 @item constructs for expressing fine-grained parallelism,
3218 @item asynchronous condition handling across thread boundaries,
3219 @item parallel versions of map, reduce, sort, remove, and many others,
3220 @item promises, futures, and delayed evaluation constructs,
3221 @item computation trees for parallelizing interconnected tasks,
3222 @item bounded and unbounded FIFO queues,
3223 @item high and low priority tasks,
3224 @item task killing by category,
3225 @item integrated timeouts.
3226 @end itemize\n")
3227     (license license:expat)))
3228
3229 (define-public cl-lparallel
3230   (sbcl-package->cl-source-package sbcl-lparallel))
3231
3232 (define-public ecl-lparallel
3233   (sbcl-package->ecl-package sbcl-lparallel))
3234
3235 (define-public sbcl-cl-markup
3236   (let ((commit "e0eb7debf4bdff98d1f49d0f811321a6a637b390"))
3237     (package
3238       (name "sbcl-cl-markup")
3239       (version (git-version "0.1" "1" commit))
3240       (source
3241        (origin
3242          (method git-fetch)
3243          (uri (git-reference
3244                (url "https://github.com/arielnetworks/cl-markup/")
3245                (commit commit)))
3246          (file-name (git-file-name "cl-markup" version))
3247          (sha256
3248           (base32
3249            "10l6k45971dl13fkdmva7zc6i453lmq9j4xax2ci6pjzlc6xjhp7"))))
3250       (build-system asdf-build-system/sbcl)
3251       (home-page "https://github.com/arielnetworks/cl-markup/")
3252       (synopsis "Markup generation library for Common Lisp")
3253       (description
3254        "A modern markup generation library for Common Lisp that features:
3255
3256 @itemize
3257 @item Fast (even faster through compiling the code)
3258 @item Safety
3259 @item Support for multiple document types (markup, xml, html, html5, xhtml)
3260 @item Output with doctype
3261 @item Direct output to stream
3262 @end itemize\n")
3263       (license license:lgpl3+))))
3264
3265 (define-public cl-markup
3266   (sbcl-package->cl-source-package sbcl-cl-markup))
3267
3268 (define-public ecl-cl-markup
3269   (sbcl-package->ecl-package sbcl-cl-markup))
3270
3271 (define-public sbcl-cl-css
3272   (let ((commit "8fe654c8f0cf95b300718101cce4feb517f78e2f"))
3273     (package
3274       (name "sbcl-cl-css")
3275       (version (git-version "0.1" "1" commit))
3276       (source
3277        (origin
3278          (method git-fetch)
3279          (uri (git-reference
3280                (url "https://github.com/inaimathi/cl-css/")
3281                (commit commit)))
3282          (file-name (git-file-name "cl-css" version))
3283          (sha256
3284           (base32
3285            "1lc42zi2sw11fl2589sc19nr5sd2p0wy7wgvgwaggxa5f3ajhsmd"))))
3286       (build-system asdf-build-system/sbcl)
3287       (home-page "https://github.com/inaimathi/cl-css/")
3288       (synopsis "Non-validating, inline CSS generator for Common Lisp")
3289       (description
3290        "This is a dead-simple, non validating, inline CSS generator for Common
3291 Lisp.  Its goals are axiomatic syntax, simple implementation to support
3292 portability, and boilerplate reduction in CSS.")
3293       (license license:expat))))
3294
3295 (define-public cl-css
3296   (sbcl-package->cl-source-package sbcl-cl-css))
3297
3298 (define-public ecl-cl-css
3299   (sbcl-package->ecl-package sbcl-cl-css))
3300
3301 (define-public sbcl-portable-threads
3302   (let ((commit "c0e61a1faeb0583c80fd3f20b16cc4c555226920"))
3303     (package
3304       (name "sbcl-portable-threads")
3305       (version (git-version "2.3" "1" commit))
3306       (source
3307        (origin
3308          (method git-fetch)
3309          (uri (git-reference
3310                (url "https://github.com/binghe/portable-threads/")
3311                (commit commit)))
3312          (file-name (git-file-name "portable-threads" version))
3313          (sha256
3314           (base32
3315            "03fmxyarc0xf4kavwkfa0a2spkyfrz6hbgbi9y4q7ny5aykdyfaq"))))
3316       (build-system asdf-build-system/sbcl)
3317       (arguments
3318        `(;; Tests seem broken.
3319          #:tests? #f))
3320       (home-page "https://github.com/binghe/portable-threads")
3321       (synopsis "Portable threads (and scheduled and periodic functions) API for Common Lisp")
3322       (description
3323        "Portable Threads (and Scheduled and Periodic Functions) API for Common
3324 Lisp (from GBBopen project).")
3325       (license license:asl2.0))))
3326
3327 (define-public cl-portable-threads
3328   (sbcl-package->cl-source-package sbcl-portable-threads))
3329
3330 (define-public ecl-portable-threada
3331   (sbcl-package->ecl-package sbcl-portable-threads))
3332
3333 (define sbcl-usocket-boot0
3334   ;; usocket's test rely on usocket-server which depends on usocket itself.
3335   ;; We break this cyclic dependency with -boot0 that packages usocket.
3336   (package
3337     (name "sbcl-usocket-boot0")
3338     (version "0.8.3")
3339     (source
3340      (origin
3341        (method git-fetch)
3342        (uri (git-reference
3343              (url "https://github.com/usocket/usocket/")
3344              (commit (string-append "v" version))))
3345        (file-name (git-file-name "usocket" version))
3346        (sha256
3347         (base32
3348          "0x746wr2324l6bn7skqzgkzcbj5kd0zp2ck0c8rldrw0rzabg826"))))
3349     (build-system asdf-build-system/sbcl)
3350     (inputs
3351      `(("split-sequence" ,sbcl-split-sequence)))
3352     (arguments
3353      `(#:tests? #f
3354        #:asd-system-name "usocket"))
3355     (home-page "https://common-lisp.net/project/usocket/")
3356     (synopsis "Universal socket library for Common Lisp (server side)")
3357     (description
3358      "This library strives to provide a portable TCP/IP and UDP/IP socket
3359 interface for as many Common Lisp implementations as possible, while keeping
3360 the abstraction and portability layer as thin as possible.")
3361     (license license:expat)))
3362
3363 (define-public sbcl-usocket-server
3364   (package
3365     (inherit sbcl-usocket-boot0)
3366     (name "sbcl-usocket-server")
3367     (inputs
3368      `(("bordeaux-threads" ,sbcl-bordeaux-threads)
3369        ("usocket" ,sbcl-usocket-boot0)))
3370     (arguments
3371      '(#:asd-system-name "usocket-server"))
3372     (synopsis "Universal socket library for Common Lisp (server side)")))
3373
3374 (define-public cl-usocket-server
3375   (sbcl-package->cl-source-package sbcl-usocket-server))
3376
3377 (define-public ecl-socket-server
3378   (sbcl-package->ecl-package sbcl-usocket-server))
3379
3380 (define-public sbcl-usocket
3381   (package
3382     (inherit sbcl-usocket-boot0)
3383     (name "sbcl-usocket")
3384     (arguments
3385      ;; FIXME: Tests need network access?
3386      `(#:tests? #f))
3387     (native-inputs
3388      ;; Testing only.
3389      `(("usocket-server" ,sbcl-usocket-server)
3390        ("rt" ,sbcl-rt)))))
3391
3392 (define-public cl-usocket
3393   (sbcl-package->cl-source-package sbcl-usocket))
3394
3395 (define-public ecl-usocket
3396   (sbcl-package->ecl-package sbcl-usocket))
3397
3398 (define-public sbcl-s-xml
3399   (package
3400     (name "sbcl-s-xml")
3401     (version "3")
3402     (source
3403      (origin
3404        (method url-fetch)
3405        (uri "https://common-lisp.net/project/s-xml/s-xml.tgz")
3406        (sha256
3407         (base32
3408          "061qcr0dzshsa38s5ma4ay924cwak2nq9gy59dw6v9p0qb58nzjf"))))
3409     (build-system asdf-build-system/sbcl)
3410     (home-page "https://common-lisp.net/project/s-xml/")
3411     (synopsis "Simple XML parser implemented in Common Lisp")
3412     (description
3413      "S-XML is a simple XML parser implemented in Common Lisp.  This XML
3414 parser implementation has the following features:
3415
3416 @itemize
3417 @item It works (handling many common XML usages).
3418 @item It is very small (the core is about 700 lines of code, including
3419 comments and whitespace).
3420 @item It has a core API that is simple, efficient and pure functional, much
3421 like that from SSAX (see also http://ssax.sourceforge.net).
3422 @item It supports different DOM models: an XSML-based one, an LXML-based one
3423 and a classic xml-element struct based one.
3424 @item It is reasonably time and space efficient (internally avoiding garbage
3425 generatation as much as possible).
3426 @item It does support CDATA.
3427 @item It should support the same character sets as your Common Lisp
3428 implementation.
3429 @item It does support XML name spaces.
3430 @end itemize
3431
3432 This XML parser implementation has the following limitations:
3433
3434 @itemize
3435 @item It does not support any special tags (like processing instructions).
3436 @item It is not validating, even skips DTD's all together.
3437 @end itemize\n")
3438     (license license:lgpl3+)))
3439
3440 (define-public cl-s-xml
3441   (sbcl-package->cl-source-package sbcl-s-xml))
3442
3443 (define-public ecl-s-xml
3444   (sbcl-package->ecl-package sbcl-s-xml))
3445
3446 (define-public sbcl-s-xml-rpc
3447   (package
3448     (name "sbcl-s-xml-rpc")
3449     (version "7")
3450     (source
3451      (origin
3452        (method url-fetch)
3453        (uri "https://common-lisp.net/project/s-xml-rpc/s-xml-rpc.tgz")
3454        (sha256
3455         (base32
3456          "02z7k163d51v0pzk8mn1xb6h5s6x64gjqkslhwm3a5x26k2gfs11"))))
3457     (build-system asdf-build-system/sbcl)
3458     (inputs
3459      `(("s-xml" ,sbcl-s-xml)))
3460     (home-page "https://common-lisp.net/project/s-xml-rpc/")
3461     (synopsis "Implementation of XML-RPC in Common Lisp for both client and server")
3462     (description
3463      "S-XML-RPC is an implementation of XML-RPC in Common Lisp for both
3464 client and server.")
3465     (license license:lgpl3+)))
3466
3467 (define-public cl-s-xml-rpc
3468   (sbcl-package->cl-source-package sbcl-s-xml-rpc))
3469
3470 (define-public ecl-s-xml-rpc
3471   (sbcl-package->ecl-package sbcl-s-xml-rpc))
3472
3473 (define-public sbcl-trivial-clipboard
3474   (let ((commit "5af3415d1484e6d69a1b5c178f24680d9fd01796"))
3475     (package
3476       (name "sbcl-trivial-clipboard")
3477       (version (git-version "0.0.0.0" "2" commit))
3478       (source
3479        (origin
3480          (method git-fetch)
3481          (uri (git-reference
3482                (url "https://github.com/snmsts/trivial-clipboard")
3483                (commit commit)))
3484          (file-name (git-file-name "trivial-clipboard" version))
3485          (sha256
3486           (base32
3487            "1gb515z5yq6h5548pb1fwhmb0hhq1ssyb78pvxh4alq799xipxs9"))))
3488       (build-system asdf-build-system/sbcl)
3489       (inputs
3490        `(("xclip" ,xclip)))
3491       (native-inputs
3492        `(("fiveam" ,sbcl-fiveam)))
3493       (arguments
3494        `(#:phases
3495          (modify-phases %standard-phases
3496            (add-after 'unpack 'fix-paths
3497              (lambda* (#:key inputs #:allow-other-keys)
3498                (substitute* "src/text.lisp"
3499                  (("\\(executable-find \"xclip\"\\)")
3500                   (string-append "(executable-find \""
3501                                  (assoc-ref inputs "xclip")
3502                                  "/bin/xclip\")"))))))))
3503       (home-page "https://github.com/snmsts/trivial-clipboard")
3504       (synopsis "Access system clipboard in Common Lisp")
3505       (description
3506        "@command{trivial-clipboard} gives access to the system clipboard.")
3507       (license license:expat))))
3508
3509 (define-public cl-trivial-clipboard
3510   (sbcl-package->cl-source-package sbcl-trivial-clipboard))
3511
3512 (define-public ecl-trivial-clipboard
3513   (sbcl-package->ecl-package sbcl-trivial-clipboard))
3514
3515 (define-public sbcl-trivial-backtrace
3516   (let ((commit "ca81c011b86424a381a7563cea3b924f24e6fbeb")
3517         (revision "1"))
3518     (package
3519      (name "sbcl-trivial-backtrace")
3520      (version (git-version "0.0.0" revision commit))
3521      (source
3522       (origin
3523        (method git-fetch)
3524        (uri (git-reference
3525              (url "https://github.com/gwkkwg/trivial-backtrace.git")
3526              (commit commit)))
3527        (file-name (git-file-name "trivial-backtrace" version))
3528        (sha256
3529         (base32 "10p41p43skj6cimdg8skjy7372s8v2xpkg8djjy0l8rm45i654k1"))))
3530      (build-system asdf-build-system/sbcl)
3531      (inputs
3532       `(("sbcl-lift" ,sbcl-lift)))
3533      (arguments
3534       `(#:phases
3535         (modify-phases %standard-phases
3536           (add-after 'check 'delete-test-results
3537             (lambda* (#:key outputs #:allow-other-keys)
3538               (let ((test-results (string-append (assoc-ref outputs "out")
3539                                                  "/share/common-lisp/"
3540                                                  (%lisp-type) "-source"
3541                                                  "/trivial-backtrace"
3542                                                  "/test-results")))
3543                 (when (file-exists? test-results)
3544                   (delete-file-recursively test-results)))
3545               #t)))))
3546      (home-page "https://common-lisp.net/project/trivial-backtrace/")
3547      (synopsis "Portable simple API to work with backtraces in Common Lisp")
3548      (description
3549       "On of the many things that didn't quite get into the Common Lisp
3550 standard was how to get a Lisp to output its call stack when something has
3551 gone wrong.  As such, each Lisp has developed its own notion of what to
3552 display, how to display it, and what sort of arguments can be used to
3553 customize it.  @code{trivial-backtrace} is a simple solution to generating a
3554 backtrace portably.")
3555      (license license:expat))))
3556
3557 (define-public cl-trivial-backtrace
3558   (sbcl-package->cl-source-package sbcl-trivial-backtrace))
3559
3560 (define-public sbcl-rfc2388
3561   (let ((commit "591bcf7e77f2c222c43953a80f8c297751dc0c4e")
3562         (revision "1"))
3563     (package
3564      (name "sbcl-rfc2388")
3565      (version (git-version "0.0.0" revision commit))
3566      (source
3567       (origin
3568        (method git-fetch)
3569        (uri (git-reference
3570              (url "https://github.com/jdz/rfc2388.git")
3571              (commit commit)))
3572        (file-name (git-file-name "rfc2388" version))
3573        (sha256
3574         (base32 "0phh5n3clhl9ji8jaxrajidn22d3f0aq87mlbfkkxlnx2pnw694k"))))
3575      (build-system asdf-build-system/sbcl)
3576      (home-page "https://github.com/jdz/rfc2388/")
3577      (synopsis "An implementation of RFC 2388 in Common Lisp")
3578      (description
3579       "This package contains an implementation of RFC 2388, which is used to
3580 process form data posted with HTTP POST method using enctype
3581 \"multipart/form-data\".")
3582      (license license:bsd-2))))
3583
3584 (define-public cl-rfc2388
3585   (sbcl-package->cl-source-package sbcl-rfc2388))
3586
3587 (define-public sbcl-md5
3588   (package
3589     (name "sbcl-md5")
3590     (version "2.0.4")
3591     (source
3592      (origin
3593        (method url-fetch)
3594        (uri (string-append
3595              "https://github.com/pmai/md5/archive/release-" version ".tar.gz"))
3596        (sha256
3597         (base32 "19yl9n0pjdz5gw4qi711lka97xcd9f81ylg434hk7jwn9f2s6w11"))))
3598     (build-system asdf-build-system/sbcl)
3599     (home-page "https://github.com/pmai/md5")
3600     (synopsis
3601      "Common Lisp implementation of the MD5 Message-Digest Algorithm (RFC 1321)")
3602     (description
3603      "This package implements The MD5 Message-Digest Algorithm, as defined in
3604 RFC 1321 by R. Rivest, published April 1992.")
3605     (license license:public-domain)))
3606
3607 (define-public cl-md5
3608   (sbcl-package->cl-source-package sbcl-md5))
3609
3610 (define-public sbcl-cl+ssl
3611   (let ((commit "141ae91416bc40f1618dc07e48429b84388aa599")
3612         (revision "1"))
3613     (package
3614       (name "sbcl-cl+ssl")
3615       (version (git-version "0.0.0" revision commit))
3616       (source
3617        (origin
3618          (method git-fetch)
3619          (uri (git-reference
3620                (url "https://github.com/cl-plus-ssl/cl-plus-ssl.git")
3621                (commit commit)))
3622          (file-name (git-file-name "cl+ssl" version))
3623          (sha256
3624           (base32 "1s0hg1h9sf8q89v0yrxmzg5f5sng29rgx3n21r9h9yql8351myan"))))
3625       (build-system asdf-build-system/sbcl)
3626       (arguments
3627        '(#:phases
3628          (modify-phases %standard-phases
3629            (add-after 'unpack 'fix-paths
3630              (lambda* (#:key inputs #:allow-other-keys)
3631                (substitute* "src/reload.lisp"
3632                  (("libssl.so" all)
3633                   (string-append
3634                    (assoc-ref inputs "openssl") "/lib/" all))))))))
3635       (inputs
3636        `(("openssl" ,openssl)
3637          ("sbcl-cffi" ,sbcl-cffi)
3638          ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)
3639          ("sbcl-flexi-streams" ,sbcl-flexi-streams)
3640          ("sbcl-bordeaux-threads" ,sbcl-bordeaux-threads)
3641          ("sbcl-trivial-garbage" ,sbcl-trivial-garbage)
3642          ("sbcl-alexandria" ,sbcl-alexandria)
3643          ("sbcl-trivial-features" ,sbcl-trivial-features)))
3644       (home-page "https://common-lisp.net/project/cl-plus-ssl/")
3645       (synopsis "Common Lisp bindings to OpenSSL")
3646       (description
3647        "This library is a fork of SSL-CMUCL.  The original SSL-CMUCL source
3648 code was written by Eric Marsden and includes contributions by Jochen Schmidt.
3649 Development into CL+SSL was done by David Lichteblau.")
3650       (license license:expat))))
3651
3652 (define-public cl-cl+ssl
3653   (sbcl-package->cl-source-package sbcl-cl+ssl))
3654
3655 (define-public sbcl-kmrcl
3656   (let ((version "1.109.0")
3657         (commit "5260068b2eb735af6796740c2db4955afac21636")
3658         (revision "1"))
3659     (package
3660       (name "sbcl-kmrcl")
3661       (version (git-version version revision commit))
3662       (source
3663        (origin
3664          (method git-fetch)
3665          (uri (git-reference
3666                (url "http://git.kpe.io/kmrcl.git/")
3667                (commit commit)))
3668          (file-name (git-file-name name version))
3669          (sha256
3670           (base32 "1va7xjgzfv674bpsli674i7zj3f7wg5kxic41kz18r6hh4n52dfv"))))
3671       (build-system asdf-build-system/sbcl)
3672       (arguments
3673        ;; Tests fail with: :FORCE and :FORCE-NOT arguments not allowed in a
3674        ;; nested call to ASDF/OPERATE:OPERATE unless identically to toplevel
3675        '(#:tests? #f))
3676       (inputs
3677        `(("sbcl-rt" ,sbcl-rt)))
3678       (home-page "http://files.kpe.io/kmrcl/")
3679       (synopsis "General utilities for Common Lisp programs")
3680       (description
3681        "KMRCL is a collection of utilities used by a number of Kevin
3682 Rosenberg's CL packages.")
3683       (license license:llgpl))))
3684
3685 (define-public cl-kmrcl
3686   (sbcl-package->cl-source-package sbcl-kmrcl))
3687
3688 (define-public sbcl-cl-base64
3689   (let ((version "3.3.3"))
3690     (package
3691       (name "sbcl-cl-base64")
3692       (version version)
3693       (source
3694        (origin
3695          (method git-fetch)
3696          (uri (git-reference
3697                (url "http://git.kpe.io/cl-base64.git")
3698                (commit (string-append "v" version))))
3699          (file-name (git-file-name "cl-base64" version))
3700          (sha256
3701           (base32 "1dw6j7n6gsd2qa0p0rbsjxj00acxx3i9ca1qkgl0liy8lpnwkypl"))))
3702       (build-system asdf-build-system/sbcl)
3703       (arguments
3704        ;; Tests fail with: :FORCE and :FORCE-NOT arguments not allowed
3705        ;; in a nested call to ASDF/OPERATE:OPERATE unless identically
3706        ;; to toplevel
3707        '(#:tests? #f))
3708       (inputs
3709        `(("sbcl-ptester" ,sbcl-ptester)
3710          ("sbcl-kmrcl" ,sbcl-kmrcl)))
3711       (home-page "http://files.kpe.io/cl-base64/")
3712       (synopsis
3713        "Common Lisp package to encode and decode base64 with URI support")
3714       (description
3715        "This package provides highly optimized base64 encoding and decoding.
3716 Besides conversion to and from strings, integer conversions are supported.
3717 Encoding with Uniform Resource Identifiers is supported by using a modified
3718 encoding table that uses only URI-compatible characters.")
3719       (license license:bsd-3))))
3720
3721 (define-public cl-base64
3722   (sbcl-package->cl-source-package sbcl-cl-base64))
3723
3724 (define-public sbcl-chunga
3725   (package
3726     (name "sbcl-chunga")
3727     (version "1.1.7")
3728     (source
3729      (origin
3730        (method git-fetch)
3731        (uri (git-reference
3732               (url "https://github.com/edicl/chunga.git")
3733               (commit (string-append "v" version))))
3734        (file-name (git-file-name name version))
3735        (sha256
3736         (base32 "0jzn3nyb3f22gm983rfk99smqs3mhb9ivjmasvhq9qla5cl9pyhd"))))
3737     (build-system asdf-build-system/sbcl)
3738     (inputs
3739      `(("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)))
3740     (home-page "https://edicl.github.io/chunga/")
3741     (synopsis "Portable chunked streams for Common Lisp")
3742     (description
3743      "Chunga implements streams capable of chunked encoding on demand as
3744 defined in RFC 2616.")
3745     (license license:bsd-2)))
3746
3747 (define-public cl-chunga
3748   (sbcl-package->cl-source-package sbcl-chunga))
3749
3750 (define-public sbcl-cl-who
3751   (let ((version "1.1.4")
3752         (commit "2c08caa4bafba720409af9171feeba3f32e86d32")
3753         (revision "1"))
3754     (package
3755       (name "sbcl-cl-who")
3756       (version (git-version version revision commit))
3757       (source
3758        (origin
3759          (method git-fetch)
3760          (uri (git-reference
3761                (url "https://github.com/edicl/cl-who.git")
3762                (commit commit)))
3763          (file-name (git-file-name name version))
3764          (sha256
3765           (base32
3766            "0yjb6sr3yazm288m318kqvj9xk8rm9n1lpimgf65ymqv0i5agxsb"))))
3767       (build-system asdf-build-system/sbcl)
3768       (native-inputs
3769        `(("sbcl-flexi-streams" ,sbcl-flexi-streams)))
3770       (home-page "https://edicl.github.io/cl-who/")
3771       (synopsis "Yet another Lisp markup language")
3772       (description
3773        "There are plenty of Lisp Markup Languages out there - every Lisp
3774 programmer seems to write at least one during his career - and CL-WHO (where
3775 WHO means \"with-html-output\" for want of a better acronym) is probably just
3776 as good or bad as the next one.")
3777       (license license:bsd-2))))
3778
3779 (define-public cl-cl-who
3780   (sbcl-package->cl-source-package sbcl-cl-who))
3781
3782 (define-public sbcl-chipz
3783   (let ((version "0.8")
3784         (commit "75dfbc660a5a28161c57f115adf74c8a926bfc4d")
3785         (revision "1"))
3786     (package
3787       (name "sbcl-chipz")
3788       (version (git-version version revision commit))
3789       (source
3790        (origin
3791          (method git-fetch)
3792          (uri (git-reference
3793                (url "https://github.com/froydnj/chipz.git")
3794                (commit commit)))
3795          (file-name (git-file-name name version))
3796          (sha256
3797           (base32
3798            "0plx4rs39zbs4gjk77h4a2q11zpy75fh9v8hnxrvsf8fnakajhwg"))))
3799       (build-system asdf-build-system/sbcl)
3800       (native-inputs
3801        `(("sbcl-flexi-streams" ,sbcl-flexi-streams)))
3802       (home-page "http://method-combination.net/lisp/chipz/")
3803       (synopsis
3804        "Common Lisp library for decompressing deflate, zlib, gzip, and bzip2
3805 data")
3806       (description
3807        "DEFLATE data, defined in RFC1951, forms the core of popular
3808 compression formats such as zlib (RFC 1950) and gzip (RFC 1952).  As such,
3809 Chipz also provides for decompressing data in those formats as well.  BZIP2 is
3810 the format used by the popular compression tool bzip2.")
3811       ;; The author describes it as "MIT-like"
3812       (license license:expat))))
3813
3814 (define-public cl-chipz
3815   (sbcl-package->cl-source-package sbcl-chipz))
3816
3817 (define-public sbcl-drakma
3818   (package
3819     (name "sbcl-drakma")
3820     (version "2.0.7")
3821     (source
3822      (origin
3823        (method git-fetch)
3824        (uri (git-reference
3825              (url "https://github.com/edicl/drakma.git")
3826              (commit (string-append "v" version))))
3827        (file-name (git-file-name name version))
3828        (sha256
3829         (base32
3830          "1441idnyif9xzx3ln1p3fg36k2v9h4wasjqrzc8y52j61420qpci"))))
3831     (build-system asdf-build-system/sbcl)
3832     (inputs
3833      `(("sbcl-puri" ,sbcl-puri)
3834        ("sbcl-cl-base64" ,sbcl-cl-base64)
3835        ("sbcl-chunga" ,sbcl-chunga)
3836        ("sbcl-flexi-streams" ,sbcl-flexi-streams)
3837        ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
3838        ("sbcl-chipz" ,sbcl-chipz)
3839        ("sbcl-usocket" ,sbcl-usocket)
3840        ("sbcl-cl+ssl" ,sbcl-cl+ssl)))
3841     (native-inputs
3842      `(("sbcl-fiveam" ,sbcl-fiveam)))
3843     (home-page "https://edicl.github.io/drakma/")
3844     (synopsis "HTTP client written in Common Lisp")
3845     (description
3846      "Drakma is a full-featured HTTP client implemented in Common Lisp.  It
3847 knows how to handle HTTP/1.1 chunking, persistent connections, re-usable
3848 sockets, SSL, continuable uploads, file uploads, cookies, and more.")
3849     (license license:bsd-2)))
3850
3851 (define-public cl-drakma
3852   (sbcl-package->cl-source-package sbcl-drakma))
3853
3854 (define-public ecl-drakma
3855   (sbcl-package->ecl-package sbcl-drakma))
3856
3857 (define-public sbcl-hunchentoot
3858   (package
3859     (name "sbcl-hunchentoot")
3860     (version "1.2.38")
3861     (source
3862      (origin
3863        (method git-fetch)
3864        (uri (git-reference
3865              (url "https://github.com/edicl/hunchentoot.git")
3866              (commit (string-append "v" version))))
3867        (file-name (git-file-name "hunchentoot" version))
3868        (sha256
3869         (base32 "1anpcad7w045m4rsjs1f3xdhjwx5cppq1h0vlb3q7dz81fi3i6yq"))))
3870     (build-system asdf-build-system/sbcl)
3871     (native-inputs
3872      `(("sbcl-cl-who" ,sbcl-cl-who)
3873        ("sbcl-drakma" ,sbcl-drakma)))
3874     (inputs
3875      `(("sbcl-chunga" ,sbcl-chunga)
3876        ("sbcl-cl-base64" ,sbcl-cl-base64)
3877        ("sbcl-cl-fad" ,sbcl-cl-fad)
3878        ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
3879        ("sbcl-flexi-streams" ,sbcl-flexi-streams)
3880        ("sbcl-cl+ssl" ,sbcl-cl+ssl)
3881        ("sbcl-md5" ,sbcl-md5)
3882        ("sbcl-rfc2388" ,sbcl-rfc2388)
3883        ("sbcl-trivial-backtrace" ,sbcl-trivial-backtrace)
3884        ("sbcl-usocket" ,sbcl-usocket)))
3885     (home-page "https://edicl.github.io/hunchentoot/")
3886     (synopsis "Web server written in Common Lisp")
3887     (description
3888      "Hunchentoot is a web server written in Common Lisp and at the same
3889 time a toolkit for building dynamic websites.  As a stand-alone web server,
3890 Hunchentoot is capable of HTTP/1.1 chunking (both directions), persistent
3891 connections (keep-alive), and SSL.")
3892     (license license:bsd-2)))
3893
3894 (define-public cl-hunchentoot
3895   (sbcl-package->cl-source-package sbcl-hunchentoot))
3896
3897 (define-public sbcl-trivial-types
3898   (package
3899     (name "sbcl-trivial-types")
3900     (version "0.0.1")
3901     (source
3902      (origin
3903        (method git-fetch)
3904        (uri (git-reference
3905              (url "https://github.com/m2ym/trivial-types.git")
3906              (commit "ee869f2b7504d8aa9a74403641a5b42b16f47d88")))
3907        (file-name (git-file-name name version))
3908        (sha256
3909         (base32 "1s4cp9bdlbn8447q7w7f1wkgwrbvfzp20mgs307l5pxvdslin341"))))
3910     (build-system asdf-build-system/sbcl)
3911     (home-page "https://github.com/m2ym/trivial-types")
3912     (synopsis "Trivial type definitions for Common Lisp")
3913     (description
3914      "TRIVIAL-TYPES provides missing but important type definitions such as
3915 PROPER-LIST, ASSOCIATION-LIST, PROPERTY-LIST and TUPLE.")
3916     (license license:llgpl)))
3917
3918 (define-public cl-trivial-types
3919   (sbcl-package->cl-source-package sbcl-trivial-types))
3920
3921 (define-public sbcl-cl-syntax
3922   (package
3923     (name "sbcl-cl-syntax")
3924     (version "0.0.3")
3925     (source
3926      (origin
3927        (method git-fetch)
3928        (uri (git-reference
3929              (url "https://github.com/m2ym/cl-syntax.git")
3930              (commit "03f0c329bbd55b8622c37161e6278366525e2ccc")))
3931        (file-name (git-file-name "cl-syntax" version))
3932        (sha256
3933         (base32 "17ran8xp77asagl31xv8w819wafh6whwfc9p6dgx22ca537gyl4y"))))
3934     (build-system asdf-build-system/sbcl)
3935     (arguments
3936      '(#:asd-file "cl-syntax.asd"
3937        #:asd-system-name "cl-syntax"))
3938     (inputs `(("sbcl-trivial-types" ,sbcl-trivial-types)
3939               ("sbcl-named-readtables" ,sbcl-named-readtables)))
3940     (home-page "https://github.com/m2ym/cl-syntax")
3941     (synopsis "Reader Syntax Coventions for Common Lisp and SLIME")
3942     (description
3943      "CL-SYNTAX provides Reader Syntax Coventions for Common Lisp and SLIME.")
3944     (license license:llgpl)))
3945
3946 (define-public cl-syntax
3947   (sbcl-package->cl-source-package sbcl-cl-syntax))
3948
3949 (define-public sbcl-cl-annot
3950   (let ((commit "c99e69c15d935eabc671b483349a406e0da9518d")
3951         (revision "1"))
3952     (package
3953       (name "sbcl-cl-annot")
3954       (version (git-version "0.0.0" revision commit))
3955       (source
3956        (origin
3957          (method git-fetch)
3958          (uri (git-reference
3959                (url "https://github.com/m2ym/cl-annot.git")
3960                (commit commit)))
3961          (file-name (git-file-name name version))
3962          (sha256
3963           (base32 "1wq1gs9jjd5m6iwrv06c2d7i5dvqsfjcljgbspfbc93cg5xahk4n"))))
3964       (build-system asdf-build-system/sbcl)
3965     (arguments
3966      '(#:asd-file "cl-annot.asd"
3967        #:asd-system-name "cl-annot"))
3968       (inputs
3969        `(("sbcl-alexandria" ,sbcl-alexandria)))
3970       (home-page "https://github.com/m2ym/cl-annot")
3971       (synopsis "Python-like Annotation Syntax for Common Lisp.")
3972       (description
3973        "@code{cl-annot} is an general annotation library for Common Lisp.")
3974       (license license:llgpl))))
3975
3976 (define-public cl-annot
3977   (sbcl-package->cl-source-package sbcl-cl-annot))
3978
3979 (define-public sbcl-cl-syntax-annot
3980   (package
3981     (name "sbcl-cl-syntax-annot")
3982     (version "0.0.3")
3983     (source
3984      (origin
3985        (method git-fetch)
3986        (uri (git-reference
3987              (url "https://github.com/m2ym/cl-syntax.git")
3988              (commit "03f0c329bbd55b8622c37161e6278366525e2ccc")))
3989        (file-name (git-file-name name version))
3990        (sha256
3991         (base32 "17ran8xp77asagl31xv8w819wafh6whwfc9p6dgx22ca537gyl4y"))))
3992     (build-system asdf-build-system/sbcl)
3993     (arguments
3994      '(#:asd-file "cl-syntax-annot.asd"
3995        #:asd-system-name "cl-syntax-annot"))
3996     (inputs
3997      `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
3998        ("sbcl-cl-annot" ,sbcl-cl-annot)))
3999     (home-page "https://github.com/m2ym/cl-syntax")
4000     (synopsis "Reader Syntax Coventions for Common Lisp and SLIME")
4001     (description
4002      "CL-SYNTAX provides Reader Syntax Coventions for Common Lisp and
4003 SLIME.")
4004     (license license:llgpl)))
4005
4006 (define-public cl-syntax-annot
4007   (sbcl-package->cl-source-package sbcl-cl-syntax-annot))
4008
4009 (define-public sbcl-cl-utilities
4010   (let ((commit "dce2d2f6387091ea90357a130fa6d13a6776884b")
4011         (revision "1"))
4012     (package
4013       (name "sbcl-cl-utilities")
4014       (version (git-version "0.0.0" revision commit))
4015       (source
4016        (origin
4017          (method url-fetch)
4018          (uri
4019           (string-append
4020            "https://gitlab.common-lisp.net/cl-utilities/cl-utilities/-/"
4021            "archive/" commit "/cl-utilities-" commit ".tar.gz"))
4022          (sha256
4023           (base32 "1r46v730yf96nk2vb24qmagv9x96xvd08abqwhf02ghgydv1a7z2"))))
4024       (build-system asdf-build-system/sbcl)
4025       (arguments
4026        '(#:asd-file "cl-utilities.asd"
4027          #:asd-system-name "cl-utilities"
4028          #:phases
4029          (modify-phases %standard-phases
4030            (add-after 'unpack 'fix-paths
4031              (lambda* (#:key inputs #:allow-other-keys)
4032                (substitute* "rotate-byte.lisp"
4033                  (("in-package :cl-utilities)" all)
4034                   "in-package :cl-utilities)\n\n#+sbcl\n(require :sb-rotate-byte)")))))))
4035       (home-page "http://common-lisp.net/project/cl-utilities")
4036       (synopsis "A collection of semi-standard utilities")
4037       (description
4038        "On Cliki.net <http://www.cliki.net/Common%20Lisp%20Utilities>, there
4039 is a collection of Common Lisp Utilities, things that everybody writes since
4040 they're not part of the official standard.  There are some very useful things
4041 there; the only problems are that they aren't implemented as well as you'd
4042 like (some aren't implemented at all) and they aren't conveniently packaged
4043 and maintained.  It takes quite a bit of work to carefully implement utilities
4044 for common use, commented and documented, with error checking placed
4045 everywhere some dumb user might make a mistake.")
4046       (license license:public-domain))))
4047
4048 (define-public cl-utilities
4049   (sbcl-package->cl-source-package sbcl-cl-utilities))
4050
4051 (define-public sbcl-map-set
4052   (let ((commit "7b4b545b68b8")
4053         (revision "1"))
4054     (package
4055       (name "sbcl-map-set")
4056       (version (git-version "0.0.0" revision commit))
4057       (source
4058        (origin
4059          (method url-fetch)
4060          (uri (string-append
4061                "https://bitbucket.org/tarballs_are_good/map-set/get/"
4062                commit ".tar.gz"))
4063          (sha256
4064           (base32 "1sx5j5qdsy5fklspfammwb16kjrhkggdavm922a9q86jm5l0b239"))))
4065       (build-system asdf-build-system/sbcl)
4066       (home-page "https://bitbucket.org/tarballs_are_good/map-set")
4067       (synopsis "Set-like data structure")
4068       (description
4069        "Implementation of a set-like data structure with constant time
4070 addition, removal, and random selection.")
4071       (license license:bsd-3))))
4072
4073 (define-public cl-map-set
4074   (sbcl-package->cl-source-package sbcl-map-set))
4075
4076 (define-public sbcl-quri
4077   (let ((commit "76b75103f21ead092c9f715512fa82441ef61185")
4078         (revision "1"))
4079     (package
4080       (name "sbcl-quri")
4081       (version (git-version "0.1.0" revision commit))
4082       (source
4083        (origin
4084          (method git-fetch)
4085          (uri (git-reference
4086                (url "https://github.com/fukamachi/quri.git")
4087                (commit commit)))
4088          (file-name (git-file-name name version))
4089          (sha256
4090           (base32 "1ccbxsgzdibmzq33mmbmmz9vwl6l03xh6nbpsh1hkdvdcl7q0a60"))))
4091       (build-system asdf-build-system/sbcl)
4092       (arguments
4093        ;; Tests fail with: Component QURI-ASD::QURI-TEST not found,
4094        ;; required by #<SYSTEM "quri">. Why?
4095        '(#:tests? #f))
4096       (native-inputs `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4097                        ("sbcl-prove" ,sbcl-prove)))
4098       (inputs `(("sbcl-babel" ,sbcl-babel)
4099                 ("sbcl-split-sequence" ,sbcl-split-sequence)
4100                 ("sbcl-cl-utilities" ,sbcl-cl-utilities)
4101                 ("sbcl-alexandria" ,sbcl-alexandria)))
4102       (home-page "https://github.com/fukamachi/quri")
4103       (synopsis "Yet another URI library for Common Lisp")
4104       (description
4105        "QURI (pronounced \"Q-ree\") is yet another URI library for Common
4106 Lisp. It is intended to be a replacement of PURI.")
4107       (license license:bsd-3))))
4108
4109 (define-public cl-quri
4110   (sbcl-package->cl-source-package sbcl-quri))
4111
4112 (define-public sbcl-myway
4113   (let ((commit "286230082a11f879c18b93f17ca571c5f676bfb7")
4114         (revision "1"))
4115     (package
4116      (name "sbcl-myway")
4117      (version (git-version "0.1.0" revision commit))
4118      (source
4119       (origin
4120        (method git-fetch)
4121        (uri (git-reference
4122              (url "https://github.com/fukamachi/myway.git")
4123              (commit commit)))
4124        (file-name (git-file-name "myway" version))
4125        (sha256
4126         (base32 "0briia9bk3lbr0frnx39d1qg6i38dm4j6z9w3yga3d40k6df4a90"))))
4127      (build-system asdf-build-system/sbcl)
4128      (arguments
4129       ;; Tests fail with: Component MYWAY-ASD::MYWAY-TEST not found, required
4130       ;; by #<SYSTEM "myway">. Why?
4131       '(#:tests? #f))
4132      (native-inputs
4133       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4134         ("sbcl-prove" ,sbcl-prove)))
4135      (inputs
4136       `(("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
4137         ("sbcl-quri" ,sbcl-quri)
4138         ("sbcl-map-set" ,sbcl-map-set)))
4139      (home-page "https://github.com/fukamachi/myway")
4140      (synopsis "Sinatra-compatible URL routing library for Common Lisp")
4141      (description "My Way is a Sinatra-compatible URL routing library.")
4142      (license license:llgpl))))
4143
4144 (define-public cl-myway
4145   (sbcl-package->cl-source-package sbcl-myway))
4146
4147 (define-public sbcl-xsubseq
4148   (let ((commit "5ce430b3da5cda3a73b9cf5cee4df2843034422b")
4149         (revision "1"))
4150     (package
4151      (name "sbcl-xsubseq")
4152      (version (git-version "0.0.1" revision commit))
4153      (source
4154       (origin
4155        (method git-fetch)
4156        (uri (git-reference
4157              (url "https://github.com/fukamachi/xsubseq")
4158              (commit commit)))
4159        (file-name (git-file-name name version))
4160        (sha256
4161         (base32 "1xz79q0p2mclf3sqjiwf6izdpb6xrsr350bv4mlmdlm6rg5r99px"))))
4162      (build-system asdf-build-system/sbcl)
4163      (arguments
4164       ;; Tests fail with: Component XSUBSEQ-ASD::XSUBSEQ-TEST not found,
4165       ;; required by #<SYSTEM "xsubseq">. Why?
4166       '(#:tests? #f))
4167      (native-inputs
4168       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4169         ("sbcl-prove" ,sbcl-prove)))
4170      (home-page "https://github.com/fukamachi/xsubseq")
4171      (synopsis "Efficient way to use \"subseq\"s in Common Lisp")
4172      (description
4173       "XSubseq provides functions to be able to handle \"subseq\"s more
4174 effieiently.")
4175      (license license:bsd-2))))
4176
4177 (define-public cl-xsubseq
4178   (sbcl-package->cl-source-package sbcl-xsubseq))
4179
4180 (define-public sbcl-smart-buffer
4181   (let ((commit "09b9a9a0b3abaa37abe9a730f5aac2643dca4e62")
4182         (revision "1"))
4183     (package
4184       (name "sbcl-smart-buffer")
4185       (version (git-version "0.0.1" revision commit))
4186       (source
4187        (origin
4188          (method git-fetch)
4189          (uri (git-reference
4190                (url "https://github.com/fukamachi/smart-buffer")
4191                (commit commit)))
4192          (file-name (git-file-name name version))
4193          (sha256
4194           (base32 "0qz1zzxx0wm5ff7gpgsq550a59p0qj594zfmm2rglj97dahj54l7"))))
4195       (build-system asdf-build-system/sbcl)
4196       (arguments
4197        ;; Tests fail with: Component SMART-BUFFER-ASD::SMART-BUFFER-TEST not
4198        ;; found, required by #<SYSTEM "smart-buffer">. Why?
4199        `(#:tests? #f))
4200       (native-inputs
4201        `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4202          ("sbcl-prove" ,sbcl-prove)))
4203       (inputs
4204        `(("sbcl-xsubseq" ,sbcl-xsubseq)
4205          ("sbcl-flexi-streams" ,sbcl-flexi-streams)))
4206       (home-page "https://github.com/fukamachi/smart-buffer")
4207       (synopsis "Smart octets buffer")
4208       (description
4209        "Smart-buffer provides an output buffer which changes the destination
4210 depending on content size.")
4211       (license license:bsd-3))))
4212
4213 (define-public cl-smart-buffer
4214   (sbcl-package->cl-source-package sbcl-smart-buffer))
4215
4216 (define-public sbcl-fast-http
4217   (let ((commit "f9e7597191bae380503e20724fd493a24d024935")
4218         (revision "1"))
4219     (package
4220       (name "sbcl-fast-http")
4221       (version (git-version "0.2.0" revision commit))
4222       (source
4223        (origin
4224          (method git-fetch)
4225          (uri (git-reference
4226                (url "https://github.com/fukamachi/fast-http")
4227                (commit commit)))
4228          (file-name (git-file-name name version))
4229          (sha256
4230           (base32 "0qdmwv2zm0sizxdb8nnclgwl0nfjcbjaimbakavikijw7lr9b4jp"))))
4231       (build-system asdf-build-system/sbcl)
4232       (arguments
4233        ;; Tests fail with: Component FAST-HTTP-ASD::FAST-HTTP-TEST not found,
4234        ;; required by #<SYSTEM "fast-http">. Why?
4235        `(#:tests? #f))
4236       (native-inputs
4237        `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4238          ("sbcl-prove" ,sbcl-prove)))
4239       (inputs
4240        `(("sbcl-alexandria" ,sbcl-alexandria)
4241          ("sbcl-proc-parse" ,sbcl-proc-parse)
4242          ("sbcl-xsubseq" ,sbcl-xsubseq)
4243          ("sbcl-smart-buffer" ,sbcl-smart-buffer)
4244          ("sbcl-cl-utilities" ,sbcl-cl-utilities)))
4245       (home-page "https://github.com/fukamachi/fast-http")
4246       (synopsis "HTTP request/response parser for Common Lisp")
4247       (description
4248        "@code{fast-http} is a HTTP request/response protocol parser for Common
4249 Lisp.")
4250       ;; Author specified the MIT license
4251       (license license:expat))))
4252
4253 (define-public cl-fast-http
4254   (sbcl-package->cl-source-package sbcl-fast-http))
4255
4256 (define-public sbcl-static-vectors
4257   (package
4258     (name "sbcl-static-vectors")
4259     (version "1.8.4")
4260     (source
4261      (origin
4262        (method git-fetch)
4263        (uri (git-reference
4264              (url "https://github.com/sionescu/static-vectors.git")
4265              (commit (string-append "v" version))))
4266        (file-name (git-file-name name version))
4267        (sha256
4268         (base32 "0qvf9z6bhwhm8n45fjwkm7j8dcb58szfvndky65cyn4lpdval7m1"))))
4269     (native-inputs
4270      `(("sbcl-fiveam" ,sbcl-fiveam)))
4271     (inputs
4272      `(("sbcl-cffi-grovel" ,sbcl-cffi-grovel)
4273        ("sbcl-cffi" ,sbcl-cffi)))
4274     (build-system asdf-build-system/sbcl)
4275     (home-page "https://github.com/sionescu/static-vectors")
4276     (synopsis "Allocate SIMPLE-ARRAYs in static memory")
4277     (description
4278      "With @code{static-vectors}, you can create vectors allocated in static
4279 memory.")
4280     (license license:expat)))
4281
4282 (define-public cl-static-vectors
4283   (sbcl-package->cl-source-package sbcl-static-vectors))
4284
4285 (define-public ecl-static-vectors
4286   (sbcl-package->ecl-package sbcl-static-vectors))
4287
4288 (define-public sbcl-marshal
4289   (let ((commit "eff1b15f2b0af2f26f71ad6a4dd5c4beab9299ec")
4290         (revision "1"))
4291     (package
4292      (name "sbcl-marshal")
4293      (version (git-version "1.3.0" revision commit))
4294      (source
4295       (origin
4296        (method git-fetch)
4297        (uri (git-reference
4298              (url "https://github.com/wlbr/cl-marshal.git")
4299              (commit commit)))
4300        (file-name (git-file-name name version))
4301        (sha256
4302         (base32 "08qs6fhk38xpkkjkpcj92mxx0lgy4ygrbbzrmnivdx281syr0gwh"))))
4303      (build-system asdf-build-system/sbcl)
4304      (home-page "https://github.com/wlbr/cl-marshal")
4305      (synopsis "Simple (de)serialization of Lisp datastructures")
4306      (description
4307       "Simple and fast marshalling of Lisp datastructures.  Convert any object
4308 into a string representation, put it on a stream an revive it from there.
4309 Only minimal changes required to make your CLOS objects serializable.")
4310      (license license:expat))))
4311
4312 (define-public cl-marshal
4313   (sbcl-package->cl-source-package sbcl-marshal))
4314
4315 (define-public sbcl-checkl
4316   (let ((commit "80328800d047fef9b6e32dfe6bdc98396aee3cc9")
4317         (revision "1"))
4318     (package
4319       (name "sbcl-checkl")
4320       (version (git-version "0.0.0" revision commit))
4321       (source
4322        (origin
4323          (method git-fetch)
4324          (uri (git-reference
4325                (url "https://github.com/rpav/CheckL.git")
4326                (commit commit)))
4327          (file-name (git-file-name name version))
4328          (sha256
4329           (base32 "0bpisihx1gay44xmyr1dmhlwh00j0zzi04rp9fy35i95l2r4xdlx"))))
4330       (build-system asdf-build-system/sbcl)
4331       (arguments
4332        ;; Error while trying to load definition for system checkl-test from
4333        ;; pathname [...]/checkl-test.asd: The function CHECKL:DEFINE-TEST-OP
4334        ;; is undefined.
4335        '(#:tests? #f))
4336       (native-inputs
4337        `(("sbcl-fiveam" ,sbcl-fiveam)))
4338       (inputs
4339        `(("sbcl-marshal" ,sbcl-marshal)))
4340       (home-page "https://github.com/rpav/CheckL/")
4341       (synopsis "Dynamic testing for Common Lisp")
4342       (description
4343        "CheckL lets you write tests dynamically, it checks resulting values
4344 against the last run.")
4345       ;; The author specifies both LLGPL and "BSD", but the "BSD" license
4346       ;; isn't specified anywhere, so I don't know which kind.  LLGPL is the
4347       ;; stronger of the two and so I think only listing this should suffice.
4348       (license license:llgpl))))
4349
4350 (define-public cl-checkl
4351   (sbcl-package->cl-source-package sbcl-checkl))
4352
4353 (define-public sbcl-fast-io
4354   (let ((commit "dc3a71db7e9b756a88781ae9c342fe9d4bbab51c")
4355         (revision "1"))
4356     (package
4357      (name "sbcl-fast-io")
4358      (version (git-version "1.0.0" revision commit))
4359      (source
4360       (origin
4361        (method git-fetch)
4362        (uri (git-reference
4363              (url "https://github.com/rpav/fast-io.git")
4364              (commit commit)))
4365        (file-name (git-file-name name version))
4366        (sha256
4367         (base32 "1jsp6xvi26ln6fdy5j5zi05xvan8jsqdhisv552dy6xg6ws8i1yq"))))
4368      (build-system asdf-build-system/sbcl)
4369      (arguments
4370       ;; Error while trying to load definition for system fast-io-test from
4371       ;; pathname [...]/fast-io-test.asd: The function CHECKL:DEFINE-TEST-OP
4372       ;; is undefined.
4373       '(#:tests? #f))
4374      (native-inputs
4375       `(("sbcl-fiveam" ,sbcl-fiveam)
4376         ("sbcl-checkl" ,sbcl-checkl)))
4377      (inputs
4378       `(("sbcl-alexandria" ,sbcl-alexandria)
4379         ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)
4380         ("sbcl-static-vectors" ,sbcl-static-vectors)))
4381      (home-page "https://github.com/rpav/fast-io")
4382      (synopsis "Fast octet-vector/stream I/O for Common Lisp")
4383      (description
4384       "Fast-io is about improving performance to octet-vectors and octet
4385 streams (though primarily the former, while wrapping the latter).")
4386      ;; Author specifies this as NewBSD which is an alias
4387      (license license:bsd-3))))
4388
4389 (define-public cl-fast-io
4390   (sbcl-package->cl-source-package sbcl-fast-io))
4391
4392 (define-public sbcl-jonathan
4393   (let ((commit "1f448b4f7ac8265e56e1c02b32ce383e65316300")
4394         (revision "1"))
4395     (package
4396      (name "sbcl-jonathan")
4397      (version (git-version "0.1.0" revision commit))
4398      (source
4399       (origin
4400        (method git-fetch)
4401        (uri (git-reference
4402              (url "https://github.com/Rudolph-Miller/jonathan.git")
4403              (commit commit)))
4404        (file-name (git-file-name name version))
4405        (sha256
4406         (base32 "14x4iwz3mbag5jzzzr4sb6ai0m9r4q4kyypbq32jmsk2dx1hi807"))))
4407      (build-system asdf-build-system/sbcl)
4408      (arguments
4409       ;; Tests fail with: Component JONATHAN-ASD::JONATHAN-TEST not found,
4410       ;; required by #<SYSTEM "jonathan">. Why?
4411       `(#:tests? #f))
4412      (native-inputs
4413       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4414         ("sbcl-prove" ,sbcl-prove)))
4415      (inputs
4416       `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
4417         ("sbcl-cl-syntax-annot" ,sbcl-cl-syntax-annot)
4418         ("sbcl-fast-io" ,sbcl-fast-io)
4419         ("sbcl-proc-parse" ,sbcl-proc-parse)
4420         ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)))
4421      (home-page "https://rudolph-miller.github.io/jonathan/overview.html")
4422      (synopsis "JSON encoder and decoder")
4423      (description
4424       "High performance JSON encoder and decoder.  Currently support: SBCL,
4425 CCL.")
4426      ;; Author specifies the MIT license
4427      (license license:expat))))
4428
4429 (define-public cl-jonathan
4430   (sbcl-package->cl-source-package sbcl-jonathan))
4431
4432 (define-public sbcl-http-body
4433   (let ((commit "dd01dc4f5842e3d29728552e5163acce8386eb73")
4434         (revision "1"))
4435     (package
4436      (name "sbcl-http-body")
4437      (version (git-version "0.1.0" revision commit))
4438      (source
4439       (origin
4440        (method git-fetch)
4441        (uri (git-reference
4442              (url "https://github.com/fukamachi/http-body")
4443              (commit commit)))
4444        (file-name (git-file-name name version))
4445        (sha256
4446         (base32 "1jd06snjvxcprhapgfq8sx0y5lrldkvhf206ix6d5a23dd6zcmr0"))))
4447      (build-system asdf-build-system/sbcl)
4448      (arguments
4449       ;; Tests fail with: Component HTTP-BODY-ASD::HTTP-BODY-TEST not
4450       ;; found, required by #<SYSTEM "http-body">. Why?
4451       `(#:tests? #f))
4452      (native-inputs
4453       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4454         ("sbcl-prove" ,sbcl-prove)))
4455      (inputs
4456       `(("sbcl-fast-http" ,sbcl-fast-http)
4457         ("sbcl-jonathan" ,sbcl-jonathan)
4458         ("sbcl-quri" ,sbcl-quri)))
4459      (home-page "https://github.com/fukamachi/http-body")
4460      (synopsis "HTTP POST data parser")
4461      (description
4462       "HTTP-Body parses HTTP POST data and returns POST parameters.  It
4463 supports application/x-www-form-urlencoded, application/json, and
4464 multipart/form-data.")
4465      (license license:bsd-2))))
4466
4467 (define-public cl-http-body
4468   (sbcl-package->cl-source-package sbcl-http-body))
4469
4470 (define-public sbcl-circular-streams
4471   (let ((commit "e770bade1919c5e8533dd2078c93c3d3bbeb38df")
4472         (revision "1"))
4473     (package
4474      (name "sbcl-circular-streams")
4475      (version (git-version "0.1.0" revision commit))
4476      (source
4477       (origin
4478        (method git-fetch)
4479        (uri (git-reference
4480              (url "https://github.com/fukamachi/circular-streams")
4481              (commit commit)))
4482        (file-name (git-file-name name version))
4483        (sha256
4484         (base32 "1wpw6d5cciyqcf92f7mvihak52pd5s47kk4qq6f0r2z2as68p5rs"))))
4485      (build-system asdf-build-system/sbcl)
4486      (arguments
4487       ;; The tests depend on cl-test-more which is now prove. Prove
4488       ;; tests aren't working for some reason.
4489       `(#:tests? #f))
4490      (inputs
4491       `(("sbcl-fast-io" ,sbcl-fast-io)
4492         ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)))
4493      (home-page "https://github.com/fukamachi/circular-streams")
4494      (synopsis "Circularly readable streams for Common Lisp")
4495      (description
4496       "Circular-Streams allows you to read streams circularly by wrapping real
4497 streams. Once you reach end-of-file of a stream, it's file position will be
4498 reset to 0 and you're able to read it again.")
4499      (license license:llgpl))))
4500
4501 (define-public cl-circular-streams
4502   (sbcl-package->cl-source-package sbcl-circular-streams))
4503
4504 (define-public sbcl-lack-request
4505   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4506         (revision "1"))
4507     (package
4508      (name "sbcl-lack-request")
4509      (version (git-version "0.1.0" revision commit))
4510      (source
4511       (origin
4512        (method git-fetch)
4513        (uri (git-reference
4514              (url "https://github.com/fukamachi/lack.git")
4515              (commit commit)))
4516        (file-name (git-file-name "lack-request" version))
4517        (sha256
4518         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4519      (build-system asdf-build-system/sbcl)
4520      (arguments
4521       '(#:asd-file "lack-request.asd"
4522         #:asd-system-name "lack-request"
4523         #:test-asd-file "t-lack-request.asd"
4524         ;; XXX: Component :CLACK-TEST not found
4525         #:tests? #f))
4526      (native-inputs
4527       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4528         ("sbcl-prove" ,sbcl-prove)))
4529      (inputs
4530       `(("sbcl-quri" ,sbcl-quri)
4531         ("sbcl-http-body" ,sbcl-http-body)
4532         ("sbcl-circular-streams" ,sbcl-circular-streams)))
4533      (home-page "https://github.com/fukamachi/lack")
4534      (synopsis "Lack, the core of Clack")
4535      (description
4536       "Lack is a Common Lisp library which allows web applications to be
4537 constructed of modular components.  It was originally a part of Clack, however
4538 it's going to be rewritten as an individual project since Clack v2 with
4539 performance and simplicity in mind.")
4540      (license license:llgpl))))
4541
4542 (define-public cl-lack-request
4543   (sbcl-package->cl-source-package sbcl-lack-request))
4544
4545 (define-public sbcl-local-time
4546   (let ((commit "beac054eef428552b63d4ae7820c32ffef9a3015")
4547         (revision "1"))
4548     (package
4549      (name "sbcl-local-time")
4550      (version (git-version "1.0.6" revision commit))
4551      (source
4552       (origin
4553        (method git-fetch)
4554        (uri (git-reference
4555              (url "https://github.com/dlowe-net/local-time.git")
4556              (commit commit)))
4557        (file-name (git-file-name name version))
4558        (sha256
4559         (base32 "0xhkmgxh41dg2wwlsp0h2l41jp144xn4gpxhh0lna6kh0560w2cc"))))
4560      (build-system asdf-build-system/sbcl)
4561      (arguments
4562       ;; TODO: Component :STEFIL not found, required by #<SYSTEM
4563       ;; "local-time/test">
4564       '(#:tests? #f))
4565      (native-inputs
4566       `(("stefil" ,sbcl-hu.dwim.stefil)))
4567      (inputs
4568       `(("sbcl-cl-fad" ,sbcl-cl-fad)))
4569      (home-page "https://common-lisp.net/project/local-time/")
4570      (synopsis "Time manipulation library for Common Lisp")
4571      (description
4572       "The LOCAL-TIME library is a Common Lisp library for the manipulation of
4573 dates and times.  It is based almost entirely upon Erik Naggum's paper \"The
4574 Long Painful History of Time\".")
4575      (license license:expat))))
4576
4577 (define-public cl-local-time
4578   (sbcl-package->cl-source-package sbcl-local-time))
4579
4580 (define-public sbcl-lack-response
4581   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4582         (revision "1"))
4583     (package
4584      (name "sbcl-lack-response")
4585      (version (git-version "0.1.0" revision commit))
4586      (source
4587       (origin
4588        (method git-fetch)
4589        (uri (git-reference
4590              (url "https://github.com/fukamachi/lack.git")
4591              (commit commit)))
4592        (file-name (git-file-name name version))
4593        (sha256
4594         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4595      (build-system asdf-build-system/sbcl)
4596      (arguments
4597       '(#:asd-file "lack-response.asd"
4598         #:asd-system-name "lack-response"
4599         ;; XXX: no tests for lack-response.
4600         #:tests? #f))
4601      (native-inputs
4602       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4603         ("sbcl-prove" ,sbcl-prove)))
4604      (inputs
4605       `(("sbcl-quri" ,sbcl-quri)
4606         ("sbcl-http-body" ,sbcl-http-body)
4607         ("sbcl-circular-streams" ,sbcl-circular-streams)
4608         ("sbcl-local-time" ,sbcl-local-time)))
4609      (home-page "https://github.com/fukamachi/lack")
4610      (synopsis "Lack, the core of Clack")
4611      (description
4612       "Lack is a Common Lisp library which allows web applications to be
4613 constructed of modular components.  It was originally a part of Clack, however
4614 it's going to be rewritten as an individual project since Clack v2 with
4615 performance and simplicity in mind.")
4616      (license license:llgpl))))
4617
4618 (define-public cl-lack-response
4619   (sbcl-package->cl-source-package sbcl-lack-response))
4620
4621 (define-public sbcl-lack-component
4622   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4623         (revision "1"))
4624     (package
4625      (name "sbcl-lack-component")
4626      (version (git-version "0.0.0" revision commit))
4627      (source
4628       (origin
4629        (method git-fetch)
4630        (uri (git-reference
4631              (url "https://github.com/fukamachi/lack.git")
4632              (commit commit)))
4633        (file-name (git-file-name "lack-component" version))
4634        (sha256
4635         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4636      (build-system asdf-build-system/sbcl)
4637      (arguments
4638       '(#:asd-file "lack-component.asd"
4639         #:asd-system-name "lack-component"
4640         #:test-asd-file "t-lack-component.asd"
4641         ;; XXX: Component :LACK-TEST not found
4642         #:tests? #f))
4643      (native-inputs
4644       `(("prove-asdf" ,sbcl-prove-asdf)))
4645      (home-page "https://github.com/fukamachi/lack")
4646      (synopsis "Lack, the core of Clack")
4647      (description
4648       "Lack is a Common Lisp library which allows web applications to be
4649 constructed of modular components.  It was originally a part of Clack, however
4650 it's going to be rewritten as an individual project since Clack v2 with
4651 performance and simplicity in mind.")
4652      (license license:llgpl))))
4653
4654 (define-public cl-lack-component
4655   (sbcl-package->cl-source-package sbcl-lack-component))
4656
4657 (define-public sbcl-lack-util
4658   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4659         (revision "1"))
4660     (package
4661      (name "sbcl-lack-util")
4662      (version (git-version "0.1.0" revision commit))
4663      (source
4664       (origin
4665        (method git-fetch)
4666        (uri (git-reference
4667              (url "https://github.com/fukamachi/lack.git")
4668              (commit commit)))
4669        (file-name (git-file-name "lack-util" version))
4670        (sha256
4671         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4672      (build-system asdf-build-system/sbcl)
4673      (arguments
4674       '(#:asd-file "lack-util.asd"
4675         #:asd-system-name "lack-util"
4676         #:test-asd-file "t-lack-util.asd"
4677         ;; XXX: Component :LACK-TEST not found
4678         #:tests? #f))
4679      (native-inputs
4680       `(("prove-asdf" ,sbcl-prove-asdf)))
4681      (inputs
4682       `(("sbcl-ironclad" ,sbcl-ironclad)))
4683      (home-page "https://github.com/fukamachi/lack")
4684      (synopsis "Lack, the core of Clack")
4685      (description
4686       "Lack is a Common Lisp library which allows web applications to be
4687 constructed of modular components.  It was originally a part of Clack, however
4688 it's going to be rewritten as an individual project since Clack v2 with
4689 performance and simplicity in mind.")
4690      (license license:llgpl))))
4691
4692 (define-public cl-lack-util
4693   (sbcl-package->cl-source-package sbcl-lack-util))
4694
4695 (define-public sbcl-lack-middleware-backtrace
4696   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4697         (revision "1"))
4698     (package
4699      (name "sbcl-lack-middleware-backtrace")
4700      (version (git-version "0.1.0" revision commit))
4701      (source
4702       (origin
4703        (method git-fetch)
4704        (uri (git-reference
4705              (url "https://github.com/fukamachi/lack.git")
4706              (commit commit)))
4707        (file-name (git-file-name "lack-middleware-backtrace" version))
4708        (sha256
4709         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4710      (build-system asdf-build-system/sbcl)
4711      (arguments
4712       '(#:asd-file "lack-middleware-backtrace.asd"
4713         #:asd-system-name "lack-middleware-backtrace"
4714         #:test-asd-file "t-lack-middleware-backtrace.asd"
4715         ;; XXX: Component :LACK not found
4716         #:tests? #f))
4717      (native-inputs
4718       `(("prove-asdf" ,sbcl-prove-asdf)))
4719      (home-page "https://github.com/fukamachi/lack")
4720      (synopsis "Lack, the core of Clack")
4721      (description
4722       "Lack is a Common Lisp library which allows web applications to be
4723 constructed of modular components.  It was originally a part of Clack, however
4724 it's going to be rewritten as an individual project since Clack v2 with
4725 performance and simplicity in mind.")
4726      (license license:llgpl))))
4727
4728 (define-public cl-lack-middleware-backtrace
4729   (sbcl-package->cl-source-package sbcl-lack-middleware-backtrace))
4730
4731 (define-public sbcl-trivial-mimes
4732   (let ((commit "303f8ac0aa6ca0bc139aa3c34822e623c3723fab")
4733         (revision "1"))
4734     (package
4735       (name "sbcl-trivial-mimes")
4736       (version (git-version "1.1.0" revision commit))
4737       (source
4738        (origin
4739          (method git-fetch)
4740          (uri (git-reference
4741                (url "https://github.com/Shinmera/trivial-mimes.git")
4742                (commit commit)))
4743          (file-name (git-file-name name version))
4744          (sha256
4745           (base32 "17jxgl47r695bvsb7wi3n2ws5rp1zzgvw0zii8cy5ggw4b4ayv6m"))))
4746       (build-system asdf-build-system/sbcl)
4747       (arguments
4748        '(#:phases
4749          (modify-phases %standard-phases
4750            (add-after
4751                'unpack 'fix-paths
4752              (lambda* (#:key inputs #:allow-other-keys)
4753                (let ((anchor "#p\"/etc/mime.types\""))
4754                  (substitute* "mime-types.lisp"
4755                    ((anchor all)
4756                     (string-append
4757                      anchor "\n"
4758                      "(asdf:system-relative-pathname :trivial-mimes "
4759                      "\"../../share/common-lisp/" (%lisp-type)
4760                      "-source/trivial-mimes/mime.types\")")))))))))
4761       (native-inputs
4762        `(("stefil" ,sbcl-hu.dwim.stefil)))
4763       (inputs
4764        `(("sbcl-cl-fad" ,sbcl-cl-fad)))
4765       (home-page "https://shinmera.github.io/trivial-mimes/")
4766       (synopsis "Tiny Common Lisp library to detect mime types in files")
4767       (description
4768        "This is a teensy library that provides some functions to determine the
4769 mime-type of a file.")
4770       (license license:artistic2.0))))
4771
4772 (define-public cl-trivial-mimes
4773   (sbcl-package->cl-source-package sbcl-trivial-mimes))
4774
4775 (define-public ecl-trivial-mimes
4776   (sbcl-package->ecl-package sbcl-trivial-mimes))
4777
4778 (define-public sbcl-lack-middleware-static
4779   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4780         (revision "1"))
4781     (package
4782      (name "sbcl-lack-middleware-static")
4783      (version (git-version "0.1.0" revision commit))
4784      (source
4785       (origin
4786        (method git-fetch)
4787        (uri (git-reference
4788              (url "https://github.com/fukamachi/lack.git")
4789              (commit commit)))
4790        (file-name (git-file-name "lack-middleware-static" version))
4791        (sha256
4792         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4793      (build-system asdf-build-system/sbcl)
4794      (arguments
4795       '(#:asd-file "lack-middleware-static.asd"
4796         #:asd-system-name "lack-middleware-static"
4797         #:test-asd-file "t-lack-middleware-static.asd"
4798         ;; XXX: Component :LACK not found
4799         #:tests? #f))
4800      (native-inputs
4801       `(("prove-asdf" ,sbcl-prove-asdf)))
4802      (inputs
4803       `(("sbcl-ironclad" ,sbcl-ironclad)
4804         ("sbcl-trivial-mimes" ,sbcl-trivial-mimes)
4805         ("sbcl-local-time" ,sbcl-local-time)))
4806      (home-page "https://github.com/fukamachi/lack")
4807      (synopsis "Lack, the core of Clack")
4808      (description
4809       "Lack is a Common Lisp library which allows web applications to be
4810 constructed of modular components.  It was originally a part of Clack, however
4811 it's going to be rewritten as an individual project since Clack v2 with
4812 performance and simplicity in mind.")
4813      (license license:llgpl))))
4814
4815 (define-public cl-lack-middleware-static
4816   (sbcl-package->cl-source-package sbcl-lack-middleware-static))
4817
4818 (define-public sbcl-lack
4819   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4820         (revision "1"))
4821     (package
4822      (name "sbcl-lack")
4823      (version (git-version "0.1.0" revision commit))
4824      (source
4825       (origin
4826        (method git-fetch)
4827        (uri (git-reference
4828              (url "https://github.com/fukamachi/lack.git")
4829              (commit commit)))
4830        (file-name (git-file-name "lack" version))
4831        (sha256
4832         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4833      (build-system asdf-build-system/sbcl)
4834      (arguments
4835       '(#:test-asd-file "t-lack.asd"
4836         ;; XXX: Component :CLACK not found
4837         #:tests? #f))
4838      (native-inputs
4839       `(("prove-asdf" ,sbcl-prove-asdf)))
4840      (inputs
4841       `(("sbcl-lack-component" ,sbcl-lack-component)
4842         ("sbcl-lack-util" ,sbcl-lack-util)))
4843      (home-page "https://github.com/fukamachi/lack")
4844      (synopsis "Lack, the core of Clack")
4845      (description
4846       "Lack is a Common Lisp library which allows web applications to be
4847 constructed of modular components.  It was originally a part of Clack, however
4848 it's going to be rewritten as an individual project since Clack v2 with
4849 performance and simplicity in mind.")
4850      (license license:llgpl))))
4851
4852 (define-public cl-lack
4853   (sbcl-package->cl-source-package sbcl-lack))
4854
4855 (define-public sbcl-ningle
4856   (let ((commit "50bd4f09b5a03a7249bd4d78265d6451563b25ad")
4857         (revision "1"))
4858     (package
4859       (name "sbcl-ningle")
4860       (version (git-version "0.3.0" revision commit))
4861       (source
4862        (origin
4863          (method git-fetch)
4864          (uri (git-reference
4865                (url "https://github.com/fukamachi/ningle.git")
4866                (commit commit)))
4867          (file-name (git-file-name name version))
4868          (sha256
4869           (base32 "1bsl8cnxhacb8p92z9n89vhk1ikmij5zavk0m2zvmj7iqm79jzgw"))))
4870       (build-system asdf-build-system/sbcl)
4871       (arguments
4872        ;; TODO: pull in clack-test
4873        '(#:tests? #f
4874          #:phases
4875          (modify-phases %standard-phases
4876            (delete 'cleanup-files)
4877            (delete 'cleanup)
4878            (add-before 'cleanup 'combine-fasls
4879              (lambda* (#:key outputs #:allow-other-keys)
4880                (let* ((out (assoc-ref outputs "out"))
4881                       (lib (string-append out "/lib/sbcl"))
4882                       (ningle-path (string-append lib "/ningle"))
4883                       (fasl-files (find-files out "\\.fasl$")))
4884                  (mkdir-p ningle-path)
4885                  (let ((fasl-path (lambda (name)
4886                                     (string-append ningle-path
4887                                                    "/"
4888                                                    (basename name)
4889                                                    "--system.fasl"))))
4890                    (for-each (lambda (file)
4891                                (rename-file file
4892                                             (fasl-path
4893                                              (basename file ".fasl"))))
4894                              fasl-files))
4895                  fasl-files)
4896                #t)))))
4897       (native-inputs
4898        `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4899          ("sbcl-prove" ,sbcl-prove)))
4900       (inputs
4901        `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
4902          ("sbcl-cl-syntax-annot" ,sbcl-cl-syntax-annot)
4903          ("sbcl-myway" ,sbcl-myway)
4904          ("sbcl-lack-request" ,sbcl-lack-request)
4905          ("sbcl-lack-response" ,sbcl-lack-response)
4906          ("sbcl-lack-component" ,sbcl-lack-component)
4907          ("sbcl-alexandria" ,sbcl-alexandria)
4908          ("sbcl-babel" ,sbcl-babel)))
4909       (home-page "https://8arrow.org/ningle/")
4910       (synopsis "Super micro framework for Common Lisp")
4911       (description
4912        "Ningle is a lightweight web application framework for Common Lisp.")
4913       (license license:llgpl))))
4914
4915 (define-public cl-ningle
4916   (sbcl-package->cl-source-package sbcl-ningle))
4917
4918 (define-public sbcl-clack
4919   (let ((commit "e3e032843bb1220ab96263c411aa7f2feb4746e0")
4920         (revision "1"))
4921     (package
4922      (name "sbcl-clack")
4923      (version (git-version "2.0.0" revision commit))
4924      (source
4925       (origin
4926        (method git-fetch)
4927        (uri (git-reference
4928              (url "https://github.com/fukamachi/clack.git")
4929              (commit commit)))
4930        (file-name (git-file-name name version))
4931        (sha256
4932         (base32 "1ymzs6qyrwhlj6cgqsnpyn6g5cbp7a3s1vgxwna20y2q7y4iacy0"))))
4933      (build-system asdf-build-system/sbcl)
4934      (inputs
4935       `(("sbcl-lack" ,sbcl-lack)
4936         ("sbcl-lack-middleware-backtrace" ,sbcl-lack-middleware-backtrace)
4937         ("sbcl-bordeaux-threads" ,sbcl-bordeaux-threads)))
4938      (home-page "https://github.com/fukamachi/clack")
4939      (synopsis "Web Application Environment for Common Lisp")
4940      (description
4941       "Clack is a web application environment for Common Lisp inspired by
4942 Python's WSGI and Ruby's Rack.")
4943      (license license:llgpl))))
4944
4945 (define-public cl-clack
4946   (sbcl-package->cl-source-package sbcl-clack))
4947
4948 (define-public sbcl-log4cl
4949   (let ((commit "611e094458504b938d49de904eab141285328c7c")
4950         (revision "1"))
4951     (package
4952       (name "sbcl-log4cl")
4953       (build-system asdf-build-system/sbcl)
4954       (version "1.1.2")
4955       (source
4956        (origin
4957          (method git-fetch)
4958          (uri (git-reference
4959                (url "https://github.com/sharplispers/log4cl")
4960                (commit commit)))
4961          (file-name (git-file-name name version))
4962          (sha256
4963           (base32
4964            "08jly0s0g26b56hhpfizxsb4j0yvbh946sd205gr42dkzv8l7dsc"))))
4965       ;; FIXME: tests require stefil, sbcl-hu.dwim.stefil wont work
4966       (arguments
4967        `(#:tests? #f))
4968       (inputs `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
4969       (synopsis "Common Lisp logging framework, modeled after Log4J")
4970       (home-page "https://github.com/7max/log4cl")
4971       (description "This is a Common Lisp logging framework that can log at
4972 various levels and mix text with expressions.")
4973       (license license:asl2.0))))
4974
4975 (define-public cl-log4cl
4976   (sbcl-package->cl-source-package sbcl-log4cl))
4977
4978 (define-public ecl-log4cl
4979   (sbcl-package->ecl-package sbcl-log4cl))
4980
4981 (define-public sbcl-find-port
4982   (let ((commit "00c96a25af93a0f8681d34ec548861f2d7485478")
4983         (revision "1"))
4984     (package
4985       (name "sbcl-find-port")
4986       (build-system asdf-build-system/sbcl)
4987       (version "0.1")
4988       (home-page "https://github.com/eudoxia0/find-port")
4989       (source
4990        (origin
4991          (method git-fetch)
4992          (uri (git-reference
4993                (url home-page)
4994                (commit commit)))
4995          (file-name (git-file-name name version))
4996          (sha256
4997           (base32
4998            "0d6dzbb45jh0rx90wgs6v020k2xa87mvzas3mvfzvivjvqqlpryq"))))
4999       (native-inputs
5000        `(("fiveam" ,sbcl-fiveam)))
5001       (inputs
5002        `(("sbcl-usocket" ,sbcl-usocket)))
5003       (synopsis "Find open ports programmatically in Common Lisp")
5004       (description "This is a small Common Lisp library that finds an open
5005 port within a range.")
5006       (license license:expat))))
5007
5008 (define-public cl-find-port
5009   (sbcl-package->cl-source-package sbcl-find-port))
5010
5011 (define-public ecl-find-port
5012   (sbcl-package->ecl-package sbcl-find-port))
5013
5014 (define-public sbcl-clunit
5015   (let ((commit "6f6d72873f0e1207f037470105969384f8380628")
5016         (revision "1"))
5017     (package
5018       (name "sbcl-clunit")
5019       (version (git-version "0.2.3" revision commit))
5020       (source
5021        (origin
5022          (method git-fetch)
5023          (uri (git-reference
5024                (url "https://github.com/tgutu/clunit.git")
5025                (commit commit)))
5026          (file-name (git-file-name name version))
5027          (sha256
5028           (base32
5029            "1idf2xnqzlhi8rbrqmzpmb3i1l6pbdzhhajkmhwbp6qjkmxa4h85"))))
5030       (build-system asdf-build-system/sbcl)
5031       (synopsis "CLUnit is a Common Lisp unit testing framework")
5032       (description
5033        "CLUnit is a Common Lisp unit testing framework.  It is designed
5034 to be easy to use so that you can quickly start testing.  CLUnit
5035 provides a rich set of features aimed at improving your unit testing
5036 experience.")
5037       (home-page "https://tgutu.github.io/clunit/")
5038       ;; MIT License
5039       (license license:expat))))
5040
5041 (define-public cl-clunit
5042   (sbcl-package->cl-source-package sbcl-clunit))
5043
5044 (define-public ecl-clunit
5045   (sbcl-package->ecl-package sbcl-clunit))
5046
5047 (define-public sbcl-py4cl
5048   (let ((commit "4c8a2b0814fd311f978964f825ce012290f60136")
5049         (revision "1"))
5050     (package
5051       (name "sbcl-py4cl")
5052       (version (git-version "0.0.0" revision commit))
5053       (source
5054        (origin
5055          (method git-fetch)
5056          (uri (git-reference
5057                (url "https://github.com/bendudson/py4cl.git")
5058                (commit commit)))
5059          (file-name (git-file-name name version))
5060          (sha256
5061           (base32
5062            "15mk7qdqjkj56gdnbyrdyz6r7m1h26ldvn6ch96pmvg5vmr1m45r"))
5063          (modules '((guix build utils)))))
5064       (build-system asdf-build-system/sbcl)
5065       (native-inputs
5066        `(("sbcl-clunit" ,sbcl-clunit)))
5067       (inputs
5068        `(("sbcl-trivial-garbage" ,sbcl-trivial-garbage)))
5069       (propagated-inputs
5070        ;; This package doesn't do anything without python available
5071        `(("python" ,python)
5072          ;; For multi-dimensional array support
5073          ("python-numpy" ,python-numpy)))
5074       (arguments
5075        '(#:phases
5076          (modify-phases %standard-phases
5077            (add-after 'unpack 'replace-*base-directory*-var
5078              (lambda* (#:key outputs #:allow-other-keys)
5079                ;; In the ASD, the author makes an attempt to
5080                ;; programatically determine the location of the
5081                ;; source-code so lisp can call into "py4cl.py". We can
5082                ;; hard-code this since we know where this file will
5083                ;; reside.
5084                (substitute* "src/callpython.lisp"
5085                  (("py4cl/config:\\*base-directory\\*")
5086                   (string-append
5087                    "\""
5088                    (assoc-ref outputs "out")
5089                    "/share/common-lisp/sbcl-source/py4cl/"
5090                    "\""))))))))
5091       (synopsis "Call python from Common Lisp")
5092       (description
5093        "Py4CL is a bridge between Common Lisp and Python, which enables Common
5094 Lisp to interact with Python code.  It uses streams to communicate with a
5095 separate python process, the approach taken by cl4py.  This is different to
5096 the CFFI approach used by burgled-batteries, but has the same goal.")
5097       (home-page "https://github.com/bendudson/py4cl")
5098       ;; MIT License
5099       (license license:expat))))
5100
5101 (define-public cl-py4cl
5102   (sbcl-package->cl-source-package sbcl-py4cl))
5103
5104 (define-public ecl-py4cl
5105   (sbcl-package->ecl-package sbcl-py4cl))
5106
5107 (define-public sbcl-parse-declarations
5108   (let ((commit "549aebbfb9403a7fe948654126b9c814f443f4f2")
5109         (revision "1"))
5110     (package
5111       (name "sbcl-parse-declarations")
5112       (version (git-version "1.0.0" revision commit))
5113       (source
5114        (origin
5115          (method git-fetch)
5116          (uri (git-reference
5117                (url (string-append
5118                      "https://gitlab.common-lisp.net/parse-declarations/"
5119                      "parse-declarations.git"))
5120                (commit commit)))
5121          (file-name (git-file-name name version))
5122          (sha256
5123           (base32 "03g5qks4c59nmxa48pbslxkfh77h8hn8566jddp6m9pl15dzzpxd"))))
5124       (build-system asdf-build-system/sbcl)
5125       (arguments
5126        `(#:asd-file "parse-declarations-1.0.asd"
5127          #:asd-system-name "parse-declarations-1.0"))
5128       (home-page "https://common-lisp.net/project/parse-declarations/")
5129       (synopsis "Parse, filter, and build declarations")
5130       (description
5131        "Parse-Declarations is a Common Lisp library to help writing
5132 macros which establish bindings.  To be semantically correct, such
5133 macros must take user declarations into account, as these may affect
5134 the bindings they establish.  Yet the ANSI standard of Common Lisp does
5135 not provide any operators to work with declarations in a convenient,
5136 high-level way.  This library provides such operators.")
5137       ;; MIT License
5138       (license license:expat))))
5139
5140 (define-public cl-parse-declarations
5141   (sbcl-package->cl-source-package sbcl-parse-declarations))
5142
5143 (define-public ecl-parse-declarations
5144   (sbcl-package->ecl-package sbcl-parse-declarations))
5145
5146 (define-public sbcl-cl-quickcheck
5147   (let ((commit "807b2792a30c883a2fbecea8e7db355b50ba662f")
5148         (revision "1"))
5149     (package
5150       (name "sbcl-cl-quickcheck")
5151       (version (git-version "0.0.4" revision commit))
5152       (source
5153        (origin
5154          (method git-fetch)
5155          (uri (git-reference
5156                (url "https://github.com/mcandre/cl-quickcheck.git")
5157                (commit commit)))
5158          (file-name (git-file-name name version))
5159          (sha256
5160           (base32
5161            "165lhypq5xkcys6hvzb3jq7ywnmqvzaflda29qk2cbs3ggas4767"))))
5162       (build-system asdf-build-system/sbcl)
5163       (synopsis
5164        "Common Lisp port of the QuickCheck unit test framework")
5165       (description
5166        "Common Lisp port of the QuickCheck unit test framework")
5167       (home-page "https://github.com/mcandre/cl-quickcheck")
5168       ;; MIT
5169       (license license:expat))))
5170
5171 (define-public cl-cl-quickcheck
5172   (sbcl-package->cl-source-package sbcl-cl-quickcheck))
5173
5174 (define-public ecl-cl-quickcheck
5175   (sbcl-package->ecl-package sbcl-cl-quickcheck))
5176
5177 (define-public sbcl-burgled-batteries3
5178   (let ((commit "f65f454d13bb6c40e17e9ec62e41eb5069e09760")
5179         (revision "2"))
5180     (package
5181       (name "sbcl-burgled-batteries3")
5182       (version (git-version "0.0.0" revision commit))
5183       (source
5184        (origin
5185          (method git-fetch)
5186          (uri (git-reference
5187                (url "https://github.com/snmsts/burgled-batteries3.git")
5188                (commit commit)))
5189          (file-name (git-file-name name version))
5190          (sha256
5191           (base32
5192            "1nzn7jawrfajyzwfnzrg2cmn9xxadcqh4szbpg0jggkhdkdzz4wa"))))
5193       (build-system asdf-build-system/sbcl)
5194       (arguments
5195        `(#:tests? #f
5196          #:modules (((guix build python-build-system) #:select (python-version))
5197                     ,@%asdf-build-system-modules)
5198          #:imported-modules ((guix build python-build-system)
5199                              ,@%asdf-build-system-modules)
5200          #:phases
5201          (modify-phases (@ (guix build asdf-build-system) %standard-phases)
5202            (add-after 'unpack 'set-*cpython-include-dir*-var
5203              (lambda* (#:key inputs #:allow-other-keys)
5204                (let ((python (assoc-ref inputs "python")))
5205                  (setenv "BB_PYTHON3_INCLUDE_DIR"
5206                          (string-append python "/include/python"
5207                                         (python-version python)
5208                                         "m"))
5209                  (setenv "BB_PYTHON3_DYLIB"
5210                          (string-append python "/lib/libpython3.so"))
5211                  #t))))))
5212       (native-inputs
5213        `(("sbcl-cl-fad" ,sbcl-cl-fad)
5214          ("sbcl-lift" ,sbcl-lift)
5215          ("sbcl-cl-quickcheck" ,sbcl-cl-quickcheck)))
5216       (inputs
5217        `(("python" ,python)
5218          ("sbcl-cffi" ,sbcl-cffi)
5219          ("sbcl-cffi-grovel" ,sbcl-cffi-grovel)
5220          ("sbcl-alexandria" , sbcl-alexandria)
5221          ("sbcl-parse-declarations-1.0" ,sbcl-parse-declarations)
5222          ("sbcl-trivial-garbage" ,sbcl-trivial-garbage)))
5223       (synopsis "Bridge between Python and Lisp (FFI bindings, etc.)")
5224       (description
5225        "This package provides a shim between Python3 (specifically, the
5226 CPython implementation of Python) and Common Lisp.")
5227       (home-page "https://github.com/snmsts/burgled-batteries3")
5228       (license license:expat))))
5229
5230 (define-public cl-burgled-batteries3
5231   (sbcl-package->cl-source-package sbcl-burgled-batteries3))
5232
5233 (define-public ecl-burgled-batteries3
5234   (sbcl-package->ecl-package sbcl-burgled-batteries3))
5235
5236 (define-public sbcl-metabang-bind
5237   (let ((commit "c93b7f7e1c18c954c2283efd6a7fdab36746ab5e")
5238         (revision "1"))
5239     (package
5240       (name "sbcl-metabang-bind")
5241       (version (git-version "0.8.0" revision commit))
5242       (source
5243        (origin
5244          (method git-fetch)
5245          (uri (git-reference
5246                (url "https://github.com/gwkkwg/metabang-bind.git")
5247                (commit commit)))
5248          (file-name (git-file-name name version))
5249          (sha256
5250           (base32
5251            "0hd0kr91795v77akpbcyqiss9p0p7ypa9dznrllincnmgvsxlmf0"))))
5252       (build-system asdf-build-system/sbcl)
5253       (native-inputs
5254        `(("sbcl-lift" ,sbcl-lift)))
5255       (synopsis "Macro that generalizes @code{multiple-value-bind} etc.")
5256       (description
5257        "Bind extends the idea of of let and destructing to provide a uniform
5258 syntax for all your accessor needs.  It combines @code{let},
5259 @code{destructuring-bind}, @code{with-slots}, @code{with-accessors}, structure
5260 editing, property or association-lists, and @code{multiple-value-bind} and a
5261 whole lot more into a single form.")
5262       (home-page "https://common-lisp.net/project/metabang-bind/")
5263       ;; MIT License
5264       (license license:expat))))
5265
5266 (define-public cl-metabang-bind
5267   (sbcl-package->cl-source-package sbcl-metabang-bind))
5268
5269 (define-public ecl-metabang-bind
5270   (sbcl-package->ecl-package sbcl-metabang-bind))
5271
5272 (define-public sbcl-fare-utils
5273   (let ((commit "66e9c6f1499140bc00ccc22febf2aa528cbb5724")
5274         (revision "1"))
5275     (package
5276       (name "sbcl-fare-utils")
5277       (version (git-version "1.0.0.5" revision commit))
5278       (source
5279        (origin
5280          (method git-fetch)
5281          (uri
5282           (git-reference
5283            (url
5284             "https://gitlab.common-lisp.net/frideau/fare-utils.git")
5285            (commit commit)))
5286          (file-name (git-file-name name version))
5287          (sha256
5288           (base32
5289            "01wsr1aap3jdzhn4hrqjbhsjx6qci9dbd3gh4gayv1p49rbg8aqr"))))
5290       (build-system asdf-build-system/sbcl)
5291       (arguments
5292        `(#:test-asd-file "test/fare-utils-test.asd"))
5293       (native-inputs
5294        `(("sbcl-hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
5295       (synopsis "Collection of utilities and data structures")
5296       (description
5297        "fare-utils is a small collection of utilities.  It contains a lot of
5298 basic everyday functions and macros.")
5299       (home-page "https://gitlab.common-lisp.net/frideau/fare-utils")
5300       ;; MIT License
5301       (license license:expat))))
5302
5303 (define-public cl-fare-utils
5304   (sbcl-package->cl-source-package sbcl-fare-utils))
5305
5306 (define-public ecl-fare-utils
5307   (sbcl-package->ecl-package sbcl-fare-utils))
5308
5309 (define-public sbcl-trivial-utf-8
5310   (let ((commit "4d427cfbb1c452436a0efb71c3205c9da67f718f")
5311         (revision "1"))
5312     (package
5313       (name "sbcl-trivial-utf-8")
5314       (version (git-version "0.0.0" revision commit))
5315       (source
5316        (origin
5317          (method git-fetch)
5318          (uri
5319           (git-reference
5320            (url (string-append "https://gitlab.common-lisp.net/"
5321                                "trivial-utf-8/trivial-utf-8.git"))
5322            (commit commit)))
5323          (file-name (git-file-name name version))
5324          (sha256
5325           (base32
5326            "1jz27gz8gvqdmvp3k9bxschs6d5b3qgk94qp2bj6nv1d0jc3m1l1"))))
5327       (arguments
5328        ;; Guix incorrectly assumes the "8" is part of the version
5329        ;; number and lobs it off.
5330        `(#:asd-file "trivial-utf-8.asd"
5331          #:asd-system-name "trivial-utf-8"))
5332       (build-system asdf-build-system/sbcl)
5333       (synopsis "UTF-8 input/output library")
5334       (description
5335        "The Babel library solves a similar problem while understanding more
5336 encodings.  Trivial UTF-8 was written before Babel existed, but for new
5337 projects you might be better off going with Babel.  The one plus that Trivial
5338 UTF-8 has is that it doesn't depend on any other libraries.")
5339       (home-page "https://common-lisp.net/project/trivial-utf-8/")
5340       (license license:bsd-3))))
5341
5342 (define-public cl-trivial-utf-8
5343   (sbcl-package->cl-source-package sbcl-trivial-utf-8))
5344
5345 (define-public ecl-trivial-utf-8
5346   (sbcl-package->ecl-package sbcl-trivial-utf-8))
5347
5348 (define-public sbcl-idna
5349   (package
5350     (name "sbcl-idna")
5351     (build-system asdf-build-system/sbcl)
5352     (version "0.2.2")
5353     (home-page "https://github.com/antifuchs/idna")
5354     (source
5355      (origin
5356        (method git-fetch)
5357        (uri (git-reference
5358              (url home-page)
5359              (commit version)))
5360        (file-name (git-file-name name version))
5361        (sha256
5362         (base32
5363          "00nbr3mffxhlq14gg9d16pa6691s4qh35inyw76v906s77khm5a2"))))
5364     (inputs
5365      `(("split-sequence" ,sbcl-split-sequence)))
5366     (synopsis "IDNA string encoding and decoding routines for Common Lisp")
5367     (description "This Common Lisp library provides string encoding and
5368 decoding routines for IDNA, the International Domain Names in Applications.")
5369     (license license:expat)))
5370
5371 (define-public cl-idna
5372   (sbcl-package->cl-source-package sbcl-idna))
5373
5374 (define-public ecl-idna
5375   (sbcl-package->ecl-package sbcl-idna))
5376
5377 (define-public sbcl-swap-bytes
5378   (package
5379     (name "sbcl-swap-bytes")
5380     (build-system asdf-build-system/sbcl)
5381     (version "1.2")
5382     (home-page "https://github.com/sionescu/swap-bytes")
5383     (source
5384      (origin
5385        (method git-fetch)
5386        (uri (git-reference
5387              (url home-page)
5388              (commit (string-append "v" version))))
5389        (file-name (git-file-name name version))
5390        (sha256
5391         (base32
5392          "1hw1v1lw26rifyznpnj1csphha9jgzwpiic16ni3pvs6hcsni9rz"))))
5393     (inputs
5394      `(("trivial-features" ,sbcl-trivial-features)))
5395     (native-inputs
5396      `(("fiveam" ,sbcl-fiveam)))
5397     (synopsis "Efficient endianness conversion for Common Lisp")
5398     (description "This Common Lisp library provides optimized byte-swapping
5399 primitives.  The library can change endianness of unsigned integers of length
5400 1/2/4/8.  Very useful in implementing various network protocols and file
5401 formats.")
5402     (license license:expat)))
5403
5404 (define-public cl-swap-bytes
5405   (sbcl-package->cl-source-package sbcl-swap-bytes))
5406
5407 (define-public ecl-swap-bytes
5408   (sbcl-package->ecl-package sbcl-swap-bytes))
5409
5410 (define-public sbcl-iolib.asdf
5411   ;; Latest release is from June 2017.
5412   (let ((commit "7f5ea3a8457a29d224b24653c2b3657fb1898021")
5413         (revision "2"))
5414     (package
5415       (name "sbcl-iolib.asdf")
5416       (build-system asdf-build-system/sbcl)
5417       (version (git-version "0.8.3" revision commit))
5418       (home-page "https://github.com/sionescu/iolib")
5419       (source
5420        (origin
5421          (method git-fetch)
5422          (uri (git-reference
5423                (url home-page)
5424                (commit commit)))
5425          (file-name (git-file-name name version))
5426          (sha256
5427           (base32
5428            "1bg5w7lm61hqk4b0svmri8a590q36z76jfa0sdgzb39r98c04w12"))))
5429       (inputs
5430        `(("alexandria" ,sbcl-alexandria)))
5431       (arguments
5432        '(#:asd-file "iolib.asdf.asd"))
5433       (synopsis "ASDF component classes for IOLib, a Common Lisp I/O library")
5434       (description "IOlib is to be a better and more modern I/O library than
5435 the standard Common Lisp library.  It contains a socket library, a DNS
5436 resolver, an I/O multiplexer(which supports @code{select(2)}, @code{epoll(4)}
5437 and @code{kqueue(2)}), a pathname library and file-system utilities.")
5438       (license license:expat))))
5439
5440 (define-public sbcl-iolib.conf
5441   (package
5442     (inherit sbcl-iolib.asdf)
5443     (name "sbcl-iolib.conf")
5444     (inputs
5445      `(("iolib.asdf" ,sbcl-iolib.asdf)))
5446     (arguments
5447      '(#:asd-file "iolib.conf.asd"))
5448     (synopsis "Compile-time configuration for IOLib, a Common Lisp I/O library")))
5449
5450 (define-public sbcl-iolib.common-lisp
5451   (package
5452     (inherit sbcl-iolib.asdf)
5453     (name "sbcl-iolib.common-lisp")
5454     (inputs
5455      `(("iolib.asdf" ,sbcl-iolib.asdf)
5456        ("iolib.conf" ,sbcl-iolib.conf)))
5457     (arguments
5458      '(#:asd-file "iolib.common-lisp.asd"))
5459     (synopsis "Slightly modified Common Lisp for IOLib, a Common Lisp I/O library")))
5460
5461 (define-public sbcl-iolib.base
5462   (package
5463     (inherit sbcl-iolib.asdf)
5464     (name "sbcl-iolib.base")
5465     (inputs
5466      `(("iolib.asdf" ,sbcl-iolib.asdf)
5467        ("iolib.conf" ,sbcl-iolib.conf)
5468        ("iolib.common-lisp" ,sbcl-iolib.common-lisp)
5469        ("split-sequence" ,sbcl-split-sequence)))
5470     (arguments
5471      '(#:asd-file "iolib.base.asd"))
5472     (synopsis "Base package for IOLib, a Common Lisp I/O library")))
5473
5474 (define-public sbcl-iolib.grovel
5475   (package
5476     (inherit sbcl-iolib.asdf)
5477     (name "sbcl-iolib.grovel")
5478     (inputs
5479      `(("iolib.asdf" ,sbcl-iolib.asdf)
5480        ("iolib.conf" ,sbcl-iolib.conf)
5481        ("iolib.base", sbcl-iolib.base)
5482        ("cffi", sbcl-cffi)))
5483     (arguments
5484      '(#:asd-file "iolib.grovel.asd"
5485        #:phases
5486        (modify-phases %standard-phases
5487          (add-after 'install 'install-header
5488            (lambda* (#:key outputs #:allow-other-keys)
5489              ;; This header is required by sbcl-iolib.
5490              (install-file "src/grovel/grovel-common.h"
5491                            (string-append (assoc-ref outputs "out")
5492                                           "/lib/sbcl"))
5493              #t)))))
5494     (synopsis "CFFI Groveller for IOLib, a Common Lisp I/O library")))
5495
5496 (define sbcl-iolib+syscalls
5497   (package
5498     (inherit sbcl-iolib.asdf)
5499     (name "sbcl-iolib+syscalls")
5500     (inputs
5501      `(("iolib.asdf" ,sbcl-iolib.asdf)
5502        ("iolib.conf" ,sbcl-iolib.conf)
5503        ("cffi-grovel" ,sbcl-cffi-grovel)
5504        ("iolib.base" ,sbcl-iolib.base)
5505        ("bordeaux-threads" ,sbcl-bordeaux-threads)
5506        ("idna" ,sbcl-idna)
5507        ("swap-bytes" ,sbcl-swap-bytes)
5508        ("libfixposix" ,libfixposix)
5509        ("cffi" ,sbcl-cffi)))
5510     (native-inputs
5511      `(("fiveam" ,sbcl-fiveam)))
5512     (arguments
5513      '(#:asd-file "iolib.asd"
5514        #:asd-system-name "iolib/syscalls"
5515        #:phases
5516        (modify-phases %standard-phases
5517          (add-after 'unpack 'fix-paths
5518            (lambda* (#:key inputs #:allow-other-keys)
5519              (substitute* "src/syscalls/ffi-functions-unix.lisp"
5520                (("\\(:default \"libfixposix\"\\)")
5521                 (string-append
5522                  "(:default \""
5523                  (assoc-ref inputs "libfixposix") "/lib/libfixposix\")")))
5524              ;; Socket tests need Internet access, disable them.
5525              (substitute* "iolib.asd"
5526                (("\\(:file \"sockets\" :depends-on \\(\"pkgdcl\" \"defsuites\"\\)\\)")
5527                 "")))))))
5528     (synopsis "Common Lisp I/O library")))
5529
5530 (define sbcl-iolib+multiplex
5531   (package
5532     (inherit sbcl-iolib+syscalls)
5533     (name "sbcl-iolib+multiplex")
5534     (inputs
5535      `(("iolib+syscalls" ,sbcl-iolib+syscalls)
5536        ,@(package-inputs sbcl-iolib+syscalls)))
5537     (arguments
5538      (substitute-keyword-arguments (package-arguments sbcl-iolib+syscalls)
5539        ((#:asd-system-name _) "iolib/multiplex")))))
5540
5541 (define sbcl-iolib+streams
5542   (package
5543     (inherit sbcl-iolib+syscalls)
5544     (name "sbcl-iolib+streams")
5545     (inputs
5546      `(("iolib+multiplex" ,sbcl-iolib+multiplex)
5547        ,@(package-inputs sbcl-iolib+syscalls)))
5548     (arguments
5549      (substitute-keyword-arguments (package-arguments sbcl-iolib+syscalls)
5550        ((#:asd-system-name _) "iolib/streams")))))
5551
5552 (define sbcl-iolib+sockets
5553   (package
5554     (inherit sbcl-iolib+syscalls)
5555     (name "sbcl-iolib+sockets")
5556     (inputs
5557      `(("iolib+syscalls" ,sbcl-iolib+syscalls)
5558        ("iolib+streams" ,sbcl-iolib+streams)
5559        ,@(package-inputs sbcl-iolib+syscalls)))
5560     (arguments
5561      (substitute-keyword-arguments (package-arguments sbcl-iolib+syscalls)
5562        ((#:asd-system-name _) "iolib/sockets")))))
5563
5564 (define-public sbcl-iolib
5565   (package
5566     (inherit sbcl-iolib+syscalls)
5567     (name "sbcl-iolib")
5568     (inputs
5569      `(("iolib+multiplex" ,sbcl-iolib+multiplex)
5570        ("iolib+streams" ,sbcl-iolib+streams)
5571        ("iolib+sockets" ,sbcl-iolib+sockets)
5572        ,@(package-inputs sbcl-iolib+syscalls)))
5573     (arguments
5574      (substitute-keyword-arguments (package-arguments sbcl-iolib+syscalls)
5575        ((#:asd-system-name _) "iolib")))))
5576
5577 (define-public cl-iolib
5578   (sbcl-package->cl-source-package sbcl-iolib))
5579
5580 (define-public sbcl-ieee-floats
5581   (let ((commit "566b51a005e81ff618554b9b2f0b795d3b29398d")
5582         (revision "1"))
5583     (package
5584       (name "sbcl-ieee-floats")
5585       (build-system asdf-build-system/sbcl)
5586       (version (git-version "20170924" revision commit))
5587       (home-page "https://github.com/marijnh/ieee-floats/")
5588       (source
5589        (origin
5590          (method git-fetch)
5591          (uri (git-reference
5592                (url home-page)
5593                (commit commit)))
5594          (file-name (git-file-name name version))
5595          (sha256
5596           (base32
5597            "1xyj49j9x3lc84cv3dhbf9ja34ywjk1c46dklx425fxw9mkwm83m"))))
5598       (native-inputs
5599        `(("fiveam" ,sbcl-fiveam)))
5600       (synopsis "IEEE 754 binary representation for floats in Common Lisp")
5601       (description "This is a Common Lisp library that converts
5602 floating point values to IEEE 754 binary representation.")
5603       (license license:bsd-3))))
5604
5605 (define-public cl-ieee-floats
5606   (sbcl-package->cl-source-package sbcl-ieee-floats))
5607
5608 (define sbcl-closure-common
5609   (let ((commit "e3c5f5f454b72b01b89115e581c3c52a7e201e5c")
5610         (revision "1"))
5611     (package
5612       (name "sbcl-closure-common")
5613       (build-system asdf-build-system/sbcl)
5614       (version (git-version "20101006" revision commit))
5615       (home-page "https://common-lisp.net/project/cxml/")
5616       (source
5617        (origin
5618          (method git-fetch)
5619          (uri (git-reference
5620                (url "https://github.com/sharplispers/closure-common")
5621                (commit commit)))
5622          (file-name (git-file-name name version))
5623          (sha256
5624           (base32
5625            "0k5r2qxn122pxi301ijir3nayi9sg4d7yiy276l36qmzwhp4mg5n"))))
5626       (inputs
5627        `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)
5628          ("babel" ,sbcl-babel)))
5629       (synopsis "Support Common Lisp library for CXML")
5630       (description "Closure-common is an internal helper library.  The name
5631 Closure is a reference to the web browser it was originally written for.")
5632       ;; TODO: License?
5633       (license #f))))
5634
5635 (define-public sbcl-cxml+xml
5636   (let ((commit "00b22bf4c4cf11c993d5866fae284f95ab18e6bf")
5637         (revision "1"))
5638     (package
5639       (name "sbcl-cxml+xml")
5640       (build-system asdf-build-system/sbcl)
5641       (version (git-version "0.0.0" revision commit))
5642       (home-page "https://common-lisp.net/project/cxml/")
5643       (source
5644        (origin
5645          (method git-fetch)
5646          (uri (git-reference
5647                (url "https://github.com/sharplispers/cxml")
5648                (commit commit)))
5649          (file-name (git-file-name name version))
5650          (sha256
5651           (base32
5652            "13kif7rf3gqdycsk9zq0d7y0g9y81krkl0z87k0p2fkbjfgrph37"))))
5653       (inputs
5654        `(("closure-common" ,sbcl-closure-common)
5655          ("puri" ,sbcl-puri)
5656          ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
5657       (arguments
5658        `(#:asd-file "cxml.asd"
5659          #:asd-system-name "cxml/xml"))
5660       (synopsis "Common Lisp XML parser")
5661       (description "CXML implements a namespace-aware, validating XML 1.0
5662 parser as well as the DOM Level 2 Core interfaces.  Two parser interfaces are
5663 offered, one SAX-like, the other similar to StAX.")
5664       (license license:llgpl))))
5665
5666 (define sbcl-cxml+dom
5667   (package
5668     (inherit sbcl-cxml+xml)
5669     (name "sbcl-cxml+dom")
5670     (inputs
5671      `(("closure-common" ,sbcl-closure-common)
5672        ("puri" ,sbcl-puri)
5673        ("cxml+xml" ,sbcl-cxml+xml)))
5674     (arguments
5675      `(#:asd-file "cxml.asd"
5676        #:asd-system-name "cxml/dom"))))
5677
5678 (define sbcl-cxml+klacks
5679   (package
5680     (inherit sbcl-cxml+xml)
5681     (name "sbcl-cxml+klacks")
5682     (inputs
5683      `(("closure-common" ,sbcl-closure-common)
5684        ("puri" ,sbcl-puri)
5685        ("cxml+xml" ,sbcl-cxml+xml)))
5686     (arguments
5687      `(#:asd-file "cxml.asd"
5688        #:asd-system-name "cxml/klacks"))))
5689
5690 (define sbcl-cxml+test
5691   (package
5692     (inherit sbcl-cxml+xml)
5693     (name "sbcl-cxml+test")
5694     (inputs
5695      `(("closure-common" ,sbcl-closure-common)
5696        ("puri" ,sbcl-puri)
5697        ("cxml+xml" ,sbcl-cxml+xml)))
5698     (arguments
5699      `(#:asd-file "cxml.asd"
5700        #:asd-system-name "cxml/test"))))
5701
5702 (define-public sbcl-cxml
5703   (package
5704     (inherit sbcl-cxml+xml)
5705     (name "sbcl-cxml")
5706     (inputs
5707      `(("closure-common" ,sbcl-closure-common)
5708        ("puri" ,sbcl-puri)
5709        ("trivial-gray-streams" ,sbcl-trivial-gray-streams)
5710        ("cxml+dom" ,sbcl-cxml+dom)
5711        ("cxml+klacks" ,sbcl-cxml+klacks)
5712        ("cxml+test" ,sbcl-cxml+test)))
5713     (arguments
5714      `(#:asd-file "cxml.asd"
5715        #:asd-system-name "cxml"
5716        #:phases
5717        (modify-phases %standard-phases
5718          (add-after 'build 'install-dtd
5719            (lambda* (#:key outputs #:allow-other-keys)
5720              (install-file "catalog.dtd"
5721                            (string-append
5722                             (assoc-ref outputs "out")
5723                             "/lib/" (%lisp-type)))))
5724          (add-after 'create-asd 'remove-component
5725            ;; XXX: The original .asd has no components, but our build system
5726            ;; creates an entry nonetheless.  We need to remove it for the
5727            ;; generated .asd to load properly.  See trivia.trivial for a
5728            ;; similar problem.
5729            (lambda* (#:key outputs #:allow-other-keys)
5730              (let* ((out (assoc-ref outputs "out"))
5731                     (asd (string-append out "/lib/sbcl/cxml.asd")))
5732                (substitute* asd
5733                  (("  :components
5734 ")
5735                   ""))
5736                (substitute* asd
5737                  ((" *\\(\\(:compiled-file \"cxml--system\"\\)\\)")
5738                   ""))))))))))
5739
5740 (define-public cl-cxml
5741   (sbcl-package->cl-source-package sbcl-cxml))
5742
5743 (define-public sbcl-cl-reexport
5744   (let ((commit "312f3661bbe187b5f28536cd7ec2956e91366c3b")
5745         (revision "1"))
5746     (package
5747       (name "sbcl-cl-reexport")
5748       (build-system asdf-build-system/sbcl)
5749       (version (git-version "0.1" revision commit))
5750       (home-page "https://github.com/takagi/cl-reexport")
5751       (source
5752        (origin
5753          (method git-fetch)
5754          (uri (git-reference
5755                (url home-page)
5756                (commit commit)))
5757          (file-name (git-file-name name version))
5758          (sha256
5759           (base32
5760            "1cwpn1m3wrl0fl9plznn7p464db646gnfc8zkyk97dyxski2aq0x"))))
5761       (inputs
5762        `(("alexandria" ,sbcl-alexandria)))
5763       (arguments
5764        ;; TODO: Tests fail because cl-test-more is missing, but I can't find it online.
5765        `(#:tests? #f))
5766       (synopsis "HTTP cookie manager for Common Lisp")
5767       (description "cl-cookie is a Common Lisp library featuring parsing of
5768 cookie headers, cookie creation, cookie jar creation and more.")
5769       (license license:llgpl))))
5770
5771 (define-public cl-reexport
5772   (sbcl-package->cl-source-package sbcl-cl-reexport))
5773
5774 (define-public sbcl-cl-cookie
5775   (let ((commit "cea55aed8b9ad25fafd13defbcb9fe8f41b29546")
5776         (revision "1"))
5777     (package
5778       (name "sbcl-cl-cookie")
5779       (build-system asdf-build-system/sbcl)
5780       (version (git-version "0.9.10" revision commit))
5781       (home-page "https://github.com/fukamachi/cl-cookie")
5782       (source
5783        (origin
5784          (method git-fetch)
5785          (uri (git-reference
5786                (url home-page)
5787                (commit commit)))
5788          (file-name (git-file-name name version))
5789          (sha256
5790           (base32
5791            "090g7z75h98zvc1ldx0vh4jn4086dhjm2w30jcwkq553qmyxwl8h"))))
5792       (inputs
5793        `(("proc-parse" ,sbcl-proc-parse)
5794          ("alexandria" ,sbcl-alexandria)
5795          ("quri" ,sbcl-quri)
5796          ("cl-ppcre" ,sbcl-cl-ppcre)
5797          ("local-time" ,sbcl-local-time)))
5798       (native-inputs
5799        `(("prove-asdf" ,sbcl-prove-asdf)
5800          ("prove" ,sbcl-prove)))
5801       (arguments
5802        ;; TODO: Tests fail because cl-cookie depends on cl-cookie-test.
5803        `(#:tests? #f))
5804       (synopsis "HTTP cookie manager for Common Lisp")
5805       (description "cl-cookie is a Common Lisp library featuring parsing of
5806 cookie headers, cookie creation, cookie jar creation and more.")
5807       (license license:bsd-2))))
5808
5809 (define-public cl-cookie
5810   (sbcl-package->cl-source-package sbcl-cl-cookie))
5811
5812 (define-public sbcl-dexador
5813   (let ((commit "a2714d126cc94bc7a9a6e1e3c08de455b3a66378")
5814         (revision "1"))
5815     (package
5816       (name "sbcl-dexador")
5817       (build-system asdf-build-system/sbcl)
5818       (version (git-version "0.9.10" revision commit))
5819       (home-page "https://github.com/fukamachi/dexador")
5820       (source
5821        (origin
5822          (method git-fetch)
5823          (uri (git-reference
5824                (url home-page)
5825                (commit commit)))
5826          (file-name (git-file-name name version))
5827          (sha256
5828           (base32
5829            "0nbqgn4v3l2z6m1k1bdxfnqpfrk84nxdmz7csz11zzcfs4flkv79"))))
5830       (inputs
5831        `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)
5832          ("babel" ,sbcl-babel)
5833          ("usocket" ,sbcl-usocket)
5834          ("fast-http" ,sbcl-fast-http)
5835          ("quri" ,sbcl-quri)
5836          ("fast-io" ,sbcl-fast-io)
5837          ("chunga" ,sbcl-chunga)
5838          ("cl-ppcre" ,sbcl-cl-ppcre)
5839          ("cl-cookie" ,sbcl-cl-cookie)
5840          ("trivial-mimes" ,sbcl-trivial-mimes)
5841          ("chipz" ,sbcl-chipz)
5842          ("cl-base64" ,sbcl-cl-base64)
5843          ("cl-reexport" ,sbcl-cl-reexport)
5844          ("cl+ssl" ,sbcl-cl+ssl)
5845          ("bordeaux-threads" ,sbcl-bordeaux-threads)
5846          ("alexandria" ,sbcl-alexandria)))
5847       (native-inputs
5848        `(("prove" ,sbcl-prove)
5849          ("prove-asdf" ,sbcl-prove-asdf)
5850          ("lack-request" ,sbcl-lack-request)
5851          ("clack" ,sbcl-clack)
5852          ("babel" ,sbcl-babel)
5853          ("alexandria" ,sbcl-alexandria)
5854          ("cl-ppcre" ,sbcl-cl-ppcre)
5855          ("local-time" ,sbcl-local-time)))
5856       (arguments
5857        ;; TODO: Circular dependency: tests depend on clack-test which depends on dexador.
5858        `(#:tests? #f
5859          #:phases
5860          (modify-phases %standard-phases
5861            (add-after 'unpack 'fix-permissions
5862              (lambda _ (make-file-writable "t/data/test.gz") #t)))))
5863       (synopsis "Yet another HTTP client for Common Lisp")
5864       (description "Dexador is yet another HTTP client for Common Lisp with
5865 neat APIs and connection-pooling.  It is meant to supersede Drakma.")
5866       (license license:expat))))
5867
5868 (define-public cl-dexador
5869   (package
5870     (inherit (sbcl-package->cl-source-package sbcl-dexador))
5871     (arguments
5872      `(#:phases
5873        ;; asdf-build-system/source has its own phases and does not inherit
5874        ;; from asdf-build-system/sbcl phases.
5875        (modify-phases %standard-phases/source
5876          (add-after 'unpack 'fix-permissions
5877            (lambda _ (make-file-writable "t/data/test.gz") #t)))))))
5878
5879 (define-public ecl-dexador
5880   (sbcl-package->ecl-package sbcl-dexador))
5881
5882 (define-public sbcl-lisp-namespace
5883   (let ((commit "28107cafe34e4c1c67490fde60c7f92dc610b2e0")
5884         (revision "1"))
5885     (package
5886       (name "sbcl-lisp-namespace")
5887       (build-system asdf-build-system/sbcl)
5888       (version (git-version "0.1" revision commit))
5889       (home-page "https://github.com/guicho271828/lisp-namespace")
5890       (source
5891        (origin
5892          (method git-fetch)
5893          (uri (git-reference
5894                (url home-page)
5895                (commit commit)))
5896          (file-name (git-file-name name version))
5897          (sha256
5898           (base32
5899            "1jw2wykp06z2afb9nm1lgfzll5cjlj36pnknjx614057zkkxq4iy"))))
5900       (inputs
5901        `(("alexandria" ,sbcl-alexandria)))
5902       (native-inputs
5903        `(("fiveam" ,sbcl-fiveam)))
5904       (arguments
5905        `(#:test-asd-file "lisp-namespace.test.asd"
5906         ;; XXX: Component LISP-NAMESPACE-ASD::LISP-NAMESPACE.TEST not found
5907          #:tests? #f))
5908       (synopsis "LISP-N, or extensible namespaces in Common Lisp")
5909       (description "Common Lisp already has major 2 namespaces, function
5910 namespace and value namespace (or variable namespace), but there are actually
5911 more — e.g., class namespace.
5912 This library offers macros to deal with symbols from any namespace.")
5913       (license license:llgpl))))
5914
5915 (define-public cl-lisp-namespace
5916   (sbcl-package->cl-source-package sbcl-lisp-namespace))
5917
5918 (define-public sbcl-trivial-cltl2
5919   (let ((commit "8eec8407df833e8f27df8a388bc10913f16d9e83")
5920         (revision "1"))
5921     (package
5922       (name "sbcl-trivial-cltl2")
5923       (build-system asdf-build-system/sbcl)
5924       (version (git-version "0.1.1" revision commit))
5925       (home-page "https://github.com/Zulu-Inuoe/trivial-cltl2")
5926       (source
5927        (origin
5928          (method git-fetch)
5929          (uri (git-reference
5930                (url home-page)
5931                (commit commit)))
5932          (file-name (git-file-name name version))
5933          (sha256
5934           (base32
5935            "1dyyxz17vqv8hlfwq287gl8xxbvcnq798ajb7p5jdjz91wqf4bgk"))))
5936       (synopsis "Simple CLtL2 compatibility layer for Common Lisp")
5937       (description "This library is a portable compatibility layer around
5938 \"Common Lisp the Language, 2nd
5939 Edition\" (@url{https://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node102.html})
5940 and it exports symbols from implementation-specific packages.")
5941       (license license:llgpl))))
5942
5943 (define-public cl-trivial-cltl2
5944   (sbcl-package->cl-source-package sbcl-trivial-cltl2))
5945
5946 (define-public sbcl-introspect-environment
5947   (let ((commit "fff42f8f8fd0d99db5ad6c5812e53de7d660020b")
5948         (revision "1"))
5949     (package
5950       (name "sbcl-introspect-environment")
5951       (build-system asdf-build-system/sbcl)
5952       (version (git-version "0.1" revision commit))
5953       (home-page "https://github.com/Bike/introspect-environment")
5954       (source
5955        (origin
5956          (method git-fetch)
5957          (uri (git-reference
5958                (url home-page)
5959                (commit commit)))
5960          (file-name (git-file-name name version))
5961          (sha256
5962           (base32
5963            "1i305n0wfmpac63ni4i3vixnnkl8daw5ncxy0k3dv92krgx6qzhp"))))
5964       (native-inputs
5965        `(("fiveam" ,sbcl-fiveam)))
5966       (synopsis "Common Lisp environment introspection portability layer")
5967       (description "This library is a small interface to portable but
5968 nonstandard introspection of Common Lisp environments.  It is intended to
5969 allow a bit more compile-time introspection of environments in Common Lisp.
5970
5971 Quite a bit of information is available at the time a macro or compiler-macro
5972 runs; inlining info, type declarations, that sort of thing.  This information
5973 is all standard - any Common Lisp program can @code{(declare (integer x))} and
5974 such.
5975
5976 This info ought to be accessible through the standard @code{&environment}
5977 parameters, but it is not.  Several implementations keep the information for
5978 their own purposes but do not make it available to user programs, because
5979 there is no standard mechanism to do so.
5980
5981 This library uses implementation-specific hooks to make information available
5982 to users.  This is currently supported on SBCL, CCL, and CMUCL.  Other
5983 implementations have implementations of the functions that do as much as they
5984 can and/or provide reasonable defaults.")
5985       (license license:wtfpl2))))
5986
5987 (define-public cl-introspect-environment
5988   (sbcl-package->cl-source-package sbcl-introspect-environment))
5989
5990 (define-public sbcl-type-i
5991   (let ((commit "dea233f45f94064105ec09f0767de338f67dcbe2")
5992         (revision "1"))
5993     (package
5994       (name "sbcl-type-i")
5995       (build-system asdf-build-system/sbcl)
5996       (version (git-version "0.1" revision commit))
5997       (home-page "https://github.com/guicho271828/type-i")
5998       (source
5999        (origin
6000          (method git-fetch)
6001          (uri (git-reference
6002                (url home-page)
6003                (commit commit)))
6004          (file-name (git-file-name name version))
6005          (sha256
6006           (base32
6007            "039g5pbrhh65s0bhr9314gmd2nwc2y5lp2377c5qrc2lxky89qs3"))))
6008       (inputs
6009        `(("alexandria" ,sbcl-alexandria)
6010          ("introspect-environment" ,sbcl-introspect-environment)
6011          ("trivia.trivial" ,sbcl-trivia.trivial)))
6012       (native-inputs
6013        `(("fiveam" ,sbcl-fiveam)))
6014       (arguments
6015        `(#:test-asd-file "type-i.test.asd"))
6016       (synopsis "Type inference utility on unary predicates for Common Lisp")
6017       (description "This library tries to provide a way to detect what kind of
6018 type the given predicate is trying to check.  This is different from inferring
6019 the return type of a function.")
6020       (license license:llgpl))))
6021
6022 (define-public cl-type-i
6023   (sbcl-package->cl-source-package sbcl-type-i))
6024
6025 (define-public sbcl-optima
6026   (let ((commit "373b245b928c1a5cce91a6cb5bfe5dd77eb36195")
6027         (revision "1"))
6028     (package
6029       (name "sbcl-optima")
6030       (build-system asdf-build-system/sbcl)
6031       (version (git-version "1.0" revision commit))
6032       (home-page "https://github.com/m2ym/optima")
6033       (source
6034        (origin
6035          (method git-fetch)
6036          (uri (git-reference
6037                (url home-page)
6038                (commit commit)))
6039          (file-name (git-file-name name version))
6040          (sha256
6041           (base32
6042            "1yw4ymq7ms89342kkvb3aqxgv0w38m9kd8ikdqxxzyybnkjhndal"))))
6043       (inputs
6044        `(("alexandria" ,sbcl-alexandria)
6045          ("closer-mop" ,sbcl-closer-mop)))
6046       (native-inputs
6047        `(("eos" ,sbcl-eos)))
6048       (arguments
6049        ;; XXX: Circular dependencies: tests depend on optima.ppcre which depends on optima.
6050        `(#:tests? #f
6051          #:test-asd-file "optima.test.asd"))
6052       (synopsis "Optimized pattern matching library for Common Lisp")
6053       (description "Optima is a fast pattern matching library which uses
6054 optimizing techniques widely used in the functional programming world.")
6055       (license license:expat))))
6056
6057 (define-public cl-optima
6058   (sbcl-package->cl-source-package sbcl-optima))
6059
6060 (define-public sbcl-fare-quasiquote
6061   (let ((commit "640d39a0451094071b3e093c97667b3947f43639")
6062         (revision "1"))
6063     (package
6064       (name "sbcl-fare-quasiquote")
6065       (build-system asdf-build-system/sbcl)
6066       (version (git-version "1.0.1" revision commit))
6067       (home-page "https://gitlab.common-lisp.net/frideau/fare-quasiquote")
6068       (source
6069        (origin
6070          (method git-fetch)
6071          (uri (git-reference
6072                (url (string-append "https://gitlab.common-lisp.net/frideau/"
6073                                    "fare-quasiquote.git"))
6074                (commit commit)))
6075          (file-name (git-file-name name version))
6076          (sha256
6077           (base32 "1g6q11l50kgija9f55lzqpcwvaq0ljiw8v1j265hnyg6nahjwjvg"))))
6078       (inputs
6079        `(("fare-utils" ,sbcl-fare-utils)))
6080       (arguments
6081        ;; XXX: Circular dependencies: Tests depend on subsystems,
6082        ;; which depend on the main systems.
6083        `(#:tests? #f
6084          #:phases
6085          (modify-phases %standard-phases
6086            ;; XXX: Require 1.0.0 version of fare-utils, and we package some
6087            ;; commits after 1.0.0.5, but ASDF fails to read the
6088            ;; "-REVISION-COMMIT" part generated by Guix.
6089            (add-after 'unpack 'patch-requirement
6090              (lambda _
6091                (substitute* "fare-quasiquote.asd"
6092                  (("\\(:version \"fare-utils\" \"1.0.0\"\\)")
6093                   "\"fare-utils\"")))))))
6094       (synopsis "Pattern-matching friendly implementation of quasiquote")
6095       (description "The main purpose of this n+2nd reimplementation of
6096 quasiquote is enable matching of quasiquoted patterns, using Optima or
6097 Trivia.")
6098       (license license:expat))))
6099
6100 (define-public cl-fare-quasiquote
6101   (sbcl-package->cl-source-package sbcl-fare-quasiquote))
6102
6103 (define-public sbcl-fare-quasiquote-optima
6104   (package
6105     (inherit sbcl-fare-quasiquote)
6106     (name "sbcl-fare-quasiquote-optima")
6107     (inputs
6108      `(("optima" ,sbcl-optima)
6109        ("fare-quasiquote" ,sbcl-fare-quasiquote)))
6110     (arguments
6111      '(#:phases
6112        (modify-phases %standard-phases
6113          (add-after 'unpack 'patch-requirement
6114            (lambda _
6115              (substitute* "fare-quasiquote-optima.asd"
6116                (("\\(:version \"optima\" \"1\\.0\"\\)")
6117                 "\"optima\""))
6118              #t)))))))
6119
6120 (define-public cl-fare-quasiquote-optima
6121   (sbcl-package->cl-source-package sbcl-fare-quasiquote-optima))
6122
6123 (define-public sbcl-fare-quasiquote-readtable
6124   (package
6125     (inherit sbcl-fare-quasiquote)
6126     (name "sbcl-fare-quasiquote-readtable")
6127     (inputs
6128      `(("fare-quasiquote" ,sbcl-fare-quasiquote)
6129        ("named-readtables" ,sbcl-named-readtables)))
6130     (description "The main purpose of this n+2nd reimplementation of
6131 quasiquote is enable matching of quasiquoted patterns, using Optima or
6132 Trivia.
6133
6134 This package uses fare-quasiquote with named-readtable.")))
6135
6136 (define-public cl-fare-quasiquote-readtable
6137   (sbcl-package->cl-source-package sbcl-fare-quasiquote-readtable))
6138
6139 ;; TODO: Add support for component-less system in asdf-build-system/sbcl.
6140 (define-public sbcl-fare-quasiquote-extras
6141   (package
6142     (inherit sbcl-fare-quasiquote)
6143     (name "sbcl-fare-quasiquote-extras")
6144     (build-system asdf-build-system/sbcl)
6145     (inputs
6146      `(("fare-quasiquote-optima" ,sbcl-fare-quasiquote-optima)
6147        ("fare-quasiquote-readtable" ,sbcl-fare-quasiquote-readtable)))
6148     (arguments
6149      `(#:phases
6150        (modify-phases %standard-phases
6151          (replace 'build
6152            (lambda* (#:key outputs #:allow-other-keys)
6153              (let* ((out (assoc-ref outputs "out"))
6154                     (lib (string-append out "/lib/" (%lisp-type))))
6155                (mkdir-p lib)
6156                (install-file "fare-quasiquote-extras.asd" lib)
6157                (make-file-writable
6158                 (string-append lib "/fare-quasiquote-extras.asd"))
6159                #t)))
6160          (add-after 'create-asd-file 'fix-asd-file
6161            (lambda* (#:key outputs #:allow-other-keys)
6162              (let* ((out (assoc-ref outputs "out"))
6163                     (lib (string-append out "/lib/" (%lisp-type)))
6164                     (asd (string-append lib "/fare-quasiquote-extras.asd")))
6165                (substitute* asd
6166                  ((":class")
6167                   "")
6168                  (("asdf/bundle:prebuilt-system")
6169                   "")
6170                  ((":components")
6171                   "")
6172                  (("\\(\\(:compiled-file \"fare-quasiquote-extras--system\"\\)\\)")
6173                   "")))
6174              #t)))))
6175     (description "This library combines @code{fare-quasiquote-readtable} and
6176 @code{fare-quasiquote-optima}.")))
6177
6178 (define-public cl-fare-quasiquote-extras
6179   (package
6180     (inherit cl-fare-quasiquote)
6181     (name "cl-fare-quasiquote-extras")
6182     (build-system asdf-build-system/source)
6183     (propagated-inputs
6184      `(("fare-quasiquote" ,cl-fare-quasiquote)
6185        ("fare-quasiquote-optima" ,cl-fare-quasiquote-optima)
6186        ("fare-quasiquote-readtable" ,cl-fare-quasiquote-readtable)))
6187     (description "This library combines @code{fare-quasiquote-readtable} and
6188 @code{fare-quasiquote-optima}.")))
6189
6190 (define-public sbcl-trivia.level0
6191   (let ((commit "574901ac376ae54c9d37169fd5efab9b3b8fcc63")
6192         (revision "1"))
6193     (package
6194       (name "sbcl-trivia.level0")
6195       (build-system asdf-build-system/sbcl)
6196       (version (git-version "0.0.0" revision commit))
6197       (home-page "https://github.com/guicho271828/trivia")
6198       (source
6199        (origin
6200          (method git-fetch)
6201          (uri (git-reference
6202                (url home-page)
6203                (commit commit)))
6204          (file-name (git-file-name name version))
6205          (sha256
6206           (base32
6207            "0hf53n71xzr9sjwrxis5fivx3drclf4s39h5ck8vh21ndqj9zvdk"))))
6208       (inputs
6209        `(("alexandria" ,sbcl-alexandria)))
6210       (synopsis "Pattern matching in Common Lisp")
6211       (description "Trivia is a pattern matching compiler that is compatible
6212 with Optima, another pattern matching library for Common Lisp.  It is meant to
6213 be faster and more extensible than Optima.")
6214       (license license:llgpl))))
6215
6216 (define-public sbcl-trivia.level1
6217   (package
6218     (inherit sbcl-trivia.level0)
6219     (name "sbcl-trivia.level1")
6220     (inputs
6221      `(("trivia.level0" ,sbcl-trivia.level0)))
6222     (description "Trivia is a pattern matching compiler that is compatible
6223 with Optima, another pattern matching library for Common Lisp.  It is meant to
6224 be faster and more extensible than Optima.
6225
6226 This system contains the core patterns of Trivia.")))
6227
6228 (define-public sbcl-trivia.level2
6229   (package
6230     (inherit sbcl-trivia.level0)
6231     (name "sbcl-trivia.level2")
6232     (inputs
6233      `(("trivia.level1" ,sbcl-trivia.level1)
6234        ("lisp-namespace" ,sbcl-lisp-namespace)
6235        ("trivial-cltl2" ,sbcl-trivial-cltl2)
6236        ("closer-mop" ,sbcl-closer-mop)))
6237     (description "Trivia is a pattern matching compiler that is compatible
6238 with Optima, another pattern matching library for Common Lisp.  It is meant to
6239 be faster and more extensible than Optima.
6240
6241 This system contains a non-optimized pattern matcher compatible with Optima,
6242 with extensible optimizer interface.")))
6243
6244 (define-public sbcl-trivia.trivial
6245   (package
6246     (inherit sbcl-trivia.level0)
6247     (name "sbcl-trivia.trivial")
6248     (inputs
6249      `(("trivia.level2" ,sbcl-trivia.level2)))
6250     (arguments
6251      `(#:phases
6252        (modify-phases %standard-phases
6253          (replace 'create-asd-file
6254            (lambda* (#:key outputs inputs #:allow-other-keys)
6255              (let* ((out (assoc-ref outputs "out"))
6256                     (lib (string-append out "/lib/" (%lisp-type)))
6257                     (level2 (assoc-ref inputs "trivia.level2")))
6258                (mkdir-p lib)
6259                (install-file "trivia.trivial.asd" lib)
6260                ;; XXX: This .asd does not have any component and the build
6261                ;; system fails to work in this case.  We should update the
6262                ;; build system to handle component-less .asd.
6263                ;; TODO: How do we append to file in Guile?  It seems that
6264                ;; (open-file ... "a") gets a "Permission denied".
6265                (substitute* (string-append lib "/trivia.trivial.asd")
6266                  (("\"\\)")
6267                   (string-append "\")
6268
6269 (progn (asdf/source-registry:ensure-source-registry)
6270        (setf (gethash
6271                \"trivia.level2\"
6272                asdf/source-registry:*source-registry*)
6273              #p\""
6274                                  level2
6275                                  "/share/common-lisp/sbcl-bundle-systems/trivia.level2.asd\"))")))))))))
6276     (description "Trivia is a pattern matching compiler that is compatible
6277 with Optima, another pattern matching library for Common Lisp.  It is meant to
6278 be faster and more extensible than Optima.
6279
6280 This system contains the base level system of Trivia with a trivial optimizer.")))
6281
6282 (define-public sbcl-trivia.balland2006
6283   (package
6284     (inherit sbcl-trivia.level0)
6285     (name "sbcl-trivia.balland2006")
6286     (inputs
6287      `(("trivia.trivial" ,sbcl-trivia.trivial)
6288        ("iterate" ,sbcl-iterate)
6289        ("type-i" ,sbcl-type-i)
6290        ("alexandria" ,sbcl-alexandria)))
6291     (arguments
6292      ;; Tests are done in trivia itself.
6293      `(#:tests? #f))
6294     (description "Trivia is a pattern matching compiler that is compatible
6295 with Optima, another pattern matching library for Common Lisp.  It is meant to
6296 be faster and more extensible than Optima.
6297
6298 This system contains the base level system of Trivia with a trivial optimizer.")))
6299
6300 (define-public sbcl-trivia.ppcre
6301   (package
6302     (inherit sbcl-trivia.level0)
6303     (name "sbcl-trivia.ppcre")
6304     (inputs
6305      `(("trivia.trivial" ,sbcl-trivia.trivial)
6306        ("cl-ppcre" ,sbcl-cl-ppcre)))
6307     (description "Trivia is a pattern matching compiler that is compatible
6308 with Optima, another pattern matching library for Common Lisp.  It is meant to
6309 be faster and more extensible than Optima.
6310
6311 This system contains the PPCRE extension.")))
6312
6313 (define-public sbcl-trivia.quasiquote
6314   (package
6315     (inherit sbcl-trivia.level0)
6316     (name "sbcl-trivia.quasiquote")
6317     (inputs
6318      `(("trivia.trivial" ,sbcl-trivia.trivial)
6319        ("fare-quasiquote" ,sbcl-fare-quasiquote)
6320        ("fare-quasiquote-readtable" ,sbcl-fare-quasiquote-readtable)))
6321     (description "Trivia is a pattern matching compiler that is compatible
6322 with Optima, another pattern matching library for Common Lisp.  It is meant to
6323 be faster and more extensible than Optima.
6324
6325 This system contains the fare-quasiquote extension.")))
6326
6327 (define-public sbcl-trivia.cffi
6328   (package
6329     (inherit sbcl-trivia.level0)
6330     (name "sbcl-trivia.cffi")
6331     (inputs
6332      `(("cffi" ,sbcl-cffi)
6333        ("trivia.trivial" ,sbcl-trivia.trivial)))
6334     (description "Trivia is a pattern matching compiler that is compatible
6335 with Optima, another pattern matching library for Common Lisp.  It is meant to
6336 be faster and more extensible than Optima.
6337
6338 This system contains the CFFI foreign slot access extension.")))
6339
6340 (define-public sbcl-trivia
6341   (package
6342     (inherit sbcl-trivia.level0)
6343     (name "sbcl-trivia")
6344     (inputs
6345      `(("trivia.balland2006" ,sbcl-trivia.balland2006)))
6346     (native-inputs
6347      `(("fiveam" ,sbcl-fiveam)
6348        ("trivia.ppcre" ,sbcl-trivia.ppcre)
6349        ("trivia.quasiquote" ,sbcl-trivia.quasiquote)
6350        ("trivia.cffi" ,sbcl-trivia.cffi)
6351        ("optima" ,sbcl-optima)))
6352     (arguments
6353      `(#:test-asd-file "trivia.test.asd"
6354        #:phases
6355        (modify-phases %standard-phases
6356          (add-after 'create-asd 'remove-component
6357            ;; XXX: The original .asd has no components, but our build system
6358            ;; creates an entry nonetheless.  We need to remove it for the
6359            ;; generated .asd to load properly.  See trivia.trivial for a
6360            ;; similar problem.
6361            (lambda* (#:key outputs #:allow-other-keys)
6362              (let* ((out (assoc-ref outputs "out"))
6363                     (asd (string-append out "/lib/" (%lisp-type) "/trivia.asd")))
6364                (substitute* asd
6365                  (("  :components
6366 ")
6367                   ""))
6368                (substitute* asd
6369                  ((" *\\(\\(:compiled-file \"trivia--system\"\\)\\)")
6370                   ""))))))))
6371     (description "Trivia is a pattern matching compiler that is compatible
6372 with Optima, another pattern matching library for Common Lisp.  It is meant to
6373 be faster and more extensible than Optima.")))
6374
6375 (define-public cl-trivia
6376   (sbcl-package->cl-source-package sbcl-trivia))
6377
6378 (define-public sbcl-mk-string-metrics
6379   (package
6380     (name "sbcl-mk-string-metrics")
6381     (version "0.1.2")
6382     (home-page "https://github.com/cbaggers/mk-string-metrics/")
6383     (source (origin
6384               (method git-fetch)
6385               (uri (git-reference
6386                     (url home-page)
6387                     (commit version)))
6388               (sha256
6389                (base32 "0bg0bv2mfd4k0g3x72x563hvmrx18xavaffr6xk5rh4if5j7kcf6"))
6390               (file-name (git-file-name name version))))
6391     (build-system asdf-build-system/sbcl)
6392     (synopsis "Calculate various string metrics efficiently in Common Lisp")
6393     (description "This library implements efficient algorithms that calculate
6394 various string metrics in Common Lisp:
6395
6396 @itemize
6397 @item Damerau-Levenshtein distance
6398 @item Hamming distance
6399 @item Jaccard similarity coefficient
6400 @item Jaro distance
6401 @item Jaro-Winkler distance
6402 @item Levenshtein distance
6403 @item Normalized Damerau-Levenshtein distance
6404 @item Normalized Levenshtein distance
6405 @item Overlap coefficient
6406 @end itemize\n")
6407     (license license:x11)))
6408
6409 (define-public cl-mk-string-metrics
6410   (sbcl-package->cl-source-package sbcl-mk-string-metrics))
6411
6412 (define-public sbcl-cl-str
6413   (let ((commit "eb480f283e28802d67b35bf916506701152f9a2a"))
6414     (package
6415       (name "sbcl-cl-str")
6416       (version (git-version "0.17" "1" commit))
6417       (home-page "https://github.com/vindarel/cl-str")
6418       (source (origin
6419                 (method git-fetch)
6420                 (uri (git-reference
6421                       (url home-page)
6422                       (commit commit)))
6423                 (sha256
6424                  (base32 "1hpq5m8zjjnzns370zy27z2vcm1p8n2ka5ij2x67gyc9amz9vla0"))
6425                 (file-name (git-file-name name version))))
6426       (build-system asdf-build-system/sbcl)
6427       (inputs
6428        `(("cl-ppcre" ,sbcl-cl-ppcre)
6429          ("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)
6430          ("cl-change-case" ,sbcl-cl-change-case)))
6431       (native-inputs
6432        `(("prove" ,sbcl-prove)
6433          ("prove-asdf" ,sbcl-prove-asdf)))
6434       (arguments
6435        `(#:asd-file "str.asd"
6436          #:asd-system-name "str"
6437          #:test-asd-file "str.test.asd"))
6438       (synopsis "Modern, consistent and terse Common Lisp string manipulation library")
6439       (description "A modern and consistent Common Lisp string manipulation
6440 library that focuses on modernity, simplicity and discoverability:
6441 @code{(str:trim s)} instead of @code{(string-trim '(#\\Space ...) s)}), or
6442 @code{str:concat strings} instead of an unusual format construct; one
6443 discoverable library instead of many; consistency and composability, where
6444 @code{s} is always the last argument, which makes it easier to feed pipes and
6445 arrows.")
6446       (license license:expat))))
6447
6448 (define-public cl-str
6449   (sbcl-package->cl-source-package sbcl-cl-str))
6450
6451 (define-public sbcl-cl-xmlspam
6452   (let ((commit "ea06abcca2a73a9779bcfb09081e56665f94e22a"))
6453     (package
6454       (name "sbcl-cl-xmlspam")
6455       (build-system asdf-build-system/sbcl)
6456       (version (git-version "0.0.0" "1" commit))
6457       (home-page "https://github.com/rogpeppe/cl-xmlspam")
6458       (source
6459        (origin
6460          (method git-fetch)
6461          (uri (git-reference
6462                (url home-page)
6463                (commit commit)))
6464          (file-name (string-append name "-" version))
6465          (sha256
6466           (base32
6467            "0w4rqvrgdgk3fwfq3kx4r7wwdr2bv3b6n3bdqwsiriw9psqzpz2s"))))
6468       (inputs
6469        `(("cxml" ,sbcl-cxml)
6470          ("cl-ppcre" ,sbcl-cl-ppcre)))
6471       (synopsis "Concise, regexp-like pattern matching on streaming XML for Common Lisp")
6472       (description "CXML does an excellent job at parsing XML elements, but what
6473 do you do when you have a XML file that's larger than you want to fit in
6474 memory, and you want to extract some information from it?  Writing code to deal
6475 with SAX events, or even using Klacks, quickly becomes tedious.
6476 @code{cl-xmlspam} (for XML Stream PAttern Matcher) is designed to make it easy
6477 to write code that mirrors the structure of the XML that it's parsing.  It
6478 also makes it easy to shift paradigms when necessary - the usual Lisp control
6479 constructs can be used interchangeably with pattern matching, and the full
6480 power of CXML is available when necessary.")
6481       (license license:bsd-3))))
6482
6483 ;; TODO: dbus uses ASDF's package-inferred-system which is not supported by
6484 ;; asdf-build-system/sbcl as of 2019-08-02.  We should fix
6485 ;; asdf-build-system/sbcl.
6486 (define-public cl-dbus
6487   (let ((commit "24b452df3a45ca5dc95015500f34baad175c981a")
6488         (revision "1"))
6489     (package
6490       (name "cl-dbus")
6491       (build-system asdf-build-system/source)
6492       (version (git-version "20190408" revision commit))
6493       (home-page "https://github.com/death/dbus")
6494       (source
6495        (origin
6496          (method git-fetch)
6497          (uri (git-reference
6498                (url home-page)
6499                (commit commit)))
6500          (file-name (git-file-name name version))
6501          (sha256
6502           (base32
6503            "0fw2q866yddbf23nk9pxphm9gsasx35vjyss82xzvndnjmzlqfl5"))))
6504       ;; Inputs must be propagated or else packages depending on this won't
6505       ;; have the necessary packages.
6506       (propagated-inputs
6507        `(("alexandria" ,sbcl-alexandria)
6508          ("trivial-garbage" ,sbcl-trivial-garbage)
6509          ("babel" ,sbcl-babel)
6510          ("iolib" ,sbcl-iolib)
6511          ("ieee-floats" ,sbcl-ieee-floats)
6512          ("flexi-streams" ,sbcl-flexi-streams)
6513          ("cl-xmlspam" ,sbcl-cl-xmlspam)
6514          ("ironclad" ,sbcl-ironclad)))
6515       (synopsis "D-Bus client library for Common Lisp")
6516       (description "This is a Common Lisp library that publishes D-Bus
6517 objects as well as send and notify other objects connected to a bus.")
6518       (license license:bsd-2))))
6519
6520 (define-public sbcl-cl-hooks
6521   (let ((commit "5b638083f3b4f1221a52631d9c8a0a265565cac7")
6522         (revision "1"))
6523     (package
6524       (name "sbcl-cl-hooks")
6525       (build-system asdf-build-system/sbcl)
6526       (version (git-version "0.2.1" revision commit))
6527       (home-page "https://github.com/scymtym/architecture.hooks")
6528       (source
6529        (origin
6530          (method git-fetch)
6531          (uri (git-reference
6532                (url home-page)
6533                (commit commit)))
6534          (file-name (git-file-name name version))
6535          (sha256
6536           (base32
6537            "0bg3l0a28lw5gqqjp6p6b5nhwqk46sgkb7184w5qbfngw1hk8x9y"))))
6538       (inputs
6539        `(("alexandria" ,sbcl-alexandria)
6540          ("let-plus" ,sbcl-let-plus)
6541          ("trivial-garbage" ,sbcl-trivial-garbage)
6542          ("closer-mop" ,sbcl-closer-mop)))
6543       (native-inputs
6544        `(("fiveam" ,sbcl-fiveam)))
6545       (synopsis "Hooks extension point mechanism (as in Emacs) for Common Lisp")
6546       (description "A hook, in the present context, is a certain kind of
6547 extension point in a program that allows interleaving the execution of
6548 arbitrary code with the execution of a the program without introducing any
6549 coupling between the two.  Hooks are used extensively in the extensible editor
6550 Emacs.
6551
6552 In the Common LISP Object System (CLOS), a similar kind of extensibility is
6553 possible using the flexible multi-method dispatch mechanism.  It may even seem
6554 that the concept of hooks does not provide any benefits over the possibilities
6555 of CLOS.  However, there are some differences:
6556
6557 @itemize
6558
6559 @item There can be only one method for each combination of specializers and
6560 qualifiers.  As a result this kind of extension point cannot be used by
6561 multiple extensions independently.
6562 @item Removing code previously attached via a @code{:before}, @code{:after} or
6563 @code{:around} method can be cumbersome.
6564 @item There could be other or even multiple extension points besides @code{:before}
6565 and @code{:after} in a single method.
6566 @item Attaching codes to individual objects using eql specializers can be
6567 cumbersome.
6568 @item Introspection of code attached a particular extension point is
6569 cumbersome since this requires enumerating and inspecting the methods of a
6570 generic function.
6571 @end itemize
6572
6573 This library tries to complement some of these weaknesses of method-based
6574 extension-points via the concept of hooks.")
6575       (license license:llgpl))))
6576
6577 (define-public cl-hooks
6578   (sbcl-package->cl-source-package sbcl-cl-hooks))
6579
6580 (define-public ecl-cl-hooks
6581   (sbcl-package->ecl-package sbcl-cl-hooks))
6582
6583 (define-public sbcl-s-sysdeps
6584   (let ((commit "d28246b5dffef9e73a0e0e6cfbc4e878006fe34d")
6585         (revision "1"))
6586     (package
6587       (name "sbcl-s-sysdeps")
6588       (build-system asdf-build-system/sbcl)
6589       (version (git-version "1" revision commit))
6590       (home-page "https://github.com/svenvc/s-sysdeps")
6591       (source
6592        (origin
6593          (method git-fetch)
6594          (uri (git-reference
6595                (url home-page)
6596                (commit commit)))
6597          (file-name (git-file-name name version))
6598          (sha256
6599           (base32
6600            "14b69b81yrxmjlvmm3lfxk04x5v7hqz4fql121334wh72czznfh9"))))
6601       (synopsis "Common Lisp abstraction layer over platform dependent functionality")
6602       (description "@code{s-sysdeps} is an abstraction layer over platform
6603 dependent functionality.  This simple package is used as a building block in a
6604 number of other open source projects.
6605
6606 @code{s-sysdeps} abstracts:
6607
6608 @itemize
6609 @item managing processes,
6610 @item implementing a standard TCP/IP server,
6611 @item opening a client TCP/IP socket stream,
6612 @item working with process locks.
6613 @end itemize\n")
6614       (license license:llgpl))))
6615
6616 (define-public cl-s-sysdeps
6617   (sbcl-package->cl-source-package sbcl-s-sysdeps))
6618
6619 (define-public ecl-s-sysdeps
6620   (sbcl-package->ecl-package sbcl-s-sysdeps))
6621
6622 (define-public sbcl-cl-prevalence
6623   (let ((commit "c163c227ed85d430b82cb1e3502f72d4f88e3cfa")
6624         (revision "1"))
6625     (package
6626       (name "sbcl-cl-prevalence")
6627       (build-system asdf-build-system/sbcl)
6628       (version (git-version "5" revision commit))
6629       (home-page "https://github.com/40ants/cl-prevalence")
6630       (source
6631        (origin
6632          (method git-fetch)
6633          (uri (git-reference
6634                (url home-page)
6635                (commit commit)))
6636          (file-name (git-file-name name version))
6637          (sha256
6638           (base32
6639            "1i9zj1q2ahgwch56an21yzbgkynz0kab9fyxkq9mg8p3xrv38jjn"))))
6640       (inputs
6641        `(("s-sysdeps" ,sbcl-s-sysdeps)
6642          ("s-xml" ,sbcl-s-xml)))
6643       (synopsis "Implementation of object prevalence for Common Lisp")
6644       (description "This Common Lisp library implements object prevalence (see
6645 @url{https://en.wikipedia.org/wiki/System_prevalence}).  It allows
6646 for (de)serializing to and from s-exps as well as XML.  Serialization of arbitrary
6647 classes and cyclic data structures are supported.")
6648       (license license:llgpl))))
6649
6650 (define-public cl-prevalence
6651   (sbcl-package->cl-source-package sbcl-cl-prevalence))
6652
6653 (define-public ecl-cl-prevalence
6654   (sbcl-package->ecl-package sbcl-cl-prevalence))
6655
6656 (define-public sbcl-series
6657   (let ((commit "da9061b336119d1e5214aff9117171d494d5a58a")
6658         (revision "1"))
6659     (package
6660       (name "sbcl-series")
6661       (version (git-version "2.2.11" revision commit))
6662       (source
6663        (origin
6664          (method git-fetch)
6665          (uri (git-reference
6666                (url "git://git.code.sf.net/p/series/series")
6667                (commit commit)))
6668          (file-name (git-file-name name version))
6669          (sha256
6670           (base32
6671            "07hk2lhfx42zk018pxqvn4gs77vd4n4g8m4xxbqaxgca76mifwfw"))))
6672       (build-system asdf-build-system/sbcl)
6673       (arguments
6674        ;; Disable the tests, they are apparently buggy and I didn't find
6675        ;; a simple way to make them run and pass.
6676        '(#:tests? #f))
6677       (synopsis "Series data structure for Common Lisp")
6678       (description
6679        "This Common Lisp library provides a series data structure much like
6680 a sequence, with similar kinds of operations.  The difference is that in many
6681 situations, operations on series may be composed functionally and yet execute
6682 iteratively, without the need to construct intermediate series values
6683 explicitly.  In this manner, series provide both the clarity of a functional
6684 programming style and the efficiency of an iterative programming style.")
6685       (home-page "http://series.sourceforge.net/")
6686       (license license:expat))))
6687
6688 (define-public cl-series
6689   (sbcl-package->cl-source-package sbcl-series))
6690
6691 (define-public ecl-series
6692   (sbcl-package->ecl-package sbcl-series))
6693
6694 (define-public sbcl-periods
6695   (let ((commit "983d4a57325db3c8def942f163133cec5391ec28")
6696         (revision "1"))
6697     (package
6698       (name "sbcl-periods")
6699       (version (git-version "0.0.2" revision commit))
6700       (source
6701        (origin
6702          (method git-fetch)
6703          (uri (git-reference
6704                (url "https://github.com/jwiegley/periods.git")
6705                (commit commit)))
6706          (file-name (git-file-name name version))
6707          (sha256
6708           (base32
6709            "0z30jr3lxz3cmi019fsl4lgcgwf0yqpn95v9zkkkwgymdrkd4lga"))))
6710       (build-system asdf-build-system/sbcl)
6711       (inputs
6712        `(("local-time" ,sbcl-local-time)))
6713       (synopsis "Common Lisp library for manipulating date/time objects")
6714       (description
6715        "Periods is a Common Lisp library providing a set of utilities for
6716 manipulating times, distances between times, and both contiguous and
6717 discontiguous ranges of time.")
6718       (home-page "https://github.com/jwiegley/periods")
6719       (license license:bsd-3))))
6720
6721 (define-public cl-periods
6722   (sbcl-package->cl-source-package sbcl-periods))
6723
6724 (define-public ecl-periods
6725   (sbcl-package->ecl-package sbcl-periods))
6726
6727 (define-public sbcl-periods-series
6728   (package
6729     (inherit sbcl-periods)
6730     (name "sbcl-periods-series")
6731     (inputs
6732      `(("periods" ,sbcl-periods)
6733        ("series" ,sbcl-series)))
6734     (arguments
6735      '(#:asd-file "periods-series.asd"
6736        #:asd-system-name "periods-series"))
6737     (description
6738      "Periods-series is an extension of the periods Common Lisp library
6739 providing functions compatible with the series Common Lisp library.")))
6740
6741 (define-public cl-periods-series
6742   (sbcl-package->cl-source-package sbcl-periods-series))
6743
6744 (define-public ecl-periods-series
6745   (sbcl-package->ecl-package sbcl-periods-series))
6746
6747 (define-public sbcl-metatilities-base
6748   (let ((commit "6eaa9e3ff0939a93a92109dd0fcd218de85417d5")
6749         (revision "1"))
6750     (package
6751       (name "sbcl-metatilities-base")
6752       (version (git-version "0.6.6" revision commit))
6753       (source
6754        (origin
6755          (method git-fetch)
6756          (uri (git-reference
6757                (url "https://github.com/gwkkwg/metatilities-base.git")
6758                (commit commit)))
6759          (file-name (git-file-name name version))
6760          (sha256
6761           (base32
6762            "0xpa86pdzlnf4v5g64j3ifaplx71sx2ha8b7vvakswi652679ma0"))))
6763       (build-system asdf-build-system/sbcl)
6764       (native-inputs
6765        `(("lift" ,sbcl-lift)))
6766       (synopsis "Core of the metatilities Common Lisp library")
6767       (description
6768        "Metatilities-base is the core of the metatilities Common Lisp library
6769 which implements a set of utilities.")
6770       (home-page "https://common-lisp.net/project/metatilities-base/")
6771       (license license:expat))))
6772
6773 (define-public cl-metatilities-base
6774   (sbcl-package->cl-source-package sbcl-metatilities-base))
6775
6776 (define-public ecl-metatilities-base
6777   (sbcl-package->ecl-package sbcl-metatilities-base))
6778
6779 (define-public sbcl-cl-containers
6780   (let ((commit "3d1df53c22403121bffb5d553cf7acb1503850e7")
6781         (revision "3"))
6782     (package
6783       (name "sbcl-cl-containers")
6784       (version (git-version "0.12.1" revision commit))
6785       (source
6786        (origin
6787          (method git-fetch)
6788          (uri (git-reference
6789                (url "https://github.com/gwkkwg/cl-containers.git")
6790                (commit commit)))
6791          (file-name (git-file-name name version))
6792          (sha256
6793           (base32
6794            "18s6jfq11n8nv9k4biz32pm1s7y9zl054ry1gmdbcf39nisy377y"))))
6795       (build-system asdf-build-system/sbcl)
6796       (native-inputs
6797        `(("lift" ,sbcl-lift)))
6798       (inputs
6799        `(("metatilities-base" ,sbcl-metatilities-base)))
6800       (arguments
6801        '(#:phases
6802          (modify-phases %standard-phases
6803            (add-after 'unpack 'relax-version-checks
6804              (lambda _
6805                (substitute* "cl-containers.asd"
6806                  (("\\(:version \"metatilities-base\" \"0\\.6\\.6\"\\)")
6807                   "\"metatilities-base\""))
6808                (substitute* "cl-containers-test.asd"
6809                  (("\\(:version \"lift\" \"1\\.7\\.0\"\\)")
6810                   "\"lift\""))
6811                #t)))))
6812       (synopsis "Container library for Common Lisp")
6813       (description
6814        "Common Lisp ships with a set of powerful built in data structures
6815 including the venerable list, full featured arrays, and hash-tables.
6816 CL-containers enhances and builds on these structures by adding containers
6817 that are not available in native Lisp (for example: binary search trees,
6818 red-black trees, sparse arrays and so on), and by providing a standard
6819 interface so that they are simpler to use and so that changing design
6820 decisions becomes significantly easier.")
6821       (home-page "https://common-lisp.net/project/cl-containers/")
6822       (license license:expat))))
6823
6824 (define-public cl-containers
6825   (sbcl-package->cl-source-package sbcl-cl-containers))
6826
6827 (define-public ecl-cl-containers
6828   (sbcl-package->ecl-package sbcl-cl-containers))
6829
6830 (define-public sbcl-xlunit
6831   (let ((commit "3805d34b1d8dc77f7e0ee527a2490194292dd0fc")
6832         (revision "1"))
6833     (package
6834       (name "sbcl-xlunit")
6835       (version (git-version "0.6.3" revision commit))
6836       (source
6837        (origin
6838          (method git-fetch)
6839          (uri (git-reference
6840                (url "http://git.kpe.io/xlunit.git")
6841                (commit commit)))
6842          (file-name (git-file-name name version))
6843          (sha256
6844           (base32
6845            "0argfmp9nghs4sihyj3f8ch9qfib2b7ll07v5m9ziajgzsfl5xw3"))))
6846       (build-system asdf-build-system/sbcl)
6847       (arguments
6848        '(#:phases
6849          (modify-phases %standard-phases
6850            (add-after 'unpack 'fix-tests
6851              (lambda _
6852                (substitute* "xlunit.asd"
6853                  ((" :force t") ""))
6854                #t)))))
6855       (synopsis "Unit testing package for Common Lisp")
6856       (description
6857        "The XLUnit package is a toolkit for building test suites.  It is based
6858 on the XPTest package by Craig Brozensky and the JUnit package by Kent Beck.")
6859       (home-page "http://quickdocs.org/xlunit/")
6860       (license license:bsd-3))))
6861
6862 (define-public cl-xlunit
6863   (sbcl-package->cl-source-package sbcl-xlunit))
6864
6865 (define-public ecl-xlunit
6866   (sbcl-package->ecl-package sbcl-xlunit))
6867
6868 (define-public sbcl-fprog
6869   (let ((commit "7016d1a98215f82605d1c158e7a16504ca1f4636")
6870         (revision "1"))
6871     (package
6872       (name "sbcl-fprog")
6873       (version (git-version "1.0.0" revision commit))
6874       (source
6875        (origin
6876          (method git-fetch)
6877          (uri (git-reference
6878                (url "https://github.com/jwiegley/cambl.git")
6879                (commit commit)))
6880          (file-name (git-file-name name version))
6881          (sha256
6882           (base32
6883            "103mry04j2k9vznsxm7wcvccgxkil92cdrv52miwcmxl8daa4jiz"))))
6884       (build-system asdf-build-system/sbcl)
6885       (synopsis "Functional programming utilities for Common Lisp")
6886       (description
6887        "@code{fprog} is a Common Lisp library allowing iteration over
6888 immutable lists sharing identical sublists.")
6889       (home-page "https://github.com/jwiegley/cambl")
6890       (license license:bsd-3))))
6891
6892 (define-public cl-fprog
6893   (sbcl-package->cl-source-package sbcl-fprog))
6894
6895 (define-public ecl-fprog
6896   (sbcl-package->ecl-package sbcl-fprog))
6897
6898 (define-public sbcl-cambl
6899   (let ((commit "7016d1a98215f82605d1c158e7a16504ca1f4636")
6900         (revision "1"))
6901     (package
6902       (inherit sbcl-fprog)
6903       (name "sbcl-cambl")
6904       (version (git-version "4.0.0" revision commit))
6905       (native-inputs
6906        `(("xlunit" ,sbcl-xlunit)))
6907       (inputs
6908        `(("alexandria" ,sbcl-alexandria)
6909          ("cl-containers" ,sbcl-cl-containers)
6910          ("local-time" ,sbcl-local-time)
6911          ("periods" ,sbcl-periods)
6912          ("fprog" ,sbcl-fprog)))
6913       (synopsis "Commoditized amounts and balances for Common Lisp")
6914       (description
6915        "CAMBL is a Common Lisp library providing a convenient facility for
6916 working with commoditized values.  It does not allow compound units (and so is
6917 not suited for scientific operations) but does work rather nicely for the
6918 purpose of financial calculations."))))
6919
6920 (define-public cl-cambl
6921   (sbcl-package->cl-source-package sbcl-cambl))
6922
6923 (define-public ecl-cambl
6924   (sbcl-package->ecl-package sbcl-cambl))
6925
6926 (define-public sbcl-cl-ledger
6927   (let ((commit "08e0be41795e804cd36142e51756ad0b1caa377b")
6928         (revision "1"))
6929     (package
6930       (name "sbcl-cl-ledger")
6931       (version (git-version "4.0.0" revision commit))
6932       (source
6933        (origin
6934          (method git-fetch)
6935          (uri (git-reference
6936                (url "https://github.com/ledger/cl-ledger.git")
6937                (commit commit)))
6938          (file-name (git-file-name name version))
6939          (sha256
6940           (base32
6941            "1via0qf6wjcyxnfbmfxjvms0ik9j8rqbifgpmnhrzvkhrq9pv8h1"))))
6942       (build-system asdf-build-system/sbcl)
6943       (inputs
6944        `(("cambl" ,sbcl-cambl)
6945          ("cl-ppcre" ,sbcl-cl-ppcre)
6946          ("local-time" ,sbcl-local-time)
6947          ("periods-series" ,sbcl-periods-series)))
6948       (arguments
6949        '(#:phases
6950          (modify-phases %standard-phases
6951            (add-after 'unpack 'fix-system-definition
6952              (lambda _
6953                (substitute* "cl-ledger.asd"
6954                  (("  :build-operation program-op") "")
6955                  (("  :build-pathname \"cl-ledger\"") "")
6956                  (("  :entry-point \"ledger::main\"") ""))
6957                #t)))))
6958       (synopsis "Common Lisp port of the Ledger accounting system")
6959       (description
6960        "CL-Ledger is a Common Lisp port of the Ledger double-entry accounting
6961 system.")
6962       (home-page "https://github.com/ledger/cl-ledger")
6963       (license license:bsd-3))))
6964
6965 (define-public cl-ledger
6966   (sbcl-package->cl-source-package sbcl-cl-ledger))
6967
6968 (define-public ecl-cl-ledger
6969   (sbcl-package->ecl-package sbcl-cl-ledger))
6970
6971 (define-public sbcl-bst
6972   (let ((commit "34f9c7e8e0a9f2c952fe310ab36cb630d5d9c15a")
6973         (revision "1"))
6974     (package
6975       (name "sbcl-bst")
6976       (version (git-version "1.1" revision commit))
6977       (source
6978        (origin
6979          (method git-fetch)
6980          (uri (git-reference
6981                (url "https://github.com/glv2/bst.git")
6982                (commit commit)))
6983          (file-name (git-file-name name version))
6984          (sha256
6985           (base32
6986            "1amxns7hvvh4arwbh8ciwfzplg127vh37dnbamv1m1kmmnmihfc8"))))
6987       (build-system asdf-build-system/sbcl)
6988       (native-inputs
6989        `(("alexandria" ,sbcl-alexandria)
6990          ("fiveam" ,sbcl-fiveam)))
6991       (synopsis "Binary search tree for Common Lisp")
6992       (description
6993        "BST is a Common Lisp library for working with binary search trees that
6994 can contain any kind of values.")
6995       (home-page "https://github.com/glv2/bst")
6996       (license license:gpl3))))
6997
6998 (define-public cl-bst
6999   (sbcl-package->cl-source-package sbcl-bst))
7000
7001 (define-public ecl-bst
7002   (sbcl-package->ecl-package sbcl-bst))
7003
7004 (define-public sbcl-cl-octet-streams
7005   (package
7006     (name "sbcl-cl-octet-streams")
7007     (version "1.0")
7008     (source
7009      (origin
7010        (method git-fetch)
7011        (uri (git-reference
7012              (url "https://github.com/glv2/cl-octet-streams.git")
7013              (commit (string-append "v" version))))
7014        (file-name (git-file-name name version))
7015        (sha256
7016         (base32
7017          "1d7mn6ydv0j2x4r7clpc9ijjwrnfpxmvhifv8n5j7jh7s744sf8d"))))
7018     (build-system asdf-build-system/sbcl)
7019     (native-inputs
7020      `(("fiveam" ,sbcl-fiveam)))
7021     (inputs
7022      `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
7023     (synopsis "In-memory octet streams for Common Lisp")
7024     (description
7025      "CL-octet-streams is a library implementing in-memory octet
7026 streams for Common Lisp.  It was inspired by the trivial-octet-streams and
7027 cl-plumbing libraries.")
7028     (home-page "https://github.com/glv2/cl-octet-streams")
7029     (license license:gpl3+)))
7030
7031 (define-public cl-octet-streams
7032   (sbcl-package->cl-source-package sbcl-cl-octet-streams))
7033
7034 (define-public ecl-cl-octet-streams
7035   (sbcl-package->ecl-package sbcl-cl-octet-streams))
7036
7037 (define-public sbcl-lzlib
7038   (let ((commit "0de1db7129fef9a58a059d35a2fa2ecfc5b47b47")
7039         (revision "1"))
7040     (package
7041       (name "sbcl-lzlib")
7042       (version (git-version "1.0" revision commit))
7043       (source
7044        (origin
7045          (method git-fetch)
7046          (uri (git-reference
7047                (url "https://github.com/glv2/cl-lzlib.git")
7048                (commit commit)))
7049          (file-name (git-file-name name version))
7050          (sha256
7051           (base32
7052            "12ny7vj52fgnd8hb8fc8mry92vq4c1x72x2350191m4476j95clz"))))
7053       (build-system asdf-build-system/sbcl)
7054       (native-inputs
7055        `(("fiveam" ,sbcl-fiveam)))
7056       (inputs
7057        `(("cffi" ,sbcl-cffi)
7058          ("cl-octet-streams" ,sbcl-cl-octet-streams)
7059          ("lzlib" ,lzlib)))
7060       (arguments
7061        '(#:phases
7062          (modify-phases %standard-phases
7063            (add-after 'unpack 'fix-paths
7064              (lambda* (#:key inputs #:allow-other-keys)
7065                (substitute* "src/lzlib.lisp"
7066                  (("liblz\\.so")
7067                   (string-append (assoc-ref inputs "lzlib") "/lib/liblz.so")))
7068                #t)))))
7069       (synopsis "Common Lisp library for lzip (de)compression")
7070       (description
7071        "This Common Lisp library provides functions for lzip (LZMA)
7072 compression/decompression using bindings to the lzlib C library.")
7073       (home-page "https://github.com/glv2/cl-lzlib")
7074       (license license:gpl3+))))
7075
7076 (define-public cl-lzlib
7077   (sbcl-package->cl-source-package sbcl-lzlib))
7078
7079 (define-public ecl-lzlib
7080   (sbcl-package->ecl-package sbcl-lzlib))
7081
7082 (define-public sbcl-chanl
7083   (let ((commit "56e90a126c78b39bb621a01585e8d3b985238e8c")
7084         (revision "1"))
7085     (package
7086       (name "sbcl-chanl")
7087       (version (git-version "0.4.1" revision commit))
7088       (source
7089        (origin
7090          (method git-fetch)
7091          (uri (git-reference
7092                (url "https://github.com/zkat/chanl.git")
7093                (commit commit)))
7094          (file-name (git-file-name name version))
7095          (sha256
7096           (base32
7097            "0b1cf6c12qx5cy1fw2z42jgh566rp3l8nv5qf0qqc569s7bgmrh4"))))
7098       (build-system asdf-build-system/sbcl)
7099       (native-inputs
7100        `(("fiveam" ,sbcl-fiveam)))
7101       (inputs
7102        `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
7103       (synopsis "Portable channel-based concurrency for Common Lisp")
7104       (description "Common Lisp library for channel-based concurrency.  In
7105 a nutshell, you create various threads sequentially executing tasks you need
7106 done, and use channel objects to communicate and synchronize the state of these
7107 threads.")
7108       (home-page "https://github.com/zkat/chanl")
7109       (license (list license:expat license:bsd-3)))))
7110
7111 (define-public cl-chanl
7112   (sbcl-package->cl-source-package sbcl-chanl))
7113
7114 (define-public ecl-chanl
7115   (sbcl-package->ecl-package sbcl-chanl))
7116
7117 (define-public sbcl-cl-store
7118   (let ((commit "c787337a16ea8cf8a06227f35933a4ec774746b3")
7119         (revision "1"))
7120     (package
7121       (name "sbcl-cl-store")
7122       (version (git-version "0.8.11" revision commit))
7123       (source
7124        (origin
7125          (method git-fetch)
7126          (uri (git-reference
7127                (url "https://github.com/skypher/cl-store.git")
7128                (commit commit)))
7129          (file-name (git-file-name name version))
7130          (sha256
7131           (base32
7132            "194srkg8nrym19c6i7zbnkzshc1qhqa82m53qnkirz9fw928bqxr"))))
7133       (build-system asdf-build-system/sbcl)
7134       (native-inputs
7135        `(("rt" ,sbcl-rt)))
7136       (synopsis "Common Lisp library to serialize data")
7137       (description
7138        "CL-STORE is a portable serialization package which should give you the
7139 ability to store all Common Lisp data types into streams.")
7140       (home-page "https://www.common-lisp.net/project/cl-store/")
7141       (license license:expat))))
7142
7143 (define-public cl-store
7144   (sbcl-package->cl-source-package sbcl-cl-store))
7145
7146 (define-public ecl-cl-store
7147   (sbcl-package->ecl-package sbcl-cl-store))
7148
7149 (define-public sbcl-cl-gobject-introspection
7150   (let ((commit "7b703e2384945ea0ac39d9b766de434a08d81560")
7151         (revision "0"))
7152     (package
7153       (name "sbcl-cl-gobject-introspection")
7154       (version (git-version "0.3" revision commit))
7155       (home-page "https://github.com/andy128k/cl-gobject-introspection")
7156       (source
7157        (origin
7158          (method git-fetch)
7159          (uri (git-reference
7160                (url home-page)
7161                (commit commit)))
7162          (file-name (git-file-name name version))
7163          (sha256
7164           (base32
7165            "1zcqd2qj14f6b38vys8gr89s6cijsp9r8j43xa8lynilwva7bwyh"))))
7166       (build-system asdf-build-system/sbcl)
7167       (inputs
7168        `(("alexandria" ,sbcl-alexandria)
7169          ("cffi" ,sbcl-cffi)
7170          ("iterate" ,sbcl-iterate)
7171          ("trivial-garbage" ,sbcl-trivial-garbage)
7172          ("glib" ,glib)
7173          ("gobject-introspection" ,gobject-introspection)))
7174       (native-inputs
7175        `(("fiveam" ,sbcl-fiveam)))
7176       (arguments
7177        ;; TODO: Tests fail, see
7178        ;; https://github.com/andy128k/cl-gobject-introspection/issues/70.
7179        '(#:tests? #f
7180          #:phases
7181          (modify-phases %standard-phases
7182            (add-after (quote unpack) (quote fix-paths)
7183              (lambda* (#:key inputs #:allow-other-keys)
7184                (substitute* "src/init.lisp"
7185                  (("libgobject-2\\.0\\.so")
7186                   (string-append (assoc-ref inputs "glib") "/lib/libgobject-2.0.so"))
7187                  (("libgirepository-1\\.0\\.so")
7188                   (string-append (assoc-ref inputs "gobject-introspection")
7189                                  "/lib/libgirepository-1.0.so")))
7190                #t)))))
7191       (synopsis "Common Lisp bindings to GObject Introspection")
7192       (description
7193        "This library is a bridge between Common Lisp and GObject
7194 Introspection, which enables Common Lisp programs to access the full interface
7195 of C+GObject libraries without the need of writing dedicated bindings.")
7196       (license (list license:bsd-3
7197                      ;; Tests are under a different license.
7198                      license:llgpl)))))
7199
7200 (define-public cl-gobject-introspection
7201   (sbcl-package->cl-source-package sbcl-cl-gobject-introspection))
7202
7203 (define-public sbcl-string-case
7204   (let ((commit "718c761e33749e297cd2809c7ba3ade1985c49f7")
7205         (revision "0"))
7206     (package
7207       (name "sbcl-string-case")
7208       (version (git-version "0.0.2" revision commit))
7209       (home-page "https://github.com/pkhuong/string-case")
7210       (source
7211        (origin
7212          (method git-fetch)
7213          (uri (git-reference
7214                (url home-page)
7215                (commit commit)))
7216          (file-name (git-file-name name version))
7217          (sha256
7218           (base32
7219            "1n5i3yh0h5s636rcnwn7jwqy3rjflikra04lymimhpcshhjsk0md"))))
7220       (build-system asdf-build-system/sbcl)
7221       (synopsis "Efficient string= case in Common Lisp")
7222       (description
7223        "@code{string-case} is a Common Lisp macro that generates specialised decision
7224 trees to dispatch on string equality.")
7225       (license license:bsd-3))))
7226
7227 (define-public cl-string-case
7228   (sbcl-package->cl-source-package sbcl-string-case))
7229
7230 (define-public ecl-string-case
7231   (sbcl-package->ecl-package sbcl-string-case))
7232
7233 (define-public sbcl-global-vars
7234   (let ((commit "c749f32c9b606a1457daa47d59630708ac0c266e")
7235         (revision "0"))
7236     (package
7237       (name "sbcl-global-vars")
7238       (version (git-version "1.0.0" revision commit))
7239       (home-page "https://github.com/lmj/global-vars")
7240       (source
7241        (origin
7242          (method git-fetch)
7243          (uri (git-reference
7244                (url home-page)
7245                (commit commit)))
7246          (file-name (git-file-name name version))
7247          (sha256
7248           (base32
7249            "06m3xc8l3pgsapl8fvsi9wf6y46zs75cp9zn7zh6dc65v4s5wz3d"))))
7250       (build-system asdf-build-system/sbcl)
7251       (synopsis "Efficient global variables in Common Lisp")
7252       (description
7253        "In Common Lisp, a special variable that is never dynamically bound
7254 typically serves as a stand-in for a global variable.  The @code{global-vars}
7255 library provides true global variables that are implemented by some compilers.
7256 An attempt to rebind a global variable properly results in a compiler error.
7257 That is, a global variable cannot be dynamically bound.
7258
7259 Global variables therefore allow us to communicate an intended usage that
7260 differs from special variables.  Global variables are also more efficient than
7261 special variables, especially in the presence of threads.")
7262       (license license:expat))))
7263
7264 (define-public cl-global-vars
7265   (sbcl-package->cl-source-package sbcl-global-vars))
7266
7267 (define-public ecl-global-vars
7268   (sbcl-package->ecl-package sbcl-global-vars))
7269
7270 (define-public sbcl-trivial-file-size
7271   (let ((commit "1c1d672a01a446ba0391dbb4ffc40be3b0476f23")
7272         (revision "0"))
7273     (package
7274       (name "sbcl-trivial-file-size")
7275       (version (git-version "0.0.0" revision commit))
7276       (home-page "https://github.com/ruricolist/trivial-file-size")
7277       (source
7278        (origin
7279          (method git-fetch)
7280          (uri (git-reference
7281                (url home-page)
7282                (commit commit)))
7283          (file-name (git-file-name name version))
7284          (sha256
7285           (base32
7286            "17pp86c9zs4y7i1sh7q9gbfw9iqv6655k7fz8qbj9ly1ypgxp4qs"))))
7287       (build-system asdf-build-system/sbcl)
7288       (native-inputs
7289        `(("fiveam" ,sbcl-fiveam)))
7290       (synopsis "Size of a file in bytes in Common Lisp")
7291       (description
7292        "The canonical way to determine the size of a file in bytes, using Common Lisp,
7293 is to open the file with an element type of (unsigned-byte 8) and then
7294 calculate the length of the stream.  This is less than ideal.  In most cases
7295 it is better to get the size of the file from its metadata, using a system
7296 call.
7297
7298 This library exports a single function, file-size-in-octets.  It returns the
7299 size of a file in bytes, using system calls when possible.")
7300       (license license:expat))))
7301
7302 (define-public cl-trivial-file-size
7303   (sbcl-package->cl-source-package sbcl-trivial-file-size))
7304
7305 (define-public ecl-trivial-file-size
7306   (sbcl-package->ecl-package sbcl-trivial-file-size))
7307
7308 (define-public sbcl-trivial-macroexpand-all
7309   (let ((commit "933270ac7107477de1bc92c1fd641fe646a7a8a9")
7310         (revision "0"))
7311     (package
7312       (name "sbcl-trivial-macroexpand-all")
7313       (version (git-version "0.0.0" revision commit))
7314       (home-page "https://github.com/cbaggers/trivial-macroexpand-all")
7315       (source
7316        (origin
7317          (method git-fetch)
7318          (uri (git-reference
7319                (url home-page)
7320                (commit commit)))
7321          (file-name (git-file-name name version))
7322          (sha256
7323           (base32
7324            "191hnn4b5j4i3crydmlzbm231kj0h7l8zj6mzj69r1npbzkas4bd"))))
7325       (build-system asdf-build-system/sbcl)
7326       (native-inputs
7327        `(("fiveam" ,sbcl-fiveam)))
7328       (synopsis "Portable macroexpand-all for Common Lisp")
7329       (description
7330        "This library provides a macroexpand-all function that calls the
7331 implementation specific equivalent.")
7332       (license license:unlicense))))
7333
7334 (define-public cl-trivial-macroexpand-all
7335   (sbcl-package->cl-source-package sbcl-trivial-macroexpand-all))
7336
7337 (define-public ecl-trivial-macroexpand-all
7338   (sbcl-package->ecl-package sbcl-trivial-macroexpand-all))
7339
7340 (define-public sbcl-serapeum
7341   (let ((commit "64f0c4a161bbbda7c275012ca1415b4293b9e169")
7342         (revision "1"))
7343     (package
7344       (name "sbcl-serapeum")
7345       (version (git-version "0.0.0" revision commit))
7346       (home-page "https://github.com/ruricolist/serapeum")
7347       (source
7348        (origin
7349          (method git-fetch)
7350          (uri (git-reference
7351                (url home-page)
7352                (commit commit)))
7353          (file-name (git-file-name name version))
7354          (sha256
7355           (base32
7356            "0djnj0py8hdjnk5j6shjq2kbmyxqd5sw79cilcfmpfz4dzjdgkx9"))))
7357       (build-system asdf-build-system/sbcl)
7358       (inputs
7359        `(("alexandria" ,sbcl-alexandria)
7360          ("trivia" ,sbcl-trivia)
7361          ("trivia.quasiquote" ,sbcl-trivia.quasiquote)
7362          ("split-sequence" ,sbcl-split-sequence)
7363          ("string-case" ,sbcl-string-case)
7364          ("parse-number" ,sbcl-parse-number)
7365          ("trivial-garbage" ,sbcl-trivial-garbage)
7366          ("bordeaux-threads" ,sbcl-bordeaux-threads)
7367          ("named-readtables" ,sbcl-named-readtables)
7368          ("fare-quasiquote-extras" ,sbcl-fare-quasiquote-extras)
7369          ("parse-declarations-1.0" ,sbcl-parse-declarations)
7370          ("global-vars" ,sbcl-global-vars)
7371          ("trivial-file-size" ,sbcl-trivial-file-size)
7372          ("trivial-macroexpand-all" ,sbcl-trivial-macroexpand-all)))
7373       (native-inputs
7374        `(("fiveam" ,sbcl-fiveam)
7375          ("local-time" ,sbcl-local-time)))
7376       (arguments
7377        '(#:phases
7378          (modify-phases %standard-phases
7379            (add-after 'unpack 'disable-failing-tests
7380              (lambda* (#:key inputs #:allow-other-keys)
7381                (substitute* "serapeum.asd"
7382                  ;; Guix does not have Quicklisp, and probably never will.
7383                  (("\\(:file \"quicklisp\"\\)") ""))
7384                #t)))))
7385       (synopsis "Common Lisp utility library beyond Alexandria")
7386       (description
7387        "Serapeum is a conservative library of Common Lisp utilities.  It is a
7388 supplement, not a competitor, to Alexandria.")
7389       (license license:expat))))
7390
7391 (define-public cl-serapeum
7392   (sbcl-package->cl-source-package sbcl-serapeum))
7393
7394 (define-public sbcl-arrows
7395   (let ((commit "df7cf0067e0132d9697ac8b1a4f1b9c88d4f5382")
7396         (revision "0"))
7397     (package
7398       (name "sbcl-arrows")
7399       (version (git-version "0.2.0" revision commit))
7400       (source
7401        (origin
7402          (method git-fetch)
7403          (uri (git-reference
7404                (url "https://gitlab.com/Harleqin/arrows.git")
7405                (commit commit)))
7406          (file-name (git-file-name name version))
7407          (sha256
7408           (base32
7409            "042k9vkssrqx9nhp14wdzm942zgdxvp35mba0p2syz98i75im2yy"))))
7410       (build-system asdf-build-system/sbcl)
7411       (native-inputs
7412        `(("hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
7413       (synopsis "Clojure-like arrow macros for Common Lisp")
7414       (description
7415        "This library implements the @code{->} and @code{->>} macros from
7416 Clojure, as well as several expansions on the idea.")
7417       (home-page "https://gitlab.com/Harleqin/arrows")
7418       (license license:public-domain))))
7419
7420 (define-public cl-arrows
7421   (sbcl-package->cl-source-package sbcl-arrows))
7422
7423 (define-public ecl-arrows
7424   (sbcl-package->ecl-package sbcl-arrows))
7425
7426 (define-public sbcl-simple-parallel-tasks
7427   (let ((commit "db460f7a3f7bbfe2d3a2223ed21e162068d04dda")
7428         (revision "0"))
7429     (package
7430       (name "sbcl-simple-parallel-tasks")
7431       (version (git-version "1.0" revision commit))
7432       (source
7433        (origin
7434          (method git-fetch)
7435          (uri (git-reference
7436                (url "https://github.com/glv2/simple-parallel-tasks.git")
7437                (commit commit)))
7438          (file-name (git-file-name name version))
7439          (sha256
7440           (base32
7441            "0amw3qk23wnlyrsgzszs6rs7y4zvxv8dr03rnqhc60mnm8ds4dd5"))))
7442       (build-system asdf-build-system/sbcl)
7443       (native-inputs
7444        `(("fiveam" ,sbcl-fiveam)))
7445       (inputs
7446        `(("chanl" ,sbcl-chanl)))
7447       (synopsis "Common Lisp library to evaluate some forms in parallel")
7448       (description "This is a simple Common Lisp library to evaluate some
7449 forms in parallel.")
7450       (home-page "https://github.com/glv2/simple-parallel-tasks")
7451       (license license:gpl3))))
7452
7453 (define-public cl-simple-parallel-tasks
7454   (sbcl-package->cl-source-package sbcl-simple-parallel-tasks))
7455
7456 (define-public ecl-simple-parallel-tasks
7457   (sbcl-package->ecl-package sbcl-simple-parallel-tasks))
7458
7459 (define-public sbcl-cl-heap
7460   (package
7461     (name "sbcl-cl-heap")
7462     (version "0.1.6")
7463     (source
7464      (origin
7465        (method url-fetch)
7466        (uri (string-append "https://common-lisp.net/project/cl-heap/releases/"
7467                            "cl-heap_" version ".tar.gz"))
7468        (sha256
7469         (base32
7470          "163hb07p2nxz126rpq3cj5dyala24n0by5i5786n2qcr1w0bak4i"))))
7471     (build-system asdf-build-system/sbcl)
7472     (native-inputs
7473      `(("xlunit" ,sbcl-xlunit)))
7474     (arguments
7475      `(#:test-asd-file "cl-heap-tests.asd"))
7476     (synopsis "Heap and priority queue data structures for Common Lisp")
7477     (description
7478      "CL-HEAP provides various implementations of heap data structures (a
7479 binary heap and a Fibonacci heap) as well as an efficient priority queue.")
7480     (home-page "https://common-lisp.net/project/cl-heap/")
7481     (license license:gpl3+)))
7482
7483 (define-public cl-heap
7484   (sbcl-package->cl-source-package sbcl-cl-heap))
7485
7486 (define-public ecl-cl-heap
7487   (sbcl-package->ecl-package sbcl-cl-heap))
7488
7489 (define-public sbcl-curry-compose-reader-macros
7490   (let ((commit "beaa92dedf392726c042184bfd6149fa8d9e6ac2")
7491         (revision "0"))
7492     (package
7493       (name "sbcl-curry-compose-reader-macros")
7494       (version (git-version "1.0.0" revision commit))
7495       (source
7496        (origin
7497          (method git-fetch)
7498          (uri
7499           (git-reference
7500            (url "https://github.com/eschulte/curry-compose-reader-macros.git")
7501            (commit commit)))
7502          (file-name (git-file-name name version))
7503          (sha256
7504           (base32
7505            "0rv9bl8xrad5wfcg5zs1dazvnpmvqz6297lbn8bywsrcfnlf7h98"))))
7506       (build-system asdf-build-system/sbcl)
7507       (inputs
7508        `(("alexandria" ,sbcl-alexandria)
7509          ("named-readtables" ,sbcl-named-readtables)))
7510       (synopsis "Reader macros for partial application and composition")
7511       (description
7512        "This Common Lisp library provides reader macros for concise expression
7513 of function partial application and composition.")
7514       (home-page "https://eschulte.github.io/curry-compose-reader-macros/")
7515       (license license:public-domain))))
7516
7517 (define-public cl-curry-compose-reader-macros
7518   (sbcl-package->cl-source-package sbcl-curry-compose-reader-macros))
7519
7520 (define-public ecl-curry-compose-reader-macros
7521   (sbcl-package->ecl-package sbcl-curry-compose-reader-macros))
7522
7523 (define-public sbcl-yason
7524   (package
7525     (name "sbcl-yason")
7526     (version "0.7.7")
7527     (source
7528      (origin
7529        (method git-fetch)
7530        (uri (git-reference
7531              (url "https://github.com/phmarek/yason.git")
7532              (commit (string-append "v" version))))
7533        (file-name (git-file-name name version))
7534        (sha256
7535         (base32
7536          "0479rbjgbj80jpk5bby18inlv1kfp771a82rlcq5psrz65qqa9bj"))))
7537     (build-system asdf-build-system/sbcl)
7538     (inputs
7539      `(("alexandria" ,sbcl-alexandria)
7540        ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
7541     (synopsis "Common Lisp JSON parser/encoder")
7542     (description
7543      "YASON is a Common Lisp library for encoding and decoding data in the
7544 JSON interchange format.")
7545     (home-page "https://github.com/phmarek/yason")
7546     (license license:bsd-3)))
7547
7548 (define-public cl-yason
7549   (sbcl-package->cl-source-package sbcl-yason))
7550
7551 (define-public ecl-yason
7552   (sbcl-package->ecl-package sbcl-yason))
7553
7554 (define-public sbcl-stefil
7555   (let ((commit "0398548ec95dceb50fc2c2c03e5fb0ce49b86c7a")
7556         (revision "0"))
7557     (package
7558       (name "sbcl-stefil")
7559       (version (git-version "0.1" revision commit))
7560       (source
7561        (origin
7562          (method git-fetch)
7563          (uri (git-reference
7564                (url "https://gitlab.common-lisp.net/stefil/stefil.git")
7565                (commit commit)))
7566          (file-name (git-file-name name version))
7567          (sha256
7568           (base32
7569            "0bqz64q2szzhf91zyqyssmvrz7da6442rs01808pf3wrdq28bclh"))))
7570       (build-system asdf-build-system/sbcl)
7571       (inputs
7572        `(("alexandria" ,sbcl-alexandria)
7573          ("iterate" ,sbcl-iterate)
7574          ("metabang-bind" ,sbcl-metabang-bind)))
7575       (propagated-inputs
7576        ;; Swank doesn't have a pre-compiled package, therefore we must
7577        ;; propagate its sources.
7578        `(("swank" ,cl-slime-swank)))
7579       (arguments
7580        '(#:phases
7581          (modify-phases %standard-phases
7582            (add-after 'unpack 'drop-unnecessary-dependency
7583              (lambda _
7584                (substitute* "package.lisp"
7585                  ((":stefil-system") ""))
7586                #t)))))
7587       (home-page "https://common-lisp.net/project/stefil/index-old.shtml")
7588       (synopsis "Simple test framework")
7589       (description
7590        "Stefil is a simple test framework for Common Lisp, with a focus on
7591 interactive development.")
7592       (license license:public-domain))))
7593
7594 (define-public cl-stefil
7595   (sbcl-package->cl-source-package sbcl-stefil))
7596
7597 (define-public sbcl-graph
7598   (let ((commit "78bf9ec930d8eae4f0861b5be76765fb1e45e24f")
7599         (revision "0"))
7600     (package
7601       (name "sbcl-graph")
7602       (version (git-version "0.0.0" revision commit))
7603       (source
7604        (origin
7605          (method git-fetch)
7606          (uri
7607           (git-reference
7608            (url "https://github.com/eschulte/graph.git")
7609            (commit commit)))
7610          (file-name (git-file-name name version))
7611          (sha256
7612           (base32
7613            "1qpij4xh8bqwc2myahpilcbh916v7vg0acz2fij14d3y0jm02h0g"))
7614          (patches (search-patches "sbcl-graph-asdf-definitions.patch"))))
7615       (build-system asdf-build-system/sbcl)
7616       (native-inputs
7617        `(("stefil" ,sbcl-stefil)))
7618       (inputs
7619        `(("alexandria" ,sbcl-alexandria)
7620          ("cl-heap" ,sbcl-cl-heap)
7621          ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
7622          ("metabang-bind" ,sbcl-metabang-bind)
7623          ("named-readtables" ,sbcl-named-readtables)))
7624       (arguments
7625        '(#:test-asd-file "graph-test.asd"))
7626       (synopsis "Graph data structure and algorithms for Common Lisp")
7627       (description
7628        "The GRAPH Common Lisp library provides a data structures to represent
7629 graphs, as well as some graph manipulation and analysis algorithms (shortest
7630 path, maximum flow, minimum spanning tree, etc.).")
7631       (home-page "https://eschulte.github.io/graph/")
7632       (license license:gpl3+))))
7633
7634 (define-public cl-graph
7635   (sbcl-package->cl-source-package sbcl-graph))
7636
7637 (define-public sbcl-graph-dot
7638   (package
7639     (inherit sbcl-graph)
7640     (name "sbcl-graph-dot")
7641     (inputs
7642      `(("alexandria" ,sbcl-alexandria)
7643        ("cl-ppcre" ,sbcl-cl-ppcre)
7644        ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
7645        ("graph" ,sbcl-graph)
7646        ("metabang-bind" ,sbcl-metabang-bind)
7647        ("named-readtables" ,sbcl-named-readtables)))
7648     (arguments
7649      (substitute-keyword-arguments (package-arguments sbcl-graph)
7650        ((#:asd-file _ "") "graph-dot.asd")
7651        ((#:asd-system-name _ #f) "graph-dot")))
7652     (synopsis "Serialize graphs to and from DOT format")))
7653
7654 (define-public sbcl-graph-json
7655   (package
7656     (inherit sbcl-graph)
7657     (name "sbcl-graph-json")
7658     (inputs
7659      `(("alexandria" ,sbcl-alexandria)
7660        ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
7661        ("graph" ,sbcl-graph)
7662        ("metabang-bind" ,sbcl-metabang-bind)
7663        ("named-readtables" ,sbcl-named-readtables)
7664        ("yason" ,sbcl-yason)))
7665     (arguments
7666      (substitute-keyword-arguments (package-arguments sbcl-graph)
7667        ((#:asd-file _ "") "graph-json.asd")
7668        ((#:asd-system-name _ #f) "graph-json")))
7669     (synopsis "Serialize graphs to and from JSON format")))
7670
7671 (define-public sbcl-trivial-indent
7672   (let ((commit "2d016941751647c6cc5bd471751c2cf68861c94a")
7673         (revision "0"))
7674     (package
7675       (name "sbcl-trivial-indent")
7676       (version (git-version "1.0.0" revision commit))
7677       (source
7678        (origin
7679          (method git-fetch)
7680          (uri
7681           (git-reference
7682            (url "https://github.com/Shinmera/trivial-indent")
7683            (commit commit)))
7684          (file-name (git-file-name name version))
7685          (sha256
7686           (base32
7687            "1sj90nqz17w4jq0ixz00gb9g5g6d2s7l8r17zdby27gxxh51w266"))))
7688       (build-system asdf-build-system/sbcl)
7689       (synopsis "Simple Common Lisp library to allow indentation hints for SWANK")
7690       (description
7691        "This library allows you to define custom indentation hints for your
7692 macros if the one recognised by SLIME automatically produces unwanted
7693 results.")
7694       (home-page "https://shinmera.github.io/trivial-indent/")
7695       (license license:zlib))))
7696
7697 (define-public cl-trivial-indent
7698   (sbcl-package->cl-source-package sbcl-trivial-indent))
7699
7700 (define-public sbcl-documentation-utils
7701   (let ((commit "98630dd5f7e36ae057fa09da3523f42ccb5d1f55")
7702         (revision "0"))
7703     (package
7704       (name "sbcl-documentation-utils")
7705       (version (git-version "1.2.0" revision commit))
7706       (source
7707        (origin
7708          (method git-fetch)
7709          (uri
7710           (git-reference
7711            (url "https://github.com/Shinmera/documentation-utils.git")
7712            (commit commit)))
7713          (file-name (git-file-name name version))
7714          (sha256
7715           (base32
7716            "098qhkqskmmrh4wix34mawf7p5c87yql28r51r75yjxj577k5idq"))))
7717       (build-system asdf-build-system/sbcl)
7718       (inputs
7719        `(("trivial-indent" ,sbcl-trivial-indent)))
7720       (synopsis "Few simple tools to document Common Lisp libraries")
7721       (description
7722        "This is a small library to help you with managing the Common Lisp
7723 docstrings for your library.")
7724       (home-page "https://shinmera.github.io/documentation-utils/")
7725       (license license:zlib))))
7726
7727 (define-public cl-documentation-utils
7728   (sbcl-package->cl-source-package sbcl-documentation-utils))
7729
7730 (define-public ecl-documentation-utils
7731   (sbcl-package->ecl-package sbcl-documentation-utils))
7732
7733 (define-public sbcl-form-fiddle
7734   (let ((commit "e0c23599dbb8cff3e83e012f3d86d0764188ad18")
7735         (revision "0"))
7736     (package
7737       (name "sbcl-form-fiddle")
7738       (version (git-version "1.1.0" revision commit))
7739       (source
7740        (origin
7741          (method git-fetch)
7742          (uri
7743           (git-reference
7744            (url "https://github.com/Shinmera/form-fiddle")
7745            (commit commit)))
7746          (file-name (git-file-name name version))
7747          (sha256
7748           (base32
7749            "041iznc9mpfyrl0sv5893ys9pbb2pvbn9g3clarqi7gsfj483jln"))))
7750       (build-system asdf-build-system/sbcl)
7751       (inputs
7752        `(("documentation-utils" ,sbcl-documentation-utils)))
7753       (synopsis "Utilities to destructure Common Lisp lambda forms")
7754       (description
7755        "Often times we need to destructure a form definition in a Common Lisp
7756 macro.  This library provides a set of simple utilities to help with that.")
7757       (home-page "https://shinmera.github.io/form-fiddle/")
7758       (license license:zlib))))
7759
7760 (define-public cl-form-fiddle
7761   (sbcl-package->cl-source-package sbcl-form-fiddle))
7762
7763 (define-public sbcl-parachute
7764   (let ((commit "ca04dd8e43010a6dfffa26dbe1d62af86008d666")
7765         (revision "0"))
7766     (package
7767       (name "sbcl-parachute")
7768       (version (git-version "1.1.1" revision commit))
7769       (source
7770        (origin
7771          (method git-fetch)
7772          (uri
7773           (git-reference
7774            (url "https://github.com/Shinmera/parachute")
7775            (commit commit)))
7776          (file-name (git-file-name name version))
7777          (sha256
7778           (base32
7779            "1mvsm3r0r6a2bg75nw0q7n9vlby3ch45qjl7hnb5k1z2n5x5lh60"))))
7780       (build-system asdf-build-system/sbcl)
7781       (inputs
7782        `(("documentation-utils" ,sbcl-documentation-utils)
7783          ("form-fiddle" ,sbcl-form-fiddle)))
7784       (synopsis "Extensible and cross-compatible testing framework for Common Lisp")
7785       (description
7786        "Parachute is a simple-to-use and extensible testing framework.
7787 In Parachute, things are organised as a bunch of named tests within a package.
7788 Each test can contain a bunch of test forms that make up its body.")
7789       (home-page "https://shinmera.github.io/parachute/")
7790       (license license:zlib))))
7791
7792 (define-public cl-parachute
7793   (sbcl-package->cl-source-package sbcl-parachute))
7794
7795 (define-public sbcl-array-utils
7796   (let ((commit "f90eb9070d0b2205af51126a35033574725e5c56")
7797         (revision "0"))
7798     (package
7799       (name "sbcl-array-utils")
7800       (version (git-version "1.1.1" revision commit))
7801       (source
7802        (origin
7803          (method git-fetch)
7804          (uri
7805           (git-reference
7806            (url "https://github.com/Shinmera/array-utils")
7807            (commit commit)))
7808          (file-name (git-file-name name version))
7809          (sha256
7810           (base32
7811            "0zhwfbpr53vs1ii4sx75dz2k9yhh1xpwdqqpg8nmfndxkmhpbi3x"))))
7812       (build-system asdf-build-system/sbcl)
7813       (native-inputs
7814        `(("parachute" ,sbcl-parachute)))
7815       (inputs
7816        `(("documentation-utils" ,sbcl-documentation-utils)))
7817       (synopsis "Tiny collection of array and vector utilities for Common Lisp")
7818       (description
7819        "A miniature toolkit that contains some useful shifting/popping/pushing
7820 functions for arrays and vectors.  Originally from Plump.")
7821       (home-page "https://shinmera.github.io/array-utils/")
7822       (license license:zlib))))
7823
7824 (define-public cl-array-utils
7825   (sbcl-package->cl-source-package sbcl-array-utils))
7826
7827 (define-public sbcl-plump
7828   (let ((commit "16f1231bf706cfbc54d9e55a853ca945e4452a08")
7829         (revision "0"))
7830     (package
7831       (name "sbcl-plump")
7832       (version (git-version "2.0.0" revision commit))
7833       (source
7834        (origin
7835          (method git-fetch)
7836          (uri
7837           (git-reference
7838            (url "https://github.com/Shinmera/plump")
7839            (commit commit)))
7840          (file-name (git-file-name name version))
7841          (sha256
7842           (base32
7843            "0705k8pbip51v74rccgwscwph439f2pma9f915qf1h4bhjx999ip"))))
7844       (build-system asdf-build-system/sbcl)
7845       (inputs
7846        `(("array-utils" ,sbcl-array-utils)
7847          ("documentation-utils" ,sbcl-documentation-utils)))
7848       (synopsis "Lenient XML / XHTML / HTML parser for Common Lisp")
7849       (description
7850        "Plump is a parser for HTML/XML-like documents, focusing on being
7851 lenient towards invalid markup.  It can handle things like invalid attributes,
7852 bad closing tag order, unencoded entities, inexistent tag types, self-closing
7853 tags and so on.  It parses documents to a class representation and offers a
7854 small set of DOM functions to manipulate it.  It can be extended to parse to
7855 your own classes.")
7856       (home-page "https://shinmera.github.io/plump/")
7857       (license license:zlib))))
7858
7859 (define-public cl-plump
7860   (sbcl-package->cl-source-package sbcl-plump))
7861
7862 (define-public sbcl-antik-base
7863   (let ((commit "e4711a69b3d6bf37b5727af05c3cfd03e8428ba3")
7864         (revision "1"))
7865     (package
7866       (name "sbcl-antik-base")
7867       (version (git-version "0.0.0" revision commit))
7868       (source
7869        (origin
7870          (method git-fetch)
7871          (uri (git-reference
7872                (url "https://gitlab.common-lisp.net/antik/antik.git")
7873                (commit commit)))
7874          (file-name (git-file-name name version))
7875          (sha256
7876           (base32
7877            "047ga2c38par2xbgg4qx6hwv06qhf1c1f67as8xvir6s80lip1km"))))
7878       (build-system asdf-build-system/sbcl)
7879       (inputs
7880        `(("alexandria" ,sbcl-alexandria)
7881          ("cl-ppcre" ,sbcl-cl-ppcre)
7882          ("iterate" ,sbcl-iterate)
7883          ("metabang-bind" ,sbcl-metabang-bind)
7884          ("named-readtables" ,sbcl-named-readtables)
7885          ("split-sequence" ,sbcl-split-sequence)))
7886       (native-inputs
7887        `(("lisp-unit" ,sbcl-lisp-unit)))
7888       (synopsis "Scientific and engineering computation in Common Lisp")
7889       (description
7890        "Antik provides a foundation for scientific and engineering
7891 computation in Common Lisp.  It is designed not only to facilitate
7892 numerical computations, but to permit the use of numerical computation
7893 libraries and the interchange of data and procedures, whether
7894 foreign (non-Lisp) or Lisp libraries.  It is named after the
7895 Antikythera mechanism, one of the oldest examples of a scientific
7896 computer known.")
7897       (home-page "https://common-lisp.net/project/antik/")
7898       (license license:gpl3))))
7899
7900 (define-public cl-antik-base
7901   (sbcl-package->cl-source-package sbcl-antik-base))
7902
7903 (define-public ecl-antik-base
7904   (sbcl-package->ecl-package sbcl-antik-base))
7905
7906 (define-public sbcl-foreign-array
7907   (package
7908     (inherit sbcl-antik-base)
7909     (name "sbcl-foreign-array")
7910     (arguments
7911      (substitute-keyword-arguments (package-arguments sbcl-antik-base)
7912        ((#:asd-file _ "") "foreign-array.asd")
7913        ((#:asd-system-name _ #f) "foreign-array")))
7914     (inputs
7915      `(("antik-base" ,sbcl-antik-base)
7916        ("cffi" ,sbcl-cffi)
7917        ("trivial-garbage" ,sbcl-trivial-garbage)
7918        ("static-vectors" ,sbcl-static-vectors)))
7919     (synopsis "Common Lisp library providing access to foreign arrays")))
7920
7921 (define-public cl-foreign-array
7922   (sbcl-package->cl-source-package sbcl-foreign-array))
7923
7924 (define-public ecl-foreign-array
7925   (sbcl-package->ecl-package sbcl-foreign-array))
7926
7927 (define-public sbcl-physical-dimension
7928   (package
7929     (inherit sbcl-antik-base)
7930     (name "sbcl-physical-dimension")
7931     (inputs
7932      `(("fare-utils" ,sbcl-fare-utils)
7933        ("foreign-array" ,sbcl-foreign-array)
7934        ("trivial-utf-8" ,sbcl-trivial-utf-8)))
7935     (arguments
7936      (substitute-keyword-arguments (package-arguments sbcl-antik-base)
7937        ((#:asd-file _ "") "physical-dimension.asd")
7938        ((#:asd-system-name _ #f) "physical-dimension")))
7939     (synopsis
7940      "Common Lisp library providing computations with physical units")))
7941
7942 (define-public cl-physical-dimension
7943   (sbcl-package->cl-source-package sbcl-physical-dimension))
7944
7945 (define-public sbcl-science-data
7946   (package
7947     (inherit sbcl-antik-base)
7948     (name "sbcl-science-data")
7949     (inputs
7950      `(("physical-dimension" ,sbcl-physical-dimension)
7951        ("drakma" ,sbcl-drakma)))
7952     (arguments
7953      (substitute-keyword-arguments (package-arguments sbcl-antik-base)
7954        ((#:asd-file _ "") "science-data.asd")
7955        ((#:asd-system-name _ #f) "science-data")))
7956     (synopsis
7957      "Common Lisp library for scientific and engineering numerical data")))
7958
7959 (define-public cl-science-data
7960   (sbcl-package->cl-source-package sbcl-science-data))
7961
7962 (define-public sbcl-gsll
7963   (let ((commit "1a8ada22f9cf5ed7372d352b2317f4ccdb6ab308")
7964         (revision "1"))
7965     (package
7966       (name "sbcl-gsll")
7967       (version (git-version "0.0.0" revision commit))
7968       (source
7969        (origin
7970          (method git-fetch)
7971          (uri (git-reference
7972                (url "https://gitlab.common-lisp.net/antik/gsll.git")
7973                (commit commit)))
7974          (file-name (git-file-name name version))
7975          (sha256
7976           (base32
7977            "0z5nypfk26hxihb08p085644afawicrgb4xvadh3lmrn46qbjfn4"))))
7978       (build-system asdf-build-system/sbcl)
7979       (native-inputs
7980        `(("lisp-unit" ,sbcl-lisp-unit)))
7981       (inputs
7982        `(("alexandria" ,sbcl-alexandria)
7983          ("cffi-grovel" ,sbcl-cffi-grovel)
7984          ("cffi-libffi" ,sbcl-cffi-libffi)
7985          ("foreign-array" ,sbcl-foreign-array)
7986          ("gsl" ,gsl)
7987          ("metabang-bind" ,sbcl-metabang-bind)
7988          ("trivial-features" ,sbcl-trivial-features)
7989          ("trivial-garbage" ,sbcl-trivial-garbage)))
7990       (arguments
7991        `(#:tests? #f
7992          #:phases
7993          (modify-phases %standard-phases
7994            (add-after 'unpack 'fix-cffi-paths
7995              (lambda* (#:key inputs #:allow-other-keys)
7996                (substitute* "gsll.asd"
7997                  ((":depends-on \\(#:foreign-array")
7998                   ":depends-on (#:foreign-array #:cffi-libffi"))
7999                (substitute* "init/init.lisp"
8000                  (("libgslcblas.so" all)
8001                   (string-append
8002                    (assoc-ref inputs "gsl") "/lib/" all)))
8003                (substitute* "init/init.lisp"
8004                  (("libgsl.so" all)
8005                   (string-append
8006                    (assoc-ref inputs "gsl") "/lib/" all))))))))
8007       (synopsis "GNU Scientific Library for Lisp")
8008       (description
8009        "The GNU Scientific Library for Lisp (GSLL) allows the use of the
8010 GNU Scientific Library (GSL) from Common Lisp.  This library provides a
8011 full range of common mathematical operations useful to scientific and
8012 engineering applications.  The design of the GSLL interface is such
8013 that access to most of the GSL library is possible in a Lisp-natural
8014 way; the intent is that the user not be hampered by the restrictions
8015 of the C language in which GSL has been written.  GSLL thus provides
8016 interactive use of GSL for getting quick answers, even for someone not
8017 intending to program in Lisp.")
8018       (home-page "https://common-lisp.net/project/gsll/")
8019       (license license:gpl3))))
8020
8021 (define-public cl-gsll
8022   (sbcl-package->cl-source-package sbcl-gsll))
8023
8024 (define-public sbcl-antik
8025   (package
8026     (inherit sbcl-antik-base)
8027     (name "sbcl-antik")
8028     (inputs
8029      `(("gsll" ,sbcl-gsll)
8030        ("physical-dimension" ,sbcl-physical-dimension)))
8031     (arguments
8032      (substitute-keyword-arguments (package-arguments sbcl-antik-base)
8033        ((#:asd-file _ "") "antik.asd")
8034        ((#:asd-system-name _ #f) "antik")))))
8035
8036 (define-public cl-antik
8037   (sbcl-package->cl-source-package sbcl-antik))
8038
8039 (define-public sbcl-cl-interpol
8040   (let ((commit "1fd288d861db85bc4677cff3cdd6af75fda1afb4")
8041         (revision "1"))
8042     (package
8043       (name "sbcl-cl-interpol")
8044       (version (git-version "0.2.6" revision commit))
8045       (source
8046        (origin
8047          (method git-fetch)
8048          (uri (git-reference
8049                (url "https://github.com/edicl/cl-interpol.git")
8050                (commit commit)))
8051          (file-name (git-file-name name version))
8052          (sha256
8053           (base32
8054            "1hnikak52hmcq1r5f616m6qq1108qnkw80pja950nv1fq5p0ppjn"))))
8055       (build-system asdf-build-system/sbcl)
8056       (inputs
8057        `(("cl-unicode" ,sbcl-cl-unicode)
8058          ("named-readtables" ,sbcl-named-readtables)))
8059       (native-inputs
8060        `(("flexi-streams" ,sbcl-flexi-streams)))
8061       (synopsis "String interpolation for Common Lisp")
8062       (description
8063        "CL-INTERPOL is a library for Common Lisp which modifies the
8064 reader so that you can have interpolation within strings similar to
8065 Perl or Unix Shell scripts.  It also provides various ways to insert
8066 arbitrary characters into literal strings even if your editor/IDE
8067 doesn't support them.")
8068       (home-page "https://edicl.github.io/cl-interpol/")
8069       (license license:bsd-3))))
8070
8071 (define-public cl-interpol
8072   (sbcl-package->cl-source-package sbcl-cl-interpol))
8073
8074 (define-public ecl-cl-interpol
8075   (sbcl-package->ecl-package sbcl-cl-interpol))
8076
8077 (define sbcl-symbol-munger-boot0
8078   ;; There is a cyclical dependency between symbol-munger and lisp-unit2.
8079   ;; See https://github.com/AccelerationNet/symbol-munger/issues/4
8080   (let ((commit "cc2bb4b7acd454d756484aec81ba487648385fc3")
8081         (revision "1"))
8082     (package
8083       (name "sbcl-symbol-munger-boot0")
8084       (version (git-version "0.0.1" revision commit))
8085       (source
8086        (origin
8087          (method git-fetch)
8088          (uri (git-reference
8089                (url "https://github.com/AccelerationNet/symbol-munger.git")
8090                (commit commit)))
8091          (file-name (git-file-name name version))
8092          (sha256
8093           (base32
8094            "0diav5ricqsybqvbp4bkxyj3bn3v9n7xb2pqqc4vg1algsw2pyjl"))))
8095       (build-system asdf-build-system/sbcl)
8096       (arguments
8097        `(#:asd-file "symbol-munger.asd"
8098          #:asd-system-name "symbol-munger"))
8099       (inputs
8100        `(("iterate" ,sbcl-iterate)
8101          ("alexandria" ,sbcl-alexandria)))
8102       (native-inputs
8103        `(("lisp-unit" ,sbcl-lisp-unit)))
8104       (synopsis
8105        "Capitalization and spacing conversion functions for Common Lisp")
8106       (description
8107        "This is a Common Lisp library to change the capitalization and spacing
8108 of a string or a symbol.  It can convert to and from Lisp, english, underscore
8109 and camel-case rules.")
8110       (home-page "https://github.com/AccelerationNet/symbol-munger")
8111       ;; The package declares a BSD license, but all of the license
8112       ;; text is MIT.
8113       ;; See https://github.com/AccelerationNet/symbol-munger/issues/5
8114       (license license:expat))))
8115
8116 (define sbcl-lisp-unit2-boot0
8117   ;; There is a cyclical dependency between symbol-munger and lisp-unit2.
8118   ;; See https://github.com/AccelerationNet/symbol-munger/issues/4
8119   (let ((commit "fb9721524d1e4e73abb223ee036d74ce14a5505c")
8120         (revision "1"))
8121     (package
8122       (name "sbcl-lisp-unit2-boot0")
8123       (version (git-version "0.2.0" revision commit))
8124       (source
8125        (origin
8126          (method git-fetch)
8127          (uri (git-reference
8128                (url "https://github.com/AccelerationNet/lisp-unit2.git")
8129                (commit commit)))
8130          (file-name (git-file-name name version))
8131          (sha256
8132           (base32
8133            "1rsqy8y0jqll6xn9a593848f5wvd5ribv4csry1ly0hmdhfnqzlp"))))
8134       (build-system asdf-build-system/sbcl)
8135       (arguments
8136        `(#:asd-file "lisp-unit2.asd"
8137          #:asd-system-name "lisp-unit2"))
8138       (inputs
8139        `(("alexandria" ,sbcl-alexandria)
8140          ("cl-interpol" ,sbcl-cl-interpol)
8141          ("iterate" ,sbcl-iterate)
8142          ("symbol-munger-boot0" ,sbcl-symbol-munger-boot0)))
8143       (synopsis "Test Framework for Common Lisp")
8144       (description
8145        "LISP-UNIT2 is a Common Lisp library that supports unit testing in the
8146 style of JUnit for Java.  It is a new version of the lisp-unit library written
8147 by Chris Riesbeck.")
8148       (home-page "https://github.com/AccelerationNet/lisp-unit2")
8149       (license license:expat))))
8150
8151 (define-public sbcl-symbol-munger
8152   (let ((commit "97598d4c3c53fd5da72ab78908fbd5d8c7a13416")
8153         (revision "1"))
8154     (package
8155       (name "sbcl-symbol-munger")
8156       (version (git-version "0.0.1" revision commit))
8157       (source
8158        (origin
8159          (method git-fetch)
8160          (uri (git-reference
8161                (url "https://github.com/AccelerationNet/symbol-munger.git")
8162                (commit commit)))
8163          (file-name (git-file-name name version))
8164          (sha256
8165           (base32
8166            "0y8jywjy0ldyhp7bxf16fdvdd2qgqnd7nlhlqfpfnzxcqk4xy1km"))))
8167       (build-system asdf-build-system/sbcl)
8168       (inputs
8169        `(("alexandria" ,sbcl-alexandria)
8170          ("iterate" ,sbcl-iterate)))
8171       (native-inputs
8172        `(("lisp-unit2-boot0" ,sbcl-lisp-unit2-boot0)))
8173       (synopsis
8174        "Capitalization and spacing conversion functions for Common Lisp")
8175       (description
8176        "This is a Common Lisp library to change the capitalization and spacing
8177 of a string or a symbol.  It can convert to and from Lisp, english, underscore
8178 and camel-case rules.")
8179       (home-page "https://github.com/AccelerationNet/symbol-munger")
8180       ;; The package declares a BSD license, but all of the license
8181       ;; text is MIT.
8182       ;; See https://github.com/AccelerationNet/symbol-munger/issues/5
8183       (license license:expat))))
8184
8185 (define-public cl-symbol-munger
8186   (sbcl-package->cl-source-package sbcl-symbol-munger))
8187
8188 (define-public ecl-symbol-munger
8189   (sbcl-package->ecl-package sbcl-symbol-munger))
8190
8191 (define-public sbcl-lisp-unit2
8192   (package
8193     (inherit sbcl-lisp-unit2-boot0)
8194     (name "sbcl-lisp-unit2")
8195     (inputs
8196      `(("alexandria" ,sbcl-alexandria)
8197        ("cl-interpol" ,sbcl-cl-interpol)
8198        ("iterate" ,sbcl-iterate)
8199        ("symbol-munger" ,sbcl-symbol-munger)))))
8200
8201 (define-public cl-lisp-unit2
8202   (sbcl-package->cl-source-package sbcl-lisp-unit2))
8203
8204 (define-public ecl-lisp-unit2
8205   (sbcl-package->ecl-package sbcl-lisp-unit2))
8206
8207 (define-public sbcl-cl-csv
8208   (let ((commit "3eba29c8364b033fbe0d189c2500559278b6a362")
8209         (revision "1"))
8210     (package
8211       (name "sbcl-cl-csv")
8212       (version (git-version "1.0.6" revision commit))
8213       (source
8214        (origin
8215          (method git-fetch)
8216          (uri (git-reference
8217                (url "https://github.com/AccelerationNet/cl-csv.git")
8218                (commit commit)))
8219          (file-name (git-file-name name version))
8220          (sha256
8221           (base32
8222            "07h4ni89jzx93clx453hlnnb5g53hhlcmz5hghqv6ysam48lc8g6"))))
8223       (build-system asdf-build-system/sbcl)
8224       (arguments
8225        ;; See: https://github.com/AccelerationNet/cl-csv/pull/34
8226        `(#:tests? #f))
8227       (inputs
8228        `(("alexandria" ,sbcl-alexandria)
8229          ("cl-interpol" ,sbcl-cl-interpol)
8230          ("iterate" ,sbcl-iterate)))
8231       (native-inputs
8232        `(("lisp-unit2" ,sbcl-lisp-unit2)))
8233       (synopsis "Common lisp library for comma-separated values")
8234       (description
8235        "This is a Common Lisp library providing functions to read/write CSV
8236 from/to strings, streams and files.")
8237       (home-page "https://github.com/AccelerationNet/cl-csv")
8238       (license license:bsd-3))))
8239
8240 (define-public cl-csv
8241   (sbcl-package->cl-source-package sbcl-cl-csv))
8242
8243 (define-public ecl-cl-csv
8244   (sbcl-package->ecl-package sbcl-cl-csv))
8245
8246 (define-public sbcl-external-program
8247   (let ((commit "5888b8f1fd3953feeeacecbba4384ddda584a749")
8248         (revision "1"))
8249     (package
8250       (name "sbcl-external-program")
8251       (version (git-version "0.0.6" revision commit))
8252       (source
8253        (origin
8254          (method git-fetch)
8255          (uri (git-reference
8256                (url "https://github.com/sellout/external-program.git")
8257                (commit commit)))
8258          (file-name (git-file-name name version))
8259          (sha256
8260           (base32
8261            "0vww1x3yilb3bjwg6k184vaj4vxyxw4vralhnlm6lk4xac67kc9z"))))
8262       (build-system asdf-build-system/sbcl)
8263       (inputs
8264        `(("trivial-features" ,sbcl-trivial-features)))
8265       (native-inputs
8266        `(("fiveam" ,sbcl-fiveam)))
8267       (synopsis "Common Lisp library for running external programs")
8268       (description
8269        "EXTERNAL-PROGRAM enables running programs outside the Lisp
8270 process.  It is an attempt to make the RUN-PROGRAM functionality in
8271 implementations like SBCL and CCL as portable as possible without
8272 sacrificing much in the way of power.")
8273       (home-page "https://github.com/sellout/external-program")
8274       (license license:llgpl))))
8275
8276 (define-public cl-external-program
8277   (sbcl-package->cl-source-package sbcl-external-program))
8278
8279 (define-public ecl-external-program
8280   (sbcl-package->ecl-package sbcl-external-program))
8281
8282 (define sbcl-cl-ana-boot0
8283   (let ((commit "fa7cee4c50aa1c859652813049ba0da7c18a0df9")
8284         (revision "1"))
8285     (package
8286      (name "sbcl-cl-ana-boot0")
8287      (version (git-version "0.0.0" revision commit))
8288      (source
8289       (origin
8290        (method git-fetch)
8291        (uri (git-reference
8292              (url "https://github.com/ghollisjr/cl-ana.git")
8293              (commit commit)))
8294        (file-name (git-file-name name version))
8295        (sha256
8296         (base32
8297          "0mr47l57m276dbpap7irr4fcnk5fgknhf6mgv4043s8h73amk5qh"))))
8298      (build-system asdf-build-system/sbcl)
8299      (synopsis "Common Lisp data analysis library")
8300      (description
8301       "CL-ANA is a data analysis library in Common Lisp providing tabular and
8302 binned data analysis along with nonlinear least squares fitting and
8303 visualization.")
8304      (home-page "https://github.com/ghollisjr/cl-ana")
8305      (license license:gpl3))))
8306
8307 (define-public sbcl-cl-ana.pathname-utils
8308   (package
8309     (inherit sbcl-cl-ana-boot0)
8310     (name "sbcl-cl-ana.pathname-utils")
8311     (arguments
8312      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8313        ((#:asd-file _ "") "pathname-utils/cl-ana.pathname-utils.asd")
8314        ((#:asd-system-name _ #f) "cl-ana.pathname-utils")))))
8315
8316 (define-public cl-ana.pathname-utils
8317   (sbcl-package->cl-source-package sbcl-cl-ana.pathname-utils))
8318
8319 (define-public ecl-cl-ana.pathname-utils
8320   (sbcl-package->ecl-package sbcl-cl-ana.pathname-utils))
8321
8322 (define-public sbcl-cl-ana.package-utils
8323   (package
8324     (inherit sbcl-cl-ana-boot0)
8325     (name "sbcl-cl-ana.package-utils")
8326     (inputs
8327      `(("alexandria" ,sbcl-alexandria)))
8328     (arguments
8329      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8330        ((#:asd-file _ "") "package-utils/cl-ana.package-utils.asd")
8331        ((#:asd-system-name _ #f) "cl-ana.package-utils")))))
8332
8333 (define-public cl-ana.package-utils
8334   (sbcl-package->cl-source-package sbcl-cl-ana.package-utils))
8335
8336 (define-public ecl-cl-ana.package-utils
8337   (sbcl-package->ecl-package sbcl-cl-ana.package-utils))
8338
8339 (define-public sbcl-cl-ana.string-utils
8340   (package
8341     (inherit sbcl-cl-ana-boot0)
8342     (name "sbcl-cl-ana.string-utils")
8343     (inputs
8344      `(("split-sequence" ,sbcl-split-sequence)))
8345     (arguments
8346      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8347        ((#:asd-file _ "") "string-utils/cl-ana.string-utils.asd")
8348        ((#:asd-system-name _ #f) "cl-ana.string-utils")))))
8349
8350 (define-public cl-ana.string-utils
8351   (sbcl-package->cl-source-package sbcl-cl-ana.string-utils))
8352
8353 (define-public ecl-cl-ana.string-utils
8354   (sbcl-package->ecl-package sbcl-cl-ana.string-utils))
8355
8356 (define-public sbcl-cl-ana.functional-utils
8357   (package
8358     (inherit sbcl-cl-ana-boot0)
8359     (name "sbcl-cl-ana.functional-utils")
8360     (arguments
8361      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8362        ((#:asd-file _ "") "functional-utils/cl-ana.functional-utils.asd")
8363        ((#:asd-system-name _ #f) "cl-ana.functional-utils")))))
8364
8365 (define-public cl-ana.functional-utils
8366   (sbcl-package->cl-source-package sbcl-cl-ana.functional-utils))
8367
8368 (define-public ecl-cl-ana.functional-utils
8369   (sbcl-package->ecl-package sbcl-cl-ana.functional-utils))
8370
8371 (define-public sbcl-cl-ana.list-utils
8372   (package
8373     (inherit sbcl-cl-ana-boot0)
8374     (name "sbcl-cl-ana.list-utils")
8375     (inputs
8376      `(("alexandria" ,sbcl-alexandria)
8377        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
8378        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)))
8379     (arguments
8380      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8381        ((#:asd-file _ "") "list-utils/cl-ana.list-utils.asd")
8382        ((#:asd-system-name _ #f) "cl-ana.list-utils")))))
8383
8384 (define-public cl-ana.list-utils
8385   (sbcl-package->cl-source-package sbcl-cl-ana.list-utils))
8386
8387 (define-public ecl-cl-ana.list-utils
8388   (sbcl-package->ecl-package sbcl-cl-ana.list-utils))
8389
8390 (define-public sbcl-cl-ana.generic-math
8391   (package
8392     (inherit sbcl-cl-ana-boot0)
8393     (name "sbcl-cl-ana.generic-math")
8394     (inputs
8395      `(("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8396        ("cl-ana.package-utils" ,sbcl-cl-ana.package-utils)))
8397     (arguments
8398      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8399        ((#:asd-file _ "") "generic-math/cl-ana.generic-math.asd")
8400        ((#:asd-system-name _ #f) "cl-ana.generic-math")))))
8401
8402 (define-public cl-ana.generic-math
8403   (sbcl-package->cl-source-package sbcl-cl-ana.generic-math))
8404
8405 (define-public ecl-cl-ana.generic-math
8406   (sbcl-package->ecl-package sbcl-cl-ana.generic-math))
8407
8408 (define-public sbcl-cl-ana.math-functions
8409   (package
8410     (inherit sbcl-cl-ana-boot0)
8411     (name "sbcl-cl-ana.math-functions")
8412     (inputs
8413      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8414        ("gsll" ,sbcl-gsll)))
8415     (arguments
8416      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8417        ((#:asd-file _ "") "math-functions/cl-ana.math-functions.asd")
8418        ((#:asd-system-name _ #f) "cl-ana.math-functions")))))
8419
8420 (define-public cl-ana.math-functions
8421   (sbcl-package->cl-source-package sbcl-cl-ana.math-functions))
8422
8423 (define-public sbcl-cl-ana.calculus
8424   (package
8425     (inherit sbcl-cl-ana-boot0)
8426     (name "sbcl-cl-ana.calculus")
8427     (inputs
8428      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)))
8429     (arguments
8430      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8431        ((#:asd-file _ "") "calculus/cl-ana.calculus.asd")
8432        ((#:asd-system-name _ #f) "cl-ana.calculus")))))
8433
8434 (define-public cl-ana.calculus
8435   (sbcl-package->cl-source-package sbcl-cl-ana.calculus))
8436
8437 (define-public ecl-cl-ana.calculus
8438   (sbcl-package->ecl-package sbcl-cl-ana.calculus))
8439
8440 (define-public sbcl-cl-ana.symbol-utils
8441   (package
8442     (inherit sbcl-cl-ana-boot0)
8443     (name "sbcl-cl-ana.symbol-utils")
8444     (inputs
8445      `(("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)))
8446     (arguments
8447      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8448        ((#:asd-file _ "") "symbol-utils/cl-ana.symbol-utils.asd")
8449        ((#:asd-system-name _ #f) "cl-ana.symbol-utils")))))
8450
8451 (define-public cl-ana.symbol-utils
8452   (sbcl-package->cl-source-package sbcl-cl-ana.symbol-utils))
8453
8454 (define-public ecl-cl-ana.symbol-utils
8455   (sbcl-package->ecl-package sbcl-cl-ana.symbol-utils))
8456
8457 (define-public sbcl-cl-ana.macro-utils
8458   (package
8459     (inherit sbcl-cl-ana-boot0)
8460     (name "sbcl-cl-ana.macro-utils")
8461     (inputs
8462      `(("alexandria" ,sbcl-alexandria)
8463        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8464        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8465        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8466        ("split-sequence" ,sbcl-split-sequence)))
8467     (arguments
8468      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8469        ((#:asd-file _ "") "macro-utils/cl-ana.macro-utils.asd")
8470        ((#:asd-system-name _ #f) "cl-ana.macro-utils")))))
8471
8472 (define-public cl-ana.macro-utils
8473   (sbcl-package->cl-source-package sbcl-cl-ana.macro-utils))
8474
8475 (define-public ecl-cl-ana.macro-utils
8476   (sbcl-package->ecl-package sbcl-cl-ana.macro-utils))
8477
8478 (define-public sbcl-cl-ana.binary-tree
8479   (package
8480     (inherit sbcl-cl-ana-boot0)
8481     (name "sbcl-cl-ana.binary-tree")
8482     (inputs
8483      `(("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
8484        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8485        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)))
8486     (arguments
8487      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8488        ((#:asd-file _ "") "binary-tree/cl-ana.binary-tree.asd")
8489        ((#:asd-system-name _ #f) "cl-ana.binary-tree")))))
8490
8491 (define-public cl-ana.binary-tree
8492   (sbcl-package->cl-source-package sbcl-cl-ana.binary-tree))
8493
8494 (define-public ecl-cl-ana.binary-tree
8495   (sbcl-package->ecl-package sbcl-cl-ana.binary-tree))
8496
8497 (define-public sbcl-cl-ana.tensor
8498   (package
8499     (inherit sbcl-cl-ana-boot0)
8500     (name "sbcl-cl-ana.tensor")
8501     (inputs
8502      `(("alexandria" ,sbcl-alexandria)
8503        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8504        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8505        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8506        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)))
8507     (arguments
8508      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8509        ((#:asd-file _ "") "tensor/cl-ana.tensor.asd")
8510        ((#:asd-system-name _ #f) "cl-ana.tensor")))))
8511
8512 (define-public cl-ana.tensor
8513   (sbcl-package->cl-source-package sbcl-cl-ana.tensor))
8514
8515 (define-public ecl-cl-ana.tensor
8516   (sbcl-package->ecl-package sbcl-cl-ana.tensor))
8517
8518 (define-public sbcl-cl-ana.error-propogation
8519   (package
8520     (inherit sbcl-cl-ana-boot0)
8521     (name "sbcl-cl-ana.error-propogation")
8522     (inputs
8523      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8524        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)))
8525     (arguments
8526      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8527        ((#:asd-file _ "") "error-propogation/cl-ana.error-propogation.asd")
8528        ((#:asd-system-name _ #f) "cl-ana.error-propogation")))))
8529
8530 (define-public cl-ana.error-propogation
8531   (sbcl-package->cl-source-package sbcl-cl-ana.error-propogation))
8532
8533 (define-public sbcl-cl-ana.quantity
8534   (package
8535     (inherit sbcl-cl-ana-boot0)
8536     (name "sbcl-cl-ana.quantity")
8537     (inputs
8538      `(("alexandria" ,sbcl-alexandria)
8539        ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
8540        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8541        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8542        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8543        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)))
8544     (arguments
8545      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8546        ((#:asd-file _ "") "quantity/cl-ana.quantity.asd")
8547        ((#:asd-system-name _ #f) "cl-ana.quantity")))))
8548
8549 (define-public cl-ana.quantity
8550   (sbcl-package->cl-source-package sbcl-cl-ana.quantity))
8551
8552 (define-public sbcl-cl-ana.table
8553   (package
8554     (inherit sbcl-cl-ana-boot0)
8555     (name "sbcl-cl-ana.table")
8556     (inputs
8557      `(("alexandria" ,sbcl-alexandria)
8558        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
8559        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8560        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8561        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8562        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)))
8563     (arguments
8564      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8565        ((#:asd-file _ "") "table/cl-ana.table.asd")
8566        ((#:asd-system-name _ #f) "cl-ana.table")))))
8567
8568 (define-public cl-ana.table
8569   (sbcl-package->cl-source-package sbcl-cl-ana.table))
8570
8571 (define-public ecl-cl-ana.table
8572   (sbcl-package->ecl-package sbcl-cl-ana.table))
8573
8574 (define-public sbcl-cl-ana.table-utils
8575   (package
8576     (inherit sbcl-cl-ana-boot0)
8577     (name "sbcl-cl-ana.table-utils")
8578     (inputs
8579      `(("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8580        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8581        ("cl-ana.table" ,sbcl-cl-ana.table)))
8582     (arguments
8583      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8584        ((#:asd-file _ "") "table-utils/cl-ana.table-utils.asd")
8585        ((#:asd-system-name _ #f) "cl-ana.table-utils")))))
8586
8587 (define-public cl-ana.table-utils
8588   (sbcl-package->cl-source-package sbcl-cl-ana.table-utils))
8589
8590 (define-public ecl-cl-ana.table-utils
8591   (sbcl-package->ecl-package sbcl-cl-ana.table-utils))
8592
8593 (define-public sbcl-cl-ana.hdf-cffi
8594   (package
8595     (inherit sbcl-cl-ana-boot0)
8596     (name "sbcl-cl-ana.hdf-cffi")
8597     (inputs
8598      `(("cffi" ,sbcl-cffi)
8599        ("hdf5" ,hdf5-parallel-openmpi)))
8600     (arguments
8601      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8602        ((#:asd-file _ "") "hdf-cffi/cl-ana.hdf-cffi.asd")
8603        ((#:asd-system-name _ #f) "cl-ana.hdf-cffi")
8604        ((#:phases phases '%standard-phases)
8605         `(modify-phases ,phases
8606            (add-after 'unpack 'fix-paths
8607              (lambda* (#:key inputs #:allow-other-keys)
8608                (substitute* "hdf-cffi/hdf-cffi.lisp"
8609                  (("/usr/lib/i386-linux-gnu/hdf5/serial/libhdf5.so")
8610                   (string-append
8611                    (assoc-ref inputs "hdf5")
8612                    "/lib/libhdf5.so")))))))))))
8613
8614 (define-public cl-ana.hdf-cffi
8615   (sbcl-package->cl-source-package sbcl-cl-ana.hdf-cffi))
8616
8617 (define-public ecl-cl-ana.hdf-cffi
8618   (sbcl-package->ecl-package sbcl-cl-ana.hdf-cffi))
8619
8620 (define-public sbcl-cl-ana.int-char
8621   (package
8622     (inherit sbcl-cl-ana-boot0)
8623     (name "sbcl-cl-ana.int-char")
8624     (arguments
8625      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8626        ((#:asd-file _ "") "int-char/cl-ana.int-char.asd")
8627        ((#:asd-system-name _ #f) "cl-ana.int-char")))))
8628
8629 (define-public cl-ana.int-char
8630   (sbcl-package->cl-source-package sbcl-cl-ana.int-char))
8631
8632 (define-public ecl-cl-ana.int-char
8633   (sbcl-package->ecl-package sbcl-cl-ana.int-char))
8634
8635 (define-public sbcl-cl-ana.memoization
8636   (package
8637     (inherit sbcl-cl-ana-boot0)
8638     (name "sbcl-cl-ana.memoization")
8639     (inputs
8640      `(("alexandria" ,sbcl-alexandria)))
8641     (arguments
8642      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8643        ((#:asd-file _ "") "memoization/cl-ana.memoization.asd")
8644        ((#:asd-system-name _ #f) "cl-ana.memoization")))))
8645
8646 (define-public cl-ana.memoization
8647   (sbcl-package->cl-source-package sbcl-cl-ana.memoization))
8648
8649 (define-public ecl-cl-ana.memoization
8650   (sbcl-package->ecl-package sbcl-cl-ana.memoization))
8651
8652 (define-public sbcl-cl-ana.typespec
8653   (package
8654     (inherit sbcl-cl-ana-boot0)
8655     (name "sbcl-cl-ana.typespec")
8656     (inputs
8657      `(("alexandria" ,sbcl-alexandria)
8658        ("cffi" ,sbcl-cffi)
8659        ("cl-ana.int-char" ,sbcl-cl-ana.int-char)
8660        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8661        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
8662        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8663        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8664        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)))
8665     (arguments
8666      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8667        ((#:asd-file _ "") "typespec/cl-ana.typespec.asd")
8668        ((#:asd-system-name _ #f) "cl-ana.typespec")))))
8669
8670 (define-public cl-ana.typespec
8671   (sbcl-package->cl-source-package sbcl-cl-ana.typespec))
8672
8673 (define-public ecl-cl-ana.typespec
8674   (sbcl-package->ecl-package sbcl-cl-ana.typespec))
8675
8676 (define-public sbcl-cl-ana.hdf-typespec
8677   (package
8678     (inherit sbcl-cl-ana-boot0)
8679     (name "sbcl-cl-ana.hdf-typespec")
8680     (inputs
8681      `(("alexandria" ,sbcl-alexandria)
8682        ("cffi" ,sbcl-cffi)
8683        ("cl-ana.hdf-cffi" ,sbcl-cl-ana.hdf-cffi)
8684        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8685        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
8686        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8687        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8688        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
8689     (arguments
8690      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8691        ((#:asd-file _ "") "hdf-typespec/cl-ana.hdf-typespec.asd")
8692        ((#:asd-system-name _ #f) "cl-ana.hdf-typespec")))))
8693
8694 (define-public cl-ana.hdf-typespec
8695   (sbcl-package->cl-source-package sbcl-cl-ana.hdf-typespec))
8696
8697 (define-public ecl-cl-ana.hdf-typespec
8698   (sbcl-package->ecl-package sbcl-cl-ana.hdf-typespec))
8699
8700 (define-public sbcl-cl-ana.hdf-utils
8701   (package
8702     (inherit sbcl-cl-ana-boot0)
8703     (name "sbcl-cl-ana.hdf-utils")
8704     (inputs
8705      `(("alexandria" ,sbcl-alexandria)
8706        ("cffi" ,sbcl-cffi)
8707        ("cl-ana.hdf-cffi" ,sbcl-cl-ana.hdf-cffi)
8708        ("cl-ana.hdf-typespec" ,sbcl-cl-ana.hdf-typespec)
8709        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8710        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
8711        ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
8712        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8713        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
8714     (arguments
8715      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8716        ((#:asd-file _ "") "hdf-utils/cl-ana.hdf-utils.asd")
8717        ((#:asd-system-name _ #f) "cl-ana.hdf-utils")))))
8718
8719 (define-public cl-ana.hdf-utils
8720   (sbcl-package->cl-source-package sbcl-cl-ana.hdf-utils))
8721
8722 (define-public ecl-cl-ana.hdf-utils
8723   (sbcl-package->ecl-package sbcl-cl-ana.hdf-utils))
8724
8725 (define-public sbcl-cl-ana.typed-table
8726   (package
8727     (inherit sbcl-cl-ana-boot0)
8728     (name "sbcl-cl-ana.typed-table")
8729     (inputs
8730      `(("alexandria" ,sbcl-alexandria)
8731        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8732        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8733        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8734        ("cl-ana.table" ,sbcl-cl-ana.table)
8735        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
8736     (arguments
8737      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8738        ((#:asd-file _ "") "typed-table/cl-ana.typed-table.asd")
8739        ((#:asd-system-name _ #f) "cl-ana.typed-table")))))
8740
8741 (define-public cl-ana.typed-table
8742   (sbcl-package->cl-source-package sbcl-cl-ana.typed-table))
8743
8744 (define-public ecl-cl-ana.typed-table
8745   (sbcl-package->ecl-package sbcl-cl-ana.typed-table))
8746
8747 (define-public sbcl-cl-ana.hdf-table
8748   (package
8749     (inherit sbcl-cl-ana-boot0)
8750     (name "sbcl-cl-ana.hdf-table")
8751     (inputs
8752      `(("alexandria" ,sbcl-alexandria)
8753        ("cl-ana.binary-tree" ,sbcl-cl-ana.binary-tree)
8754        ("cl-ana.hdf-cffi" ,sbcl-cl-ana.hdf-cffi)
8755        ("cl-ana.hdf-typespec" ,sbcl-cl-ana.hdf-typespec)
8756        ("cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
8757        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8758        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
8759        ("cl-ana.table" ,sbcl-cl-ana.table)
8760        ("cl-ana.typed-table" ,sbcl-cl-ana.typed-table)
8761        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
8762     (arguments
8763      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8764        ((#:asd-file _ "") "hdf-table/cl-ana.hdf-table.asd")
8765        ((#:asd-system-name _ #f) "cl-ana.hdf-table")))))
8766
8767 (define-public cl-ana.hdf-table
8768   (sbcl-package->cl-source-package sbcl-cl-ana.hdf-table))
8769
8770 (define-public ecl-cl-ana.hdf-table
8771   (sbcl-package->ecl-package sbcl-cl-ana.hdf-table))
8772
8773 (define-public sbcl-cl-ana.gsl-cffi
8774   (package
8775     (inherit sbcl-cl-ana-boot0)
8776     (name "sbcl-cl-ana.gsl-cffi")
8777     (inputs
8778      `(("cffi" ,sbcl-cffi)
8779        ("gsl" ,gsl)))
8780     (arguments
8781      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8782        ((#:asd-file _ "") "gsl-cffi/cl-ana.gsl-cffi.asd")
8783        ((#:asd-system-name _ #f) "cl-ana.gsl-cffi")
8784        ((#:phases phases '%standard-phases)
8785         `(modify-phases ,phases
8786            (add-after 'unpack 'fix-paths
8787              (lambda* (#:key inputs #:allow-other-keys)
8788                (substitute* "gsl-cffi/gsl-cffi.lisp"
8789                  (("define-foreign-library gsl-cffi" all)
8790                   (string-append all " (:unix "
8791                                  (assoc-ref inputs "gsl")
8792                                  "/lib/libgsl.so)")))))))))))
8793
8794 (define-public cl-ana.gsl-cffi
8795   (sbcl-package->cl-source-package sbcl-cl-ana.gsl-cffi))
8796
8797 (define-public ecl-cl-ana.gsl-cffi
8798   (sbcl-package->ecl-package sbcl-cl-ana.gsl-cffi))
8799
8800 (define-public sbcl-cl-ana.ntuple-table
8801   (package
8802     (inherit sbcl-cl-ana-boot0)
8803     (name "sbcl-cl-ana.ntuple-table")
8804     (inputs
8805      `(("alexandria" ,sbcl-alexandria)
8806        ("cffi" ,sbcl-cffi)
8807        ("cl-ana.gsl-cffi" ,sbcl-cl-ana.gsl-cffi)
8808        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8809        ("cl-ana.table" ,sbcl-cl-ana.table)
8810        ("cl-ana.typed-table" ,sbcl-cl-ana.typed-table)
8811        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)
8812        ("gsll" ,sbcl-gsll)))
8813     (arguments
8814      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8815        ((#:asd-file _ "") "ntuple-table/cl-ana.ntuple-table.asd")
8816        ((#:asd-system-name _ #f) "cl-ana.ntuple-table")))))
8817
8818 (define-public cl-ana.ntuple-table
8819   (sbcl-package->cl-source-package sbcl-cl-ana.ntuple-table))
8820
8821 (define-public sbcl-cl-ana.csv-table
8822   (package
8823     (inherit sbcl-cl-ana-boot0)
8824     (name "sbcl-cl-ana.csv-table")
8825     (inputs
8826      `(("alexandria" ,sbcl-alexandria)
8827        ("antik" ,sbcl-antik)
8828        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8829        ("cl-ana.table" ,sbcl-cl-ana.table)
8830        ("cl-csv" ,sbcl-cl-csv)
8831        ("iterate" ,sbcl-iterate)))
8832     (arguments
8833      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8834        ((#:asd-file _ "") "csv-table/cl-ana.csv-table.asd")
8835        ((#:asd-system-name _ #f) "cl-ana.csv-table")))))
8836
8837 (define-public cl-ana.csv-table
8838   (sbcl-package->cl-source-package sbcl-cl-ana.csv-table))
8839
8840 (define-public sbcl-cl-ana.reusable-table
8841   (package
8842     (inherit sbcl-cl-ana-boot0)
8843     (name "sbcl-cl-ana.reusable-table")
8844     (inputs
8845      `(("alexandria" ,sbcl-alexandria)
8846        ("cl-ana.table" ,sbcl-cl-ana.table)))
8847     (arguments
8848      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8849        ((#:asd-file _ "") "reusable-table/cl-ana.reusable-table.asd")
8850        ((#:asd-system-name _ #f) "cl-ana.reusable-table")))))
8851
8852 (define-public cl-ana.reusable-table
8853   (sbcl-package->cl-source-package sbcl-cl-ana.reusable-table))
8854
8855 (define-public ecl-cl-ana.reusable-table
8856   (sbcl-package->ecl-package sbcl-cl-ana.reusable-table))
8857
8858 (define-public sbcl-cl-ana.linear-algebra
8859   (package
8860     (inherit sbcl-cl-ana-boot0)
8861     (name "sbcl-cl-ana.linear-algebra")
8862     (inputs
8863      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8864        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8865        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
8866        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
8867        ("gsll" ,sbcl-gsll)))
8868     (arguments
8869      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8870        ((#:asd-file _ "") "linear-algebra/cl-ana.linear-algebra.asd")
8871        ((#:asd-system-name _ #f) "cl-ana.linear-algebra")))))
8872
8873 (define-public cl-ana.linear-algebra
8874   (sbcl-package->cl-source-package sbcl-cl-ana.linear-algebra))
8875
8876 (define-public sbcl-cl-ana.lorentz
8877   (package
8878     (inherit sbcl-cl-ana-boot0)
8879     (name "sbcl-cl-ana.lorentz")
8880     (inputs
8881      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8882        ("cl-ana.linear-algebra" ,sbcl-cl-ana.linear-algebra)
8883        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
8884        ("iterate" ,sbcl-iterate)))
8885     (arguments
8886      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8887        ((#:asd-file _ "") "lorentz/cl-ana.lorentz.asd")
8888        ((#:asd-system-name _ #f) "cl-ana.lorentz")))))
8889
8890 (define-public cl-ana.lorentz
8891   (sbcl-package->cl-source-package sbcl-cl-ana.lorentz))
8892
8893 (define-public sbcl-cl-ana.clos-utils
8894   (package
8895     (inherit sbcl-cl-ana-boot0)
8896     (name "sbcl-cl-ana.clos-utils")
8897     (inputs
8898      `(("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8899        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8900        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
8901        ("closer-mop" ,sbcl-closer-mop)))
8902     (arguments
8903      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8904        ((#:asd-file _ "") "clos-utils/cl-ana.clos-utils.asd")
8905        ((#:asd-system-name _ #f) "cl-ana.clos-utils")))))
8906
8907 (define-public cl-ana.clos-utils
8908   (sbcl-package->cl-source-package sbcl-cl-ana.clos-utils))
8909
8910 (define-public ecl-cl-ana.clos-utils
8911   (sbcl-package->ecl-package sbcl-cl-ana.clos-utils))
8912
8913 (define-public sbcl-cl-ana.hash-table-utils
8914   (package
8915     (inherit sbcl-cl-ana-boot0)
8916     (name "sbcl-cl-ana.hash-table-utils")
8917     (arguments
8918      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8919        ((#:asd-file _ "") "hash-table-utils/cl-ana.hash-table-utils.asd")
8920        ((#:asd-system-name _ #f) "cl-ana.hash-table-utils")))))
8921
8922 (define-public cl-ana.hash-table-utils
8923   (sbcl-package->cl-source-package sbcl-cl-ana.hash-table-utils))
8924
8925 (define-public ecl-cl-ana.hash-table-utils
8926   (sbcl-package->ecl-package sbcl-cl-ana.hash-table-utils))
8927
8928 (define-public sbcl-cl-ana.map
8929   (package
8930     (inherit sbcl-cl-ana-boot0)
8931     (name "sbcl-cl-ana.map")
8932     (inputs
8933      `(("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)))
8934     (arguments
8935      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8936        ((#:asd-file _ "") "map/cl-ana.map.asd")
8937        ((#:asd-system-name _ #f) "cl-ana.map")))))
8938
8939 (define-public cl-ana.map
8940   (sbcl-package->cl-source-package sbcl-cl-ana.map))
8941
8942 (define-public ecl-cl-ana.map
8943   (sbcl-package->ecl-package sbcl-cl-ana.map))
8944
8945 (define-public sbcl-cl-ana.fitting
8946   (package
8947     (inherit sbcl-cl-ana-boot0)
8948     (name "sbcl-cl-ana.fitting")
8949     (inputs
8950      `(("alexandria" ,sbcl-alexandria)
8951        ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
8952        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8953        ("cl-ana.map" ,sbcl-cl-ana.map)
8954        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
8955        ("gsll" ,sbcl-gsll)))
8956     (arguments
8957      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8958        ((#:asd-file _ "") "fitting/cl-ana.fitting.asd")
8959        ((#:asd-system-name _ #f) "cl-ana.fitting")))))
8960
8961 (define-public cl-ana.fitting
8962   (sbcl-package->cl-source-package sbcl-cl-ana.fitting))
8963
8964 (define-public sbcl-cl-ana.histogram
8965   (package
8966     (inherit sbcl-cl-ana-boot0)
8967     (name "sbcl-cl-ana.histogram")
8968     (inputs
8969      `(("alexandria" ,sbcl-alexandria)
8970        ("iterate" ,sbcl-iterate)
8971        ("cl-ana.binary-tree" ,sbcl-cl-ana.binary-tree)
8972        ("cl-ana.clos-utils" ,sbcl-cl-ana.clos-utils)
8973        ("cl-ana.fitting" ,sbcl-cl-ana.fitting)
8974        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
8975        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8976        ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
8977        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8978        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8979        ("cl-ana.map" ,sbcl-cl-ana.map)
8980        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)))
8981     (arguments
8982      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8983        ((#:asd-file _ "") "histogram/cl-ana.histogram.asd")
8984        ((#:asd-system-name _ #f) "cl-ana.histogram")))))
8985
8986 (define-public cl-ana.histogram
8987   (sbcl-package->cl-source-package sbcl-cl-ana.histogram))
8988
8989 (define-public sbcl-cl-ana.file-utils
8990   (package
8991     (inherit sbcl-cl-ana-boot0)
8992     (name "sbcl-cl-ana.file-utils")
8993     (inputs
8994      `(("external-program" ,sbcl-external-program)
8995        ("split-sequence" ,sbcl-split-sequence)))
8996     (arguments
8997      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8998        ((#:asd-file _ "") "file-utils/cl-ana.file-utils.asd")
8999        ((#:asd-system-name _ #f) "cl-ana.file-utils")))))
9000
9001 (define-public cl-ana.file-utils
9002   (sbcl-package->cl-source-package sbcl-cl-ana.file-utils))
9003
9004 (define-public ecl-cl-ana.file-utils
9005   (sbcl-package->ecl-package sbcl-cl-ana.file-utils))
9006
9007 (define-public sbcl-cl-ana.statistics
9008   (package
9009     (inherit sbcl-cl-ana-boot0)
9010     (name "sbcl-cl-ana.statistics")
9011     (inputs
9012      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9013        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9014        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9015        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9016        ("cl-ana.map" ,sbcl-cl-ana.map)))
9017     (arguments
9018      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9019        ((#:asd-file _ "") "statistics/cl-ana.statistics.asd")
9020        ((#:asd-system-name _ #f) "cl-ana.statistics")))))
9021
9022 (define-public cl-ana.statistics
9023   (sbcl-package->cl-source-package sbcl-cl-ana.statistics))
9024
9025 (define-public sbcl-cl-ana.gnuplot-interface
9026   (package
9027     (inherit sbcl-cl-ana-boot0)
9028     (name "sbcl-cl-ana.gnuplot-interface")
9029     (inputs
9030      `(("external-program" ,sbcl-external-program)))
9031     (arguments
9032      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9033        ((#:asd-file _ "") "gnuplot-interface/cl-ana.gnuplot-interface.asd")
9034        ((#:asd-system-name _ #f) "cl-ana.gnuplot-interface")))))
9035
9036 (define-public cl-ana.gnuplot-interface
9037   (sbcl-package->cl-source-package sbcl-cl-ana.gnuplot-interface))
9038
9039 (define-public ecl-cl-ana.gnuplot-interface
9040   (sbcl-package->ecl-package sbcl-cl-ana.gnuplot-interface))
9041
9042 (define-public sbcl-cl-ana.plotting
9043   (package
9044     (inherit sbcl-cl-ana-boot0)
9045     (name "sbcl-cl-ana.plotting")
9046     (inputs
9047      `(("alexandria" ,sbcl-alexandria)
9048        ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
9049        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
9050        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9051        ("cl-ana.gnuplot-interface" ,sbcl-cl-ana.gnuplot-interface)
9052        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9053        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9054        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9055        ("cl-ana.map" ,sbcl-cl-ana.map)
9056        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
9057        ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
9058        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
9059        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
9060        ("external-program" ,sbcl-external-program)
9061        ("split-sequence" ,sbcl-split-sequence)))
9062     (arguments
9063      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9064        ((#:asd-file _ "") "plotting/cl-ana.plotting.asd")
9065        ((#:asd-system-name _ #f) "cl-ana.plotting")))))
9066
9067 (define-public cl-ana.plotting
9068   (sbcl-package->cl-source-package sbcl-cl-ana.plotting))
9069
9070 (define-public sbcl-cl-ana.table-viewing
9071   (package
9072     (inherit sbcl-cl-ana-boot0)
9073     (name "sbcl-cl-ana.table-viewing")
9074     (inputs
9075      `(("alexandria" ,sbcl-alexandria)
9076        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9077        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9078        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9079        ("cl-ana.plotting" ,sbcl-cl-ana.plotting)
9080        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
9081        ("cl-ana.table" ,sbcl-cl-ana.table)))
9082     (arguments
9083      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9084        ((#:asd-file _ "") "table-viewing/cl-ana.table-viewing.asd")
9085        ((#:asd-system-name _ #f) "cl-ana.table-viewing")))))
9086
9087 (define-public cl-ana.table-viewing
9088   (sbcl-package->cl-source-package sbcl-cl-ana.table-viewing))
9089
9090 (define-public sbcl-cl-ana.serialization
9091   (package
9092     (inherit sbcl-cl-ana-boot0)
9093     (name "sbcl-cl-ana.serialization")
9094     (inputs
9095      `(("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
9096        ("cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
9097        ("cl-ana.hdf-table" ,sbcl-cl-ana.hdf-table)
9098        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9099        ("cl-ana.int-char" ,sbcl-cl-ana.int-char)
9100        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9101        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
9102     (arguments
9103      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9104        ((#:asd-file _ "") "serialization/cl-ana.serialization.asd")
9105        ((#:asd-system-name _ #f) "cl-ana.serialization")))))
9106
9107 (define-public cl-ana.serialization
9108   (sbcl-package->cl-source-package sbcl-cl-ana.serialization))
9109
9110 (define-public sbcl-cl-ana.makeres
9111   (package
9112     (inherit sbcl-cl-ana-boot0)
9113     (name "sbcl-cl-ana.makeres")
9114     (inputs
9115      `(("alexandria" ,sbcl-alexandria)
9116        ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
9117        ("cl-ana.file-utils" ,sbcl-cl-ana.file-utils)
9118        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
9119        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9120        ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
9121        ("cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
9122        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9123        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9124        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9125        ("cl-ana.map" ,sbcl-cl-ana.map)
9126        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
9127        ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
9128        ("cl-ana.plotting" ,sbcl-cl-ana.plotting)
9129        ("cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
9130        ("cl-ana.serialization" ,sbcl-cl-ana.serialization)
9131        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
9132        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
9133        ("cl-ana.table" ,sbcl-cl-ana.table)
9134        ("external-program" ,sbcl-external-program)))
9135     (native-inputs
9136      `(("cl-fad" ,sbcl-cl-fad)))
9137     (arguments
9138      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9139        ((#:asd-file _ "") "makeres/cl-ana.makeres.asd")
9140        ((#:asd-system-name _ #f) "cl-ana.makeres")))))
9141
9142 (define-public cl-ana.makeres
9143   (sbcl-package->cl-source-package sbcl-cl-ana.makeres))
9144
9145 (define-public sbcl-cl-ana.makeres-macro
9146   (package
9147     (inherit sbcl-cl-ana-boot0)
9148     (name "sbcl-cl-ana.makeres-macro")
9149     (inputs
9150      `(("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9151        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)))
9152     (arguments
9153      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9154        ((#:asd-file _ "") "makeres-macro/cl-ana.makeres-macro.asd")
9155        ((#:asd-system-name _ #f) "cl-ana.makeres-macro")))))
9156
9157 (define-public cl-ana.makeres-macro
9158   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-macro))
9159
9160 (define-public sbcl-cl-ana.makeres-block
9161   (package
9162     (inherit sbcl-cl-ana-boot0)
9163     (name "sbcl-cl-ana.makeres-block")
9164     (inputs
9165      `(("alexandria" ,sbcl-alexandria)
9166        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9167        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9168        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)))
9169     (arguments
9170      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9171        ((#:asd-file _ "") "makeres-block/cl-ana.makeres-block.asd")
9172        ((#:asd-system-name _ #f) "cl-ana.makeres-block")))))
9173
9174 (define-public cl-ana.makeres-block
9175   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-block))
9176
9177 (define-public sbcl-cl-ana.makeres-progress
9178   (package
9179     (inherit sbcl-cl-ana-boot0)
9180     (name "sbcl-cl-ana.makeres-progress")
9181     (inputs
9182      `(("alexandria" ,sbcl-alexandria)
9183        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9184        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)))
9185     (arguments
9186      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9187        ((#:asd-file _ "") "makeres-progress/cl-ana.makeres-progress.asd")
9188        ((#:asd-system-name _ #f) "cl-ana.makeres-progress")))))
9189
9190 (define-public cl-ana.makeres-progress
9191   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-progress))
9192
9193 (define-public sbcl-cl-ana.makeres-table
9194   (package
9195     (inherit sbcl-cl-ana-boot0)
9196     (name "sbcl-cl-ana.makeres-table")
9197     (inputs
9198      `(("cl-ana.csv-table" ,sbcl-cl-ana.csv-table)
9199        ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
9200        ("cl-ana.hdf-table" ,sbcl-cl-ana.hdf-table)
9201        ("cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
9202        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9203        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9204        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)
9205        ("cl-ana.makeres-macro" ,sbcl-cl-ana.makeres-macro)
9206        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
9207        ("cl-ana.ntuple-table" ,sbcl-cl-ana.ntuple-table)
9208        ("cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
9209        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
9210        ("cl-ana.table" ,sbcl-cl-ana.table)))
9211     (native-inputs
9212      `(("cl-fad" ,sbcl-cl-fad)))
9213     (arguments
9214      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9215        ((#:asd-file _ "") "makeres-table/cl-ana.makeres-table.asd")
9216        ((#:asd-system-name _ #f) "cl-ana.makeres-table")))))
9217
9218 (define-public cl-ana.makeres-table
9219   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-table))
9220
9221 (define-public sbcl-cl-ana.makeres-graphviz
9222   (package
9223     (inherit sbcl-cl-ana-boot0)
9224     (name "sbcl-cl-ana.makeres-graphviz")
9225     (inputs
9226      `(("cl-ana.makeres" ,sbcl-cl-ana.makeres)
9227        ("external-program" ,sbcl-external-program)))
9228     (arguments
9229      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9230        ((#:asd-file _ "") "makeres-graphviz/cl-ana.makeres-graphviz.asd")
9231        ((#:asd-system-name _ #f) "cl-ana.makeres-graphviz")))))
9232
9233 (define-public cl-ana.makeres-graphviz
9234   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-graphviz))
9235
9236 (define-public sbcl-cl-ana.makeres-branch
9237   (package
9238     (inherit sbcl-cl-ana-boot0)
9239     (name "sbcl-cl-ana.makeres-branch")
9240     (inputs
9241      `(("alexandria" ,sbcl-alexandria)
9242        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9243        ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
9244        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9245        ("cl-ana.map" ,sbcl-cl-ana.map)
9246        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)))
9247     (arguments
9248      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9249        ((#:asd-file _ "") "makeres-branch/cl-ana.makeres-branch.asd")
9250        ((#:asd-system-name _ #f) "cl-ana.makeres-branch")))))
9251
9252 (define-public cl-ana.makeres-branch
9253   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-branch))
9254
9255 (define-public sbcl-cl-ana.makeres-utils
9256   (package
9257     (inherit sbcl-cl-ana-boot0)
9258     (name "sbcl-cl-ana.makeres-utils")
9259     (inputs
9260      `(("alexandria" ,sbcl-alexandria)
9261        ("cl-ana.file-utils" ,sbcl-cl-ana.file-utils)
9262        ("cl-ana.fitting" ,sbcl-cl-ana.fitting)
9263        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
9264        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9265        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9266        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9267        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9268        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)
9269        ("cl-ana.map" ,sbcl-cl-ana.map)
9270        ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
9271        ("cl-ana.plotting" ,sbcl-cl-ana.plotting)
9272        ("cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
9273        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
9274        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
9275        ("cl-ana.table" ,sbcl-cl-ana.table)))
9276     (native-inputs
9277      `(("cl-fad" ,sbcl-cl-fad)))
9278     (arguments
9279      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9280        ((#:asd-file _ "") "makeres-utils/cl-ana.makeres-utils.asd")
9281        ((#:asd-system-name _ #f) "cl-ana.makeres-utils")))))
9282
9283 (define-public cl-ana.makeres-utils
9284   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-utils))
9285
9286 (define-public sbcl-cl-ana.statistical-learning
9287   (package
9288     (inherit sbcl-cl-ana-boot0)
9289     (name "sbcl-cl-ana.statistical-learning")
9290     (inputs
9291      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9292        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
9293        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9294        ("cl-ana.linear-algebra" ,sbcl-cl-ana.linear-algebra)
9295        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9296        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9297        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
9298        ("cl-ana.map" ,sbcl-cl-ana.map)
9299        ("cl-ana.statistics" ,sbcl-cl-ana.statistics)))
9300     (native-inputs
9301      `(("cl-fad" ,sbcl-cl-fad)))
9302     (arguments
9303      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9304        ((#:asd-file _ "")
9305         "statistical-learning/cl-ana.statistical-learning.asd")
9306        ((#:asd-system-name _ #f) "cl-ana.statistical-learning")))))
9307
9308 (define-public cl-ana.statistical-learning
9309   (sbcl-package->cl-source-package sbcl-cl-ana.statistical-learning))
9310
9311 (define-public sbcl-cl-ana
9312   (package
9313     (inherit sbcl-cl-ana-boot0)
9314     (name "sbcl-cl-ana")
9315     (inputs
9316      `(("cl-ana.binary-tree" ,sbcl-cl-ana.binary-tree)
9317        ("cl-ana.calculus" ,sbcl-cl-ana.calculus)
9318        ("cl-ana.clos-utils" ,sbcl-cl-ana.clos-utils)
9319        ("cl-ana.csv-table" ,sbcl-cl-ana.csv-table)
9320        ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
9321        ("cl-ana.file-utils" ,sbcl-cl-ana.file-utils)
9322        ("cl-ana.fitting" ,sbcl-cl-ana.fitting)
9323        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9324        ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
9325        ("cl-ana.hdf-table" ,sbcl-cl-ana.hdf-table)
9326        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9327        ("cl-ana.int-char" ,sbcl-cl-ana.int-char)
9328        ("cl-ana.linear-algebra" ,sbcl-cl-ana.linear-algebra)
9329        ("cl-ana.lorentz" ,sbcl-cl-ana.lorentz)
9330        ("cl-ana.map" ,sbcl-cl-ana.map)
9331        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)
9332        ("cl-ana.makeres-block" ,sbcl-cl-ana.makeres-block)
9333        ("cl-ana.makeres-branch" ,sbcl-cl-ana.makeres-branch)
9334        ("cl-ana.makeres-graphviz" ,sbcl-cl-ana.makeres-graphviz)
9335        ("cl-ana.makeres-macro" ,sbcl-cl-ana.makeres-macro)
9336        ("cl-ana.makeres-progress" ,sbcl-cl-ana.makeres-progress)
9337        ("cl-ana.makeres-table" ,sbcl-cl-ana.makeres-table)
9338        ("cl-ana.makeres-utils" ,sbcl-cl-ana.makeres-utils)
9339        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
9340        ("cl-ana.ntuple-table" ,sbcl-cl-ana.ntuple-table)
9341        ("cl-ana.package-utils" ,sbcl-cl-ana.package-utils)
9342        ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
9343        ("cl-ana.plotting" ,sbcl-cl-ana.plotting)
9344        ("cl-ana.quantity" ,sbcl-cl-ana.quantity)
9345        ("cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
9346        ("cl-ana.serialization" ,sbcl-cl-ana.serialization)
9347        ("cl-ana.statistics" ,sbcl-cl-ana.statistics)
9348        ("cl-ana.statistical-learning" ,sbcl-cl-ana.statistical-learning)
9349        ("cl-ana.table" ,sbcl-cl-ana.table)
9350        ("cl-ana.table-utils" ,sbcl-cl-ana.table-utils)
9351        ("cl-ana.table-viewing" ,sbcl-cl-ana.table-viewing)
9352        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
9353        ("libffi" ,libffi)))
9354     (native-inputs
9355      `(("cl-fad" ,sbcl-cl-fad)))
9356     (arguments
9357      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9358        ((#:asd-file _ "") "cl-ana.asd")
9359        ((#:asd-system-name _ #f) "cl-ana")))))
9360
9361 (define-public cl-ana
9362   (sbcl-package->cl-source-package sbcl-cl-ana))
9363
9364 (define-public sbcl-archive
9365   (let ((commit "631271c091ed02994bec3980cb288a2cf32c7cdc")
9366         (revision "1"))
9367     (package
9368       (name "sbcl-archive")
9369       (version (git-version "0.9" revision commit))
9370       (source (origin
9371                 (method git-fetch)
9372                 (uri (git-reference
9373                       (url "https://github.com/sharplispers/archive.git")
9374                       (commit commit)))
9375                 (file-name (git-file-name name version))
9376                 (sha256
9377                  (base32
9378                   "0pvsc9fmybx7rxd0kmzq4shi6hszdpwdc1sfy7jwyfxf8n3hnv4p"))))
9379       (build-system asdf-build-system/sbcl)
9380       (inputs
9381        `(("cl-fad" ,sbcl-cl-fad)
9382          ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
9383       (synopsis "Common Lisp library for tar and cpio archives")
9384       (description
9385        "This is a Common Lisp library to read and write disk-based file
9386 archives such as those generated by the tar and cpio programs on Unix.")
9387       (home-page "https://github.com/sharplispers/archive")
9388       (license license:bsd-3))))
9389
9390 (define-public cl-archive
9391   (sbcl-package->cl-source-package sbcl-archive))
9392
9393 (define-public ecl-archive
9394   (sbcl-package->ecl-package sbcl-archive))
9395
9396 (define-public sbcl-misc-extensions
9397   (let ((commit "101c05112bf2f1e1bbf527396822d2f50ca6327a")
9398         (revision "1"))
9399     (package
9400       (name "sbcl-misc-extensions")
9401       (version (git-version "3.3" revision commit))
9402       (source
9403        (origin
9404          (method git-fetch)
9405          (uri (git-reference
9406                (url "https://gitlab.common-lisp.net/misc-extensions/devel.git")
9407                (commit commit)))
9408          (file-name (git-file-name name version))
9409          (sha256
9410           (base32
9411            "0gz5f4p70qzilnxsnf5lih2n9m4wjcw8hlw4w8mpn9jyhyppyyv0"))))
9412       (build-system asdf-build-system/sbcl)
9413       (synopsis "Collection of small macros and extensions for Common Lisp")
9414       (description
9415        "This project is intended as a catchall for small, general-purpose
9416 extensions to Common Lisp.  It contains:
9417
9418 @itemize
9419 @item @code{new-let}, a macro that combines and generalizes @code{let},
9420 @code{let*} and @code{multiple-value-bind},
9421 @item @code{gmap}, an iteration macro that generalizes @code{map}.
9422 @end itemize\n")
9423       (home-page "https://common-lisp.net/project/misc-extensions/")
9424       (license license:public-domain))))
9425
9426 (define-public cl-misc-extensions
9427   (sbcl-package->cl-source-package sbcl-misc-extensions))
9428
9429 (define-public ecl-misc-extensions
9430   (sbcl-package->ecl-package sbcl-misc-extensions))
9431
9432 (define-public sbcl-mt19937
9433   (package
9434     (name "sbcl-mt19937")
9435     (version "1.1")
9436     (source
9437      (origin
9438        (method url-fetch)
9439        (uri (string-append "https://common-lisp.net/project/asdf-packaging/"
9440                            "mt19937-latest.tar.gz"))
9441        (sha256
9442         (base32
9443          "1iw636b0iw5ygkv02y8i41lh7xj0acglv0hg5agryn0zzi2nf1xv"))))
9444     (build-system asdf-build-system/sbcl)
9445     (synopsis "Mersenne Twister pseudo-random number generator")
9446     (description
9447      "MT19937 is a portable Mersenne Twister pseudo-random number generator
9448 for Common Lisp.")
9449     (home-page "https://www.cliki.net/mt19937")
9450     (license license:public-domain)))
9451
9452 (define-public cl-mt19937
9453   (sbcl-package->cl-source-package sbcl-mt19937))
9454
9455 (define-public ecl-mt19937
9456   (sbcl-package->ecl-package sbcl-mt19937))
9457
9458 (define-public sbcl-fset
9459   (let ((commit "6d2f9ded8934d2b42f2571a0ba5bda091037d852")
9460         (revision "1"))
9461     (package
9462       (name "sbcl-fset")
9463       (version (git-version "1.3.2" revision commit))
9464       (source
9465        (origin
9466          (method git-fetch)
9467          (uri (git-reference
9468                (url "https://github.com/slburson/fset")
9469                (commit commit)))
9470          (file-name (git-file-name name version))
9471          (sha256
9472           (base32
9473            "127acblwrbqicx47h6sgvknz1cqyfn8p4xkhkn1m7hxh8w5gk1zy"))
9474          (snippet '(begin
9475                      ;; Remove obsolete copy of system definition.
9476                      (delete-file "Code/fset.asd")
9477                      #t))))
9478       (build-system asdf-build-system/sbcl)
9479       (inputs
9480        `(("misc-extensions" ,sbcl-misc-extensions)
9481          ("mt19937" ,sbcl-mt19937)
9482          ("named-readtables" ,sbcl-named-readtables)))
9483       (synopsis "Functional set-theoretic collections library")
9484       (description
9485        "FSet is a functional set-theoretic collections library for Common Lisp.
9486 Functional means that all update operations return a new collection rather than
9487 modifying an existing one in place.  Set-theoretic means that collections may
9488 be nested arbitrarily with no additional programmer effort; for instance, sets
9489 may contain sets, maps may be keyed by sets, etc.")
9490       (home-page "https://common-lisp.net/project/fset/Site/index.html")
9491       (license license:llgpl))))
9492
9493 (define-public cl-fset
9494   (sbcl-package->cl-source-package sbcl-fset))
9495
9496 (define-public sbcl-cl-cont
9497   (let ((commit "fc1fa7e6eb64894fdca13e688e6015fad5290d2a")
9498         (revision "1"))
9499     (package
9500       (name "sbcl-cl-cont")
9501       (version (git-version "0.3.8" revision commit))
9502       (source
9503        (origin
9504          (method git-fetch)
9505          (uri (git-reference
9506                (url "https://gitlab.common-lisp.net/cl-cont/cl-cont.git")
9507                (commit commit)))
9508          (file-name (git-file-name name version))
9509          (sha256
9510           (base32
9511            "1zf8zvb0i6jm3hhfks4w74hibm6avgc6f9s1qwgjrn2bcik8lrvz"))))
9512       (build-system asdf-build-system/sbcl)
9513       (inputs
9514        `(("alexandria" ,sbcl-alexandria)
9515          ("closer-mop" ,sbcl-closer-mop)))
9516       (native-inputs
9517        `(("rt" ,sbcl-rt)))
9518       (synopsis "Delimited continuations for Common Lisp")
9519       (description
9520        "This is a library that implements delimited continuations by
9521 transforming Common Lisp code to continuation passing style.")
9522       (home-page "https://common-lisp.net/project/cl-cont/")
9523       (license license:llgpl))))
9524
9525 (define-public cl-cont
9526   (sbcl-package->cl-source-package sbcl-cl-cont))
9527
9528 (define-public ecl-cl-cont
9529   (sbcl-package->ecl-package sbcl-cl-cont))
9530
9531 (define-public sbcl-cl-coroutine
9532   (let ((commit "de098f8d5debd8b14ef6864b5bdcbbf5ddbcfd72")
9533         (revision "1"))
9534     (package
9535       (name "sbcl-cl-coroutine")
9536       (version (git-version "0.1" revision commit))
9537       (source
9538        (origin
9539          (method git-fetch)
9540          (uri (git-reference
9541                (url "https://github.com/takagi/cl-coroutine.git")
9542                (commit commit)))
9543          (file-name (git-file-name name version))
9544          (sha256
9545           (base32
9546            "1cqdhdjxffgfs116l1swjlsmcbly0xgcgrckvaajd566idj9yj4l"))))
9547       (build-system asdf-build-system/sbcl)
9548       (inputs
9549        `(("alexandria" ,sbcl-alexandria)
9550          ("cl-cont" ,sbcl-cl-cont)))
9551       (native-inputs
9552        `(("prove" ,sbcl-prove)))
9553       (arguments
9554        `(;; TODO: Fix the tests. They fail with:
9555          ;; "Component CL-COROUTINE-ASD::CL-COROUTINE-TEST not found"
9556          #:tests? #f
9557          #:phases
9558          (modify-phases %standard-phases
9559            (add-after 'unpack 'fix-tests
9560              (lambda _
9561                (substitute* "cl-coroutine-test.asd"
9562                  (("cl-test-more")
9563                   "prove"))
9564                #t)))))
9565       (synopsis "Coroutine library for Common Lisp")
9566       (description
9567        "This is a coroutine library for Common Lisp implemented using the
9568 continuations of the @code{cl-cont} library.")
9569       (home-page "https://github.com/takagi/cl-coroutine")
9570       (license license:llgpl))))
9571
9572 (define-public cl-coroutine
9573   (sbcl-package->cl-source-package sbcl-cl-coroutine))
9574
9575 (define-public ecl-cl-coroutine
9576   (sbcl-package->ecl-package sbcl-cl-coroutine))
9577
9578 (define-public sbcl-vom
9579   (let ((commit "1aeafeb5b74c53741b79497e0ef4acf85c92ff24")
9580         (revision "1"))
9581     (package
9582       (name "sbcl-vom")
9583       (version (git-version "0.1.4" revision commit))
9584       (source
9585        (origin
9586          (method git-fetch)
9587          (uri (git-reference
9588                (url "https://github.com/orthecreedence/vom.git")
9589                (commit commit)))
9590          (file-name (git-file-name name version))
9591          (sha256
9592           (base32
9593            "0536kppj76ax4lrxhv42npkfjsmx45km2g439vf9jmw3apinz9cy"))))
9594       (build-system asdf-build-system/sbcl)
9595       (synopsis "Tiny logging utility for Common Lisp")
9596       (description
9597        "Vom is a logging library for Common Lisp.  It's goal is to be useful
9598 and small.  It does not provide a lot of features as other loggers do, but
9599 has a small codebase that's easy to understand and use.")
9600       (home-page "https://github.com/orthecreedence/vom")
9601       (license license:expat))))
9602
9603 (define-public cl-vom
9604   (sbcl-package->cl-source-package sbcl-vom))
9605
9606 (define-public ecl-vom
9607   (sbcl-package->ecl-package sbcl-vom))
9608
9609 (define-public sbcl-cl-libuv
9610   (let ((commit "32100c023c518038d0670a103eaa4d50dd785d29")
9611         (revision "1"))
9612     (package
9613       (name "sbcl-cl-libuv")
9614       (version (git-version "0.1.6" revision commit))
9615       (source
9616        (origin
9617          (method git-fetch)
9618          (uri (git-reference
9619                (url "https://github.com/orthecreedence/cl-libuv.git")
9620                (commit commit)))
9621          (file-name (git-file-name name version))
9622          (sha256
9623           (base32
9624            "1kwix4si8a8hza34ab2k7whrh7z0yrmx39v2wc3qblv9m244jkh1"))))
9625       (build-system asdf-build-system/sbcl)
9626       (inputs
9627        `(("alexandria" ,sbcl-alexandria)
9628          ("cffi" ,sbcl-cffi)
9629          ("cffi-grovel" ,sbcl-cffi-grovel)
9630          ("libuv" ,libuv)))
9631       (arguments
9632        `(#:phases
9633          (modify-phases %standard-phases
9634            (add-after 'unpack 'fix-paths
9635              (lambda* (#:key inputs #:allow-other-keys)
9636                (substitute* "lib.lisp"
9637                  (("/usr/lib/libuv.so")
9638                   (string-append (assoc-ref inputs "libuv")
9639                                  "/lib/libuv.so")))
9640                #t))
9641            (add-after 'fix-paths 'fix-system-definition
9642              (lambda _
9643                (substitute* "cl-libuv.asd"
9644                  (("#:cffi #:alexandria")
9645                   "#:cffi #:cffi-grovel #:alexandria"))
9646                #t)))))
9647       (synopsis "Common Lisp bindings to libuv")
9648       (description
9649        "This library provides low-level libuv bindings for Common Lisp.")
9650       (home-page "https://github.com/orthecreedence/cl-libuv")
9651       (license license:expat))))
9652
9653 (define-public cl-libuv
9654   (sbcl-package->cl-source-package sbcl-cl-libuv))
9655
9656 (define-public ecl-cl-libuv
9657   (sbcl-package->ecl-package sbcl-cl-libuv))
9658
9659 (define-public sbcl-cl-async-base
9660   (let ((commit "f6423e44404a44434d803605e0d2e17199158e28")
9661         (revision "1"))
9662     (package
9663       (name "sbcl-cl-async-base")
9664       (version (git-version "0.6.1" revision commit))
9665       (source
9666        (origin
9667          (method git-fetch)
9668          (uri (git-reference
9669                (url "https://github.com/orthecreedence/cl-async.git")
9670                (commit commit)))
9671          (file-name (git-file-name name version))
9672          (sha256
9673           (base32
9674            "11xi9dxb8mjgwzrkj88i0xkgk26z9w9ddxzbv6xsvfc1d4x5cf4x"))))
9675       (build-system asdf-build-system/sbcl)
9676       (inputs
9677        `(("bordeaux-threads" ,sbcl-bordeaux-threads)
9678          ("cffi" ,sbcl-cffi)
9679          ("cl-libuv" ,sbcl-cl-libuv)))
9680       (arguments
9681        `(#:asd-file "cl-async.asd"))
9682       (synopsis "Base system for cl-async")
9683       (description
9684        "Cl-async is a library for general purpose, non-blocking programming in
9685 Common Lisp.  It uses the libuv library as backend.")
9686       (home-page "https://orthecreedence.github.io/cl-async/")
9687       (license license:expat))))
9688
9689 (define-public cl-async-base
9690   (sbcl-package->cl-source-package sbcl-cl-async-base))
9691
9692 (define-public ecl-cl-async-base
9693   (sbcl-package->ecl-package sbcl-cl-async-base))
9694
9695 (define-public sbcl-cl-async-util
9696   (package
9697     (inherit sbcl-cl-async-base)
9698     (name "sbcl-cl-async-util")
9699     (inputs
9700      `(("bordeaux-threads" ,sbcl-bordeaux-threads)
9701        ("cffi" ,sbcl-cffi)
9702        ("cl-async-base" ,sbcl-cl-async-base)
9703        ("cl-libuv" ,sbcl-cl-libuv)
9704        ("cl-ppcre" ,sbcl-cl-ppcre)
9705        ("fast-io" ,sbcl-fast-io)
9706        ("vom" ,sbcl-vom)))
9707     (synopsis "Internal utilities for cl-async")))
9708
9709 (define-public cl-async-util
9710   (sbcl-package->cl-source-package sbcl-cl-async-util))
9711
9712 (define-public ecl-cl-async-util
9713   (sbcl-package->ecl-package sbcl-cl-async-util))
9714
9715 (define-public sbcl-cl-async
9716   (package
9717     (inherit sbcl-cl-async-base)
9718     (name "sbcl-cl-async")
9719     (inputs
9720      `(("babel" ,sbcl-babel)
9721        ("cffi" ,sbcl-cffi)
9722        ("cl-async-base" ,sbcl-cl-async-base)
9723        ("cl-async-util" ,sbcl-cl-async-util)
9724        ("cl-libuv" ,sbcl-cl-libuv)
9725        ("cl-ppcre" ,sbcl-cl-ppcre)
9726        ("static-vectors" ,sbcl-static-vectors)
9727        ("trivial-features" ,sbcl-trivial-features)
9728        ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
9729     (synopsis "Asynchronous operations for Common Lisp")))
9730
9731 (define-public cl-async
9732   (sbcl-package->cl-source-package sbcl-cl-async))
9733
9734 (define-public ecl-cl-async
9735   (sbcl-package->ecl-package sbcl-cl-async))
9736
9737 (define-public sbcl-cl-async-repl
9738   (package
9739     (inherit sbcl-cl-async-base)
9740     (name "sbcl-cl-async-repl")
9741     (inputs
9742      `(("bordeaux-threads" ,sbcl-bordeaux-threads)
9743        ("cl-async" ,sbcl-cl-async)))
9744     (arguments
9745      (substitute-keyword-arguments (package-arguments sbcl-cl-async-base)
9746        ((#:asd-file _ "") "cl-async-repl.asd")))
9747     (synopsis "REPL integration for cl-async")))
9748
9749 (define-public cl-async-repl
9750   (sbcl-package->cl-source-package sbcl-cl-async-repl))
9751
9752 (define-public ecl-cl-async-repl
9753   (sbcl-package->ecl-package sbcl-cl-async-repl))
9754
9755 (define-public sbcl-cl-async-ssl
9756   (package
9757     (inherit sbcl-cl-async-base)
9758     (name "sbcl-cl-async-ssl")
9759     (inputs
9760      `(("cffi" ,sbcl-cffi)
9761        ("cl-async" ,sbcl-cl-async)
9762        ("openssl" ,openssl)
9763        ("vom" ,sbcl-vom)))
9764     (arguments
9765      (substitute-keyword-arguments (package-arguments sbcl-cl-async-base)
9766        ((#:asd-file _ "") "cl-async-ssl.asd")
9767        ((#:phases phases '%standard-phases)
9768         `(modify-phases ,phases
9769            (add-after 'unpack 'fix-paths
9770              (lambda* (#:key inputs #:allow-other-keys)
9771                (substitute* "src/ssl/package.lisp"
9772                  (("libcrypto\\.so")
9773                   (string-append (assoc-ref inputs "openssl")
9774                                  "/lib/libcrypto.so"))
9775                  (("libssl\\.so")
9776                   (string-append (assoc-ref inputs "openssl")
9777                                  "/lib/libssl.so")))
9778                #t))))))
9779     (synopsis "SSL wrapper around cl-async socket implementation")))
9780
9781 (define-public cl-async-ssl
9782   (sbcl-package->cl-source-package sbcl-cl-async-ssl))
9783
9784 (define-public ecl-cl-async-ssl
9785   (sbcl-package->ecl-package sbcl-cl-async-ssl))
9786
9787 (define-public sbcl-blackbird
9788   (let ((commit "d361f81c1411dec07f6c2dcb11c78f7aea9aaca8")
9789         (revision "1"))
9790     (package
9791       (name "sbcl-blackbird")
9792       (version (git-version "0.5.2" revision commit))
9793       (source
9794        (origin
9795          (method git-fetch)
9796          (uri (git-reference
9797                (url "https://github.com/orthecreedence/blackbird.git")
9798                (commit commit)))
9799          (file-name (git-file-name name version))
9800          (sha256
9801           (base32
9802            "0xfds5yaya64arzr7w1x38karyz11swzbhxx1afldpradj9dh19c"))))
9803       (build-system asdf-build-system/sbcl)
9804       (inputs
9805        `(("vom" ,sbcl-vom)))
9806       (native-inputs
9807        `(("cl-async" ,sbcl-cl-async)
9808          ("fiveam" ,sbcl-fiveam)))
9809       (synopsis "Promise implementation for Common Lisp")
9810       (description
9811        "This is a standalone promise implementation for Common Lisp.  It is
9812 the successor to the now-deprecated cl-async-future project.")
9813       (home-page "https://orthecreedence.github.io/blackbird/")
9814       (license license:expat))))
9815
9816 (define-public cl-blackbird
9817   (sbcl-package->cl-source-package sbcl-blackbird))
9818
9819 (define-public ecl-blackbird
9820   (sbcl-package->ecl-package sbcl-blackbird))
9821
9822 (define-public sbcl-cl-async-future
9823   (let ((commit "ee36c22a69a9516407458d2ed8b475f1fc473959")
9824         (revision "1"))
9825     (package
9826       (name "sbcl-cl-async-future")
9827       (version (git-version "0.4.4.1" revision commit))
9828       (source
9829        (origin
9830          (method git-fetch)
9831          (uri (git-reference
9832                (url "https://github.com/orthecreedence/cl-async-future.git")
9833                (commit commit)))
9834          (file-name (git-file-name name version))
9835          (sha256
9836           (base32
9837            "0z0sc7qlzzxk99f4l26zp6rai9kv0kj0f599sxai5s44p17zbbvh"))))
9838       (build-system asdf-build-system/sbcl)
9839       (inputs
9840        `(("blackbird" ,sbcl-blackbird)))
9841       (native-inputs
9842        `(("cl-async" ,sbcl-cl-async)
9843          ("eos" ,sbcl-eos)))
9844       (synopsis "Futures implementation for Common Lisp")
9845       (description
9846        "This is futures implementation for Common Lisp.  It plugs in nicely
9847 to cl-async.")
9848       (home-page "https://orthecreedence.github.io/cl-async/future")
9849       (license license:expat))))
9850
9851 (define-public cl-async-future
9852   (sbcl-package->cl-source-package sbcl-cl-async-future))
9853
9854 (define-public ecl-cl-async-future
9855   (sbcl-package->ecl-package sbcl-cl-async-future))
9856
9857 (define-public sbcl-green-threads
9858   (let ((commit "fff5ebecb441a37e5c511773716aafd84a3c5840")
9859         (revision "1"))
9860     (package
9861       (name "sbcl-green-threads")
9862       (version (git-version "0.3" revision commit))
9863       (source
9864        (origin
9865          (method git-fetch)
9866          (uri (git-reference
9867                (url "https://github.com/thezerobit/green-threads.git")
9868                (commit commit)))
9869          (file-name (git-file-name name version))
9870          (sha256
9871           (base32
9872            "1czw7nr0dwfps76h8hjvglk1wdh53yqbfbvv30whwbgqx33iippz"))))
9873       (build-system asdf-build-system/sbcl)
9874       (inputs
9875        `(("cl-async-future" ,sbcl-cl-async-future)
9876          ("cl-cont" ,sbcl-cl-cont)))
9877       (native-inputs
9878        `(("prove" ,sbcl-prove)))
9879       (arguments
9880        `(;; TODO: Fix the tests. They fail with:
9881          ;; "The function BLACKBIRD::PROMISE-VALUES is undefined"
9882          #:tests? #f
9883          #:phases
9884          (modify-phases %standard-phases
9885            (add-after 'unpack 'fix-tests
9886              (lambda _
9887                (substitute* "green-threads-test.asd"
9888                  (("cl-test-more")
9889                   "prove"))
9890                #t)))))
9891       (synopsis "Cooperative multitasking library for Common Lisp")
9892       (description
9893        "This library allows for cooperative multitasking with help of cl-cont
9894 for continuations.  It tries to mimic the API of bordeaux-threads as much as
9895 possible.")
9896       (home-page "https://github.com/thezerobit/green-threads")
9897       (license license:bsd-3))))
9898
9899 (define-public cl-green-threads
9900   (sbcl-package->cl-source-package sbcl-green-threads))
9901
9902 (define-public ecl-green-threads
9903   (sbcl-package->ecl-package sbcl-green-threads))
9904
9905 (define-public sbcl-cl-base32
9906   (let ((commit "8cdee06fab397f7b0a19583b57e7f0c98405be85")
9907         (revision "1"))
9908     (package
9909       (name "sbcl-cl-base32")
9910       (version (git-version "0.1" revision commit))
9911       (source
9912        (origin
9913          (method git-fetch)
9914          (uri (git-reference
9915                (url "https://github.com/hargettp/cl-base32.git")
9916                (commit commit)))
9917          (file-name (git-file-name name version))
9918          (sha256
9919           (base32 "17jrng8jb05d64ggyd11hp308c2fl5drvf9g175blgrkkl8l4mf8"))))
9920       (build-system asdf-build-system/sbcl)
9921       (native-inputs
9922        `(("lisp-unit" ,sbcl-lisp-unit)))
9923       (synopsis "Common Lisp library for base32 encoding and decoding")
9924       (description
9925        "This package provides functions for base32 encoding and decoding as
9926 defined in RFC4648.")
9927       (home-page "https://github.com/hargettp/cl-base32")
9928       (license license:expat))))
9929
9930 (define-public cl-base32
9931   (sbcl-package->cl-source-package sbcl-cl-base32))
9932
9933 (define-public ecl-cl-base32
9934   (sbcl-package->ecl-package sbcl-cl-base32))
9935
9936 (define-public sbcl-cl-z85
9937   (let ((commit "85b3951a9cfa2603acb6aee15567684f9a108098")
9938         (revision "1"))
9939     (package
9940       (name "sbcl-cl-z85")
9941       (version (git-version "1.0" revision commit))
9942       (source
9943        (origin
9944          (method git-fetch)
9945          (uri (git-reference
9946                (url "https://github.com/glv2/cl-z85.git")
9947                (commit commit)))
9948          (file-name (git-file-name name version))
9949          (sha256
9950           (base32 "0r27pidjaxbm7k1rr90nnajwl5xm2kp65g1fv0fva17lzy45z1mp"))))
9951       (build-system asdf-build-system/sbcl)
9952       (native-inputs
9953        `(("cl-octet-streams" ,sbcl-cl-octet-streams)
9954          ("fiveam" ,sbcl-fiveam)))
9955       (synopsis "Common Lisp library for Z85 encoding and decoding")
9956       (description
9957        "This package provides functions to encode or decode byte vectors or
9958 byte streams using the Z85 format, which is a base-85 encoding used by
9959 ZeroMQ.")
9960       (home-page "https://github.com/glv2/cl-z85")
9961       (license license:gpl3+))))
9962
9963 (define-public cl-z85
9964   (sbcl-package->cl-source-package sbcl-cl-z85))
9965
9966 (define-public ecl-cl-z85
9967   (sbcl-package->ecl-package sbcl-cl-z85))
9968
9969 (define-public sbcl-ltk
9970   (package
9971     (name "sbcl-ltk")
9972     (version "0.992")
9973     (source
9974      (origin
9975        (method git-fetch)
9976        (uri (git-reference
9977              (url "https://github.com/herth/ltk.git")
9978              (commit version)))
9979        (file-name (git-file-name name version))
9980        (sha256
9981         (base32 "13l2q4mskzilya9xh5wy2xvy30lwn104bd8wrq6ifds56r82iy3x"))))
9982     (build-system asdf-build-system/sbcl)
9983     (inputs
9984      `(("imagemagick" ,imagemagick)
9985        ("tk" ,tk)))
9986     (arguments
9987      `(#:asd-file "ltk/ltk.asd"
9988        #:tests? #f
9989        #:phases (modify-phases %standard-phases
9990                   (add-after 'unpack 'fix-paths
9991                     (lambda* (#:key inputs #:allow-other-keys)
9992                       (substitute* "ltk/ltk.lisp"
9993                         (("#-freebsd \"wish\"")
9994                          (string-append "#-freebsd \""
9995                                         (assoc-ref inputs "tk")
9996                                         "/bin/wish\""))
9997                         (("do-execute \"convert\"")
9998                          (string-append "do-execute \""
9999                                         (assoc-ref inputs "imagemagick")
10000                                         "/bin/convert\"")))
10001                       #t)))))
10002     (synopsis "Common Lisp bindings for the Tk GUI toolkit")
10003     (description
10004      "LTK is a Common Lisp binding for the Tk graphics toolkit.  It is written
10005 in pure Common Lisp and does not require any Tk knowledge for its usage.")
10006     (home-page "http://www.peter-herth.de/ltk/")
10007     (license license:llgpl)))
10008
10009 (define-public cl-ltk
10010   (sbcl-package->cl-source-package sbcl-ltk))
10011
10012 (define-public ecl-ltk
10013   (sbcl-package->ecl-package sbcl-ltk))
10014
10015 (define-public sbcl-ltk-mw
10016   (package
10017     (inherit sbcl-ltk)
10018     (name "sbcl-ltk-mw")
10019     (inputs
10020      `(("ltk" ,sbcl-ltk)))
10021     (arguments
10022      (substitute-keyword-arguments (package-arguments sbcl-ltk)
10023        ((#:asd-file _) "ltk/ltk-mw.asd")
10024        ((#:phases _) '%standard-phases)))
10025     (synopsis "Extra widgets for LTK")
10026     (description
10027      "This is a collection of higher-level widgets built on top of LTK.")))
10028
10029 (define-public cl-ltk-mw
10030   (sbcl-package->cl-source-package sbcl-ltk-mw))
10031
10032 (define-public ecl-ltk-mw
10033   (sbcl-package->ecl-package sbcl-ltk-mw))
10034
10035 (define-public sbcl-ltk-remote
10036   (package
10037     (inherit sbcl-ltk)
10038     (name "sbcl-ltk-remote")
10039     (inputs
10040      `(("ltk" ,sbcl-ltk)))
10041     (arguments
10042      (substitute-keyword-arguments (package-arguments sbcl-ltk)
10043        ((#:asd-file _) "ltk/ltk-remote.asd")
10044        ((#:phases _) '%standard-phases)))
10045     (synopsis "Remote GUI support for LTK")
10046     (description
10047      "This LTK extension allows the GUI to be displayed on a computer different
10048 from the one running the Lisp program by using a TCP connection.")))
10049
10050 (define-public cl-ltk-remote
10051   (sbcl-package->cl-source-package sbcl-ltk-remote))
10052
10053 (define-public sbcl-cl-lex
10054   (let ((commit "f2dbbe25ef553005fb402d9a6203180c3fa1093b")
10055         (revision "1"))
10056     (package
10057       (name "sbcl-cl-lex")
10058       (version (git-version "1.1.3" revision commit))
10059       (source
10060        (origin
10061          (method git-fetch)
10062          (uri (git-reference
10063                (url "https://github.com/djr7C4/cl-lex.git")
10064                (commit commit)))
10065          (file-name (git-file-name name version))
10066          (sha256
10067           (base32 "1kg50f76bfpfxcv4dfivq1n9a0xlsra2ajb0vd68lxwgbidgyc2y"))))
10068       (build-system asdf-build-system/sbcl)
10069       (inputs
10070        `(("cl-ppcre" ,sbcl-cl-ppcre)))
10071       (synopsis "Common Lisp macros for generating lexical analyzers")
10072       (description
10073        "This is a Common Lisp library providing a set of macros for generating
10074 lexical analyzers automatically.  The lexers generated using @code{cl-lex} can
10075 be used with @code{cl-yacc}.")
10076       (home-page "https://github.com/djr7C4/cl-lex")
10077       (license license:gpl3))))
10078
10079 (define-public cl-lex
10080   (sbcl-package->cl-source-package sbcl-cl-lex))
10081
10082 (define-public ecl-cl-lex
10083   (sbcl-package->ecl-package sbcl-cl-lex))
10084
10085 (define-public sbcl-clunit2
10086   (let ((commit "5e28343734eb9b7aee39306a614af92c1062d50b")
10087         (revision "1"))
10088     (package
10089       (name "sbcl-clunit2")
10090       (version (git-version "0.2.4" revision commit))
10091       (source
10092        (origin
10093          (method git-fetch)
10094          (uri (git-reference
10095                (url "https://notabug.org/cage/clunit2.git")
10096                (commit commit)))
10097          (file-name (git-file-name name version))
10098          (sha256
10099           (base32 "1ngiapfki6nm8a555mzhb5p7ch79i3w665za5bmb5j7q34fy80vw"))))
10100       (build-system asdf-build-system/sbcl)
10101       (synopsis "Unit testing framework for Common Lisp")
10102       (description
10103        "CLUnit is a Common Lisp unit testing framework.  It is designed to be
10104 easy to use so that you can quickly start testing.")
10105       (home-page "https://notabug.org/cage/clunit2")
10106       (license license:expat))))
10107
10108 (define-public cl-clunit2
10109   (sbcl-package->cl-source-package sbcl-clunit2))
10110
10111 (define-public ecl-clunit2
10112   (sbcl-package->ecl-package sbcl-clunit2))
10113
10114 (define-public sbcl-cl-colors2
10115   (let ((commit "795aedee593b095fecde574bd999b520dd03ed24")
10116         (revision "1"))
10117     (package
10118       (name "sbcl-cl-colors2")
10119       (version (git-version "0.2.1" revision commit))
10120       (source
10121        (origin
10122          (method git-fetch)
10123          (uri (git-reference
10124                (url "https://notabug.org/cage/cl-colors2.git")
10125                (commit commit)))
10126          (file-name (git-file-name name version))
10127          (sha256
10128           (base32 "0hlyf4h5chkjdp9armla5w4kw5acikk159sym7y8c4jbjp9x47ih"))))
10129       (build-system asdf-build-system/sbcl)
10130       (native-inputs
10131        `(("clunit2" ,sbcl-clunit2)))
10132       (inputs
10133        `(("alexandria" ,sbcl-alexandria)
10134          ("cl-ppcre" ,sbcl-cl-ppcre)))
10135       (synopsis "Color library for Common Lisp")
10136       (description
10137        "This is a very simple color library for Common Lisp, providing:
10138
10139 @itemize
10140 @item Types for representing colors in HSV and RGB spaces.
10141 @item Simple conversion functions between the above types (and also
10142 hexadecimal representation for RGB).
10143 @item Some predefined colors (currently X11 color names -- of course
10144 the library does not depend on X11).
10145 @end itemize\n")
10146       (home-page "https://notabug.org/cage/cl-colors2")
10147       (license license:boost1.0))))
10148
10149 (define-public cl-colors2
10150   (sbcl-package->cl-source-package sbcl-cl-colors2))
10151
10152 (define-public ecl-cl-colors2
10153   (sbcl-package->ecl-package sbcl-cl-colors2))
10154
10155 (define-public sbcl-cl-jpeg
10156   (let ((commit "ec557038128df6895fbfb743bfe8faf8ec2534af")
10157         (revision "1"))
10158     (package
10159       (name "sbcl-cl-jpeg")
10160       (version (git-version "2.8" revision commit))
10161       (source
10162        (origin
10163          (method git-fetch)
10164          (uri (git-reference
10165                (url "https://github.com/sharplispers/cl-jpeg.git")
10166                (commit commit)))
10167          (file-name (git-file-name name version))
10168          (sha256
10169           (base32 "1bkkiqz8fqldlj1wbmrccjsvxcwj98h6s4b6gslr3cg2wmdv5xmy"))))
10170       (build-system asdf-build-system/sbcl)
10171       (synopsis "JPEG image library for Common Lisp")
10172       (description
10173        "This is a baseline JPEG codec written in Common Lisp.  It can be used
10174 for reading and writing JPEG image files.")
10175       (home-page "https://github.com/sharplispers/cl-jpeg")
10176       (license license:bsd-3))))
10177
10178 (define-public cl-jpeg
10179   (sbcl-package->cl-source-package sbcl-cl-jpeg))
10180
10181 (define-public ecl-cl-jpeg
10182   (sbcl-package->ecl-package sbcl-cl-jpeg))
10183
10184 (define-public sbcl-nodgui
10185   (let ((commit "bc59ed9b787dfc9e68ae3bd7f7e8507c5c619212")
10186         (revision "1"))
10187     (package
10188       (name "sbcl-nodgui")
10189       (version (git-version "0.0.5" revision commit))
10190       (source
10191        (origin
10192          (method git-fetch)
10193          (uri (git-reference
10194                (url "https://notabug.org/cage/nodgui.git")
10195                (commit commit)))
10196          (file-name (git-file-name name version))
10197          (sha256
10198           (base32 "0xx0dk54d882i598ydnwmy7mnfk0b7vib3ddsgpqxhjck1rwq8l8"))))
10199       (build-system asdf-build-system/sbcl)
10200       (inputs
10201        `(("alexandria" ,sbcl-alexandria)
10202          ("bordeaux-threads" ,sbcl-bordeaux-threads)
10203          ("cl-colors2" ,sbcl-cl-colors2)
10204          ("cl-jpeg" ,sbcl-cl-jpeg)
10205          ("cl-lex" ,sbcl-cl-lex)
10206          ("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)
10207          ("cl-unicode" ,sbcl-cl-unicode)
10208          ("cl-yacc" ,sbcl-cl-yacc)
10209          ("clunit2" ,sbcl-clunit2)
10210          ("named-readtables" ,sbcl-named-readtables)
10211          ("parse-number" ,sbcl-parse-number)
10212          ("tk" ,tk)))
10213       (arguments
10214        `(#:phases (modify-phases %standard-phases
10215                     (add-after 'unpack 'fix-paths
10216                       (lambda* (#:key inputs #:allow-other-keys)
10217                         (substitute* "src/wish-communication.lisp"
10218                           (("#-freebsd \"wish\"")
10219                            (string-append "#-freebsd \""
10220                                           (assoc-ref inputs "tk")
10221                                           "/bin/wish\"")))
10222                         #t)))))
10223       (synopsis "Common Lisp bindings for the Tk GUI toolkit")
10224       (description
10225        "Nodgui (@emph{No Drama GUI}) is a Common Lisp binding for the Tk GUI
10226 toolkit.  It also provides a few additional widgets more than the standard Tk
10227 ones.")
10228       (home-page "https://www.autistici.org/interzona/nodgui.html")
10229       (license license:llgpl))))
10230
10231 (define-public cl-nodgui
10232   (sbcl-package->cl-source-package sbcl-nodgui))
10233
10234 (define-public ecl-nodgui
10235   (sbcl-package->ecl-package sbcl-nodgui))
10236
10237 (define-public sbcl-salza2
10238   (package
10239     (name "sbcl-salza2")
10240     (version "2.0.9")
10241     (source
10242      (origin
10243        (method git-fetch)
10244        (uri (git-reference
10245              (url "https://github.com/xach/salza2.git")
10246              (commit (string-append "release-" version))))
10247        (file-name (git-file-name name version))
10248        (sha256
10249         (base32 "0p38rj4gq7j5k807php7hrz7l2zyyfshv8i9yms7i8lkgg3433ki"))))
10250     (build-system asdf-build-system/sbcl)
10251     (synopsis "Common Lisp library for zlib, deflate and gzip compression")
10252     (description
10253      "Salza2 is a Common Lisp library for creating compressed data in the zlib,
10254 deflate, or gzip data formats, described in RFC 1950, RFC 1951, and RFC 1952,
10255 respectively.")
10256     (home-page "https://www.xach.com/lisp/salza2/")
10257     (license license:bsd-2)))
10258
10259 (define-public cl-salza2
10260   (sbcl-package->cl-source-package sbcl-salza2))
10261
10262 (define-public ecl-salza2
10263   (sbcl-package->ecl-package sbcl-salza2))
10264
10265 (define-public sbcl-png-read
10266   (let ((commit "ec29f38a689972b9f1373f13bbbcd6b05deada88")
10267         (revision "1"))
10268     (package
10269       (name "sbcl-png-read")
10270       (version (git-version "0.3.1" revision commit))
10271       (source
10272        (origin
10273          (method git-fetch)
10274          (uri (git-reference
10275                (url "https://github.com/Ramarren/png-read.git")
10276                (commit commit)))
10277          (file-name (git-file-name name version))
10278          (sha256
10279           (base32 "0vyczbcwskrygrf1hgrsnk0jil8skmvf1kiaalw5jps4fjrfdkw0"))))
10280       (build-system asdf-build-system/sbcl)
10281       (inputs
10282        `(("babel" ,sbcl-babel)
10283          ("chipz" ,sbcl-chipz)
10284          ("iterate" ,sbcl-iterate)))
10285       (synopsis "PNG decoder for Common Lisp")
10286       (description "This is a Common Lisp library for reading PNG images.")
10287       (home-page "https://github.com/Ramarren/png-read")
10288       (license license:bsd-3))))
10289
10290 (define-public cl-png-read
10291   (sbcl-package->cl-source-package sbcl-png-read))
10292
10293 (define-public ecl-png-read
10294   (sbcl-package->ecl-package sbcl-png-read))
10295
10296 (define-public sbcl-zpng
10297   (package
10298     (name "sbcl-zpng")
10299     (version "1.2.2")
10300     (source
10301      (origin
10302        (method git-fetch)
10303        (uri (git-reference
10304              (url "https://github.com/xach/zpng.git")
10305              (commit (string-append "release-" version))))
10306        (file-name (git-file-name name version))
10307        (sha256
10308         (base32 "0b3ag3jhl3z7kdls3ahdsdxsfhhw5qrizk769984f4wkxhb69rcm"))))
10309     (build-system asdf-build-system/sbcl)
10310     (inputs
10311      `(("salza2" ,sbcl-salza2)))
10312     (synopsis "PNG encoder for Common Lisp")
10313     (description "This is a Common Lisp library for creating PNG images.")
10314     (home-page "https://www.xach.com/lisp/zpng/")
10315     (license license:bsd-2)))
10316
10317 (define-public cl-zpng
10318   (sbcl-package->cl-source-package sbcl-zpng))
10319
10320 (define-public ecl-zpng
10321   (sbcl-package->ecl-package sbcl-zpng))
10322
10323 (define-public sbcl-cl-qrencode
10324   (package
10325     (name "sbcl-cl-qrencode")
10326     (version "0.1.2")
10327     (source
10328      (origin
10329        (method git-fetch)
10330        (uri (git-reference
10331              (url "https://github.com/jnjcc/cl-qrencode.git")
10332              (commit (string-append "v" version))))
10333        (file-name (git-file-name name version))
10334        (sha256
10335         (base32 "1l5k131dchbf6cj8a8xqa731790p01p3qa1kdy2wa9dawy3ymkxr"))))
10336     (build-system asdf-build-system/sbcl)
10337     (native-inputs
10338      `(("lisp-unit" ,sbcl-lisp-unit)))
10339     (inputs
10340      `(("zpng" ,sbcl-zpng)))
10341     (synopsis "QR code encoder for Common Lisp")
10342     (description
10343      "This Common Lisp library provides function to make QR codes and to save
10344 them as PNG files.")
10345     (home-page "https://github.com/jnjcc/cl-qrencode")
10346     (license license:gpl2+)))
10347
10348 (define-public cl-qrencode
10349   (sbcl-package->cl-source-package sbcl-cl-qrencode))
10350
10351 (define-public ecl-cl-qrencode
10352   (sbcl-package->ecl-package sbcl-cl-qrencode))
10353
10354 (define-public sbcl-hdf5-cffi
10355   (let ((commit "5b5c88f191e470e4fe96b462334e3ce0806eed5c")
10356         (revision "1"))
10357     (package
10358       (name "sbcl-hdf5-cffi")
10359       (version (git-version "1.8.18" revision commit))
10360       (source
10361        (origin
10362          (method git-fetch)
10363          (uri (git-reference
10364                (url "https://github.com/hdfgroup/hdf5-cffi.git")
10365                (commit commit)))
10366          (file-name (git-file-name name version))
10367          (sha256
10368           (base32
10369            "0vda3075423xz83qky998lpac5b04dwfv7bwgh9jq8cs5v0zrxjf"))))
10370       (build-system asdf-build-system/sbcl)
10371       (synopsis "Common Lisp bindings for the HDF5 library")
10372       (description
10373        "@code{hdf5-cffi} is a CFFI wrapper for the HDF5 library.")
10374       (home-page "https://github.com/hdfgroup/hdf5-cffi")
10375       (license (license:non-copyleft
10376                 (string-append "https://github.com/HDFGroup/hdf5-cffi/raw/"
10377                                commit
10378                                "/LICENSE")))
10379       (inputs
10380        `(("cffi" ,sbcl-cffi)
10381          ("cffi-grovel" ,sbcl-cffi-grovel)
10382          ("hdf5" ,hdf5-1.10)))
10383       (native-inputs
10384        `(("fiveam" ,sbcl-fiveam)))
10385       (arguments
10386        `(#:asd-system-name "hdf5-cffi"
10387          #:asd-file "hdf5-cffi.asd"
10388          #:test-asd-file "hdf5-cffi.test.asd"
10389          ;; Tests depend on hdf5-cffi.examples.asd in addition to hdf5-cffi.asd,
10390          ;; I don't know if there is a way to tell asdf-build-system to load
10391          ;; an additional system first, so tests are disabled.
10392          #:tests? #f
10393          #:phases
10394          (modify-phases %standard-phases
10395            (add-after 'unpack 'fix-paths
10396              (lambda* (#:key inputs #:allow-other-keys)
10397                (substitute* "src/library.lisp"
10398                  (("libhdf5.so")
10399                   (string-append
10400                    (assoc-ref inputs "hdf5")
10401                    "/lib/libhdf5.so")))))
10402            (add-after 'unpack 'fix-dependencies
10403              (lambda* (#:key inputs #:allow-other-keys)
10404                (substitute* "hdf5-cffi.asd"
10405                  ((":depends-on \\(:cffi\\)")
10406                   ":depends-on (:cffi :cffi-grovel)"))
10407                (substitute* "hdf5-cffi.test.asd"
10408                  ((":depends-on \\(:cffi :hdf5-cffi")
10409                   ":depends-on (:cffi :cffi-grovel :hdf5-cffi"))))))))))
10410
10411 (define-public cl-hdf5-cffi
10412   (sbcl-package->cl-source-package sbcl-hdf5-cffi))
10413
10414 (define-public ecl-hdf5-cffi
10415   (sbcl-package->ecl-package sbcl-hdf5-cffi))
10416
10417 (define-public sbcl-cl-randist
10418   (package
10419     (name "sbcl-cl-randist")
10420     (version "0.4.2")
10421     (source
10422      (origin
10423        (method git-fetch)
10424        (uri (git-reference
10425              (url "https://github.com/lvaruzza/cl-randist.git")
10426              (commit "f088a54b540a7adefab7c04094a6103f9edda3d0")))
10427        (file-name (git-file-name name version))
10428        (sha256
10429         (base32
10430          "0l8hyd6nbxb7f50vyxz3rbbm7kgr1fnadc40jywy4xj5vi5kpj5g"))))
10431     (build-system asdf-build-system/sbcl)
10432     (synopsis "Random distributions for Common Lisp")
10433     (description
10434      "Manual translation from C to Common Lisp of some random number
10435 generation functions from the GSL library.")
10436     (home-page "https://github.com/lvaruzza/cl-randist")
10437     (license license:bsd-2)
10438     (arguments
10439      `(#:asd-system-name "cl-randist"
10440        #:asd-file "cl-randist.asd"
10441        #:tests? #f))))
10442
10443 (define-public cl-randist
10444   (sbcl-package->cl-source-package sbcl-cl-randist))
10445
10446 (define-public ecl-cl-randist
10447   (sbcl-package->ecl-package sbcl-cl-randist))
10448
10449 (define-public sbcl-float-features
10450   (package
10451     (name "sbcl-float-features")
10452     (version "1.0.0")
10453     (source
10454      (origin
10455        (method git-fetch)
10456        (uri (git-reference
10457              (url "https://github.com/Shinmera/float-features.git")
10458              (commit "d3ef60181635b0849aa28cfc238053b7ca4644b0")))
10459        (file-name (git-file-name name version))
10460        (sha256
10461         (base32
10462          "0yj419k7n59x6rh3grwr6frgwwyria2il6f7wxpfazm8cskv4lzr"))))
10463     (build-system asdf-build-system/sbcl)
10464     (synopsis "Common Lisp IEEE float portability library")
10465     (description
10466      "Portability library for IEEE float features that are not
10467 covered by the Common Lisp standard.")
10468     (home-page "https://github.com/Shinmera/float-features")
10469     (license license:zlib)
10470     (inputs
10471      `(("documentation-utils" ,sbcl-documentation-utils)))
10472     (arguments
10473      `(#:asd-system-name "float-features"
10474        #:asd-file "float-features.asd"
10475        #:tests? #f))))
10476
10477 (define-public cl-float-features
10478   (sbcl-package->cl-source-package sbcl-float-features))
10479
10480 (define-public ecl-float-features
10481   (sbcl-package->ecl-package sbcl-float-features))
10482
10483 (define-public sbcl-function-cache
10484   (package
10485     (name "sbcl-function-cache")
10486     (version "1.0.3")
10487     (source
10488      (origin
10489        (method git-fetch)
10490        (uri (git-reference
10491              (url "https://github.com/AccelerationNet/function-cache.git")
10492              (commit "6a5ada401e57da2c8abf046f582029926e61fce8")))
10493        (file-name (git-file-name name version))
10494        (sha256
10495         (base32
10496          "000vmd3f5rx5hs9nvphfric0gkzaadns31c6mxaslpv0k7pkrmc6"))))
10497     (build-system asdf-build-system/sbcl)
10498     (synopsis "Function caching / memoization library for Common Lisp")
10499     (description
10500      "A common lisp library that provides extensible function result
10501 caching based on arguments (an expanded form of memoization).")
10502     (home-page "https://github.com/AccelerationNet/function-cache")
10503     (license
10504      (license:non-copyleft
10505       "https://github.com/AccelerationNet/function-cache/blob/master/README.md"))
10506     (inputs
10507      `(("alexandria" ,sbcl-alexandria)
10508        ("cl-interpol" ,sbcl-cl-interpol)
10509        ("iterate" ,sbcl-iterate)
10510        ("symbol-munger" ,sbcl-symbol-munger)
10511        ("closer-mop" ,sbcl-closer-mop)))
10512     (arguments
10513      `(#:asd-system-name "function-cache"
10514        #:asd-file "function-cache.asd"
10515        #:tests? #f))))
10516
10517 (define-public cl-function-cache
10518   (sbcl-package->cl-source-package sbcl-function-cache))
10519
10520 (define-public ecl-function-cache
10521   (sbcl-package->ecl-package sbcl-function-cache))
10522
10523 (define-public sbcl-type-r
10524   (let ((commit "83c89e38f2f7a7b16f1012777ecaf878cfa6a267")
10525         (revision "1"))
10526     (package
10527       (name "sbcl-type-r")
10528       (version (git-version "0.0.0" revision commit))
10529       (source
10530        (origin
10531          (method git-fetch)
10532          (uri (git-reference
10533                (url "https://github.com/guicho271828/type-r.git")
10534                (commit commit)))
10535          (file-name (git-file-name name version))
10536          (sha256
10537           (base32
10538            "1arsxc2539rg8vbrdirz4xxj1b06mc6g6rqndz7a02g127qvk2sm"))))
10539       (build-system asdf-build-system/sbcl)
10540       (synopsis "Parser interface for Common Lisp built-in compound types")
10541       (description
10542        "Collections of accessor functions and patterns to access
10543 the elements in compound type specifier, e.g. @code{dimensions} in
10544 @code{(array element-type dimensions)}")
10545       (home-page "https://github.com/guicho271828/type-r")
10546       (license license:lgpl3+)
10547       (inputs
10548        `(("trivia" ,sbcl-trivia)
10549          ("alexandria" ,sbcl-alexandria)))
10550       (native-inputs
10551        `(("fiveam" ,sbcl-fiveam)))
10552       (arguments
10553        `(#:asd-system-name "type-r"
10554          #:asd-file "type-r.asd"
10555          #:test-asd-file "type-r.test.asd")))))
10556
10557 (define-public cl-type-r
10558   (sbcl-package->cl-source-package sbcl-type-r))
10559
10560 (define-public sbcl-trivialib-type-unify
10561   (let ((commit "62492ebf04db567dcf435ae84c50b7b8202ecf99")
10562         (revision "1"))
10563     (package
10564       (name "sbcl-trivialib-type-unify")
10565       (version (git-version "0.1" revision commit))
10566       (source
10567        (origin
10568          (method git-fetch)
10569          (uri (git-reference
10570                (url "https://github.com/guicho271828/trivialib.type-unify.git")
10571                (commit commit)))
10572          (file-name (git-file-name name version))
10573          (sha256
10574           (base32
10575            "1bkyfzbwv75p50zp8n1n9rh2r29pw3vgz91gmn2gzzkyq3khj1vh"))))
10576       (build-system asdf-build-system/sbcl)
10577       (synopsis "Common Lisp type unification")
10578       (description
10579        "Unifies a parametrized type specifier against an actual type specifier.
10580 Importantly, it handles complicated array-subtypes and number-related types
10581 correctly.")
10582       (home-page "https://github.com/guicho271828/trivialib.type-unify")
10583       (license license:lgpl3+)
10584       (inputs
10585        `(("alexandria" ,sbcl-alexandria)
10586          ("trivia" ,sbcl-trivia)
10587          ("introspect-environment" ,sbcl-introspect-environment)
10588          ("type-r" ,sbcl-type-r)))
10589       (native-inputs
10590        `(("fiveam" ,sbcl-fiveam)))
10591       (arguments
10592        `(#:asd-system-name "trivialib.type-unify"
10593          #:asd-file "trivialib.type-unify.asd"
10594          #:test-asd-file "trivialib.type-unify.test.asd")))))
10595
10596 (define-public cl-trivialib-type-unify
10597   (sbcl-package->cl-source-package sbcl-trivialib-type-unify))
10598
10599 (define-public sbcl-specialized-function
10600   (let ((commit "b96b6afaf8358bf91cc0703e62a5a4ee20d2b7bc")
10601         (revision "1"))
10602     (package
10603       (name "sbcl-specialized-function")
10604       (version (git-version "0.0.0" revision commit))
10605       (source
10606        (origin
10607          (method git-fetch)
10608          (uri (git-reference
10609                (url "https://github.com/numcl/specialized-function.git")
10610                (commit commit)))
10611          (file-name (git-file-name name version))
10612          (sha256
10613           (base32
10614            "12j45ff0n26578vmfbhb9mfbdchw4wy023k0m2ppgl9s0z4bhjaj"))))
10615       (build-system asdf-build-system/sbcl)
10616       (synopsis "Julia-like dispatch for Common Lisp")
10617       (description
10618        "This library is part of NUMCL.  It provides a macro
10619 @code{SPECIALIZED} that performs a Julia-like dispatch on the arguments,
10620 lazily compiling a type-specific version of the function from the same
10621 code.  The main target of this macro is speed.")
10622       (home-page "https://github.com/numcl/specialized-function")
10623       (license license:lgpl3+)
10624       (inputs
10625        `(("trivia" ,sbcl-trivia)
10626          ("alexandria" ,sbcl-alexandria)
10627          ("iterate" ,sbcl-iterate)
10628          ("lisp-namespace" ,sbcl-lisp-namespace)
10629          ("type-r" ,sbcl-type-r)
10630          ("trivial-cltl2" ,sbcl-trivial-cltl2)))
10631       (native-inputs
10632        `(("fiveam" ,sbcl-fiveam)))
10633       (arguments
10634        `(#:asd-system-name "specialized-function"
10635          #:asd-file "specialized-function.asd"
10636          #:test-asd-file "specialized-function.test.asd")))))
10637
10638 (define-public cl-specialized-function
10639   (sbcl-package->cl-source-package sbcl-specialized-function))
10640
10641 (define-public sbcl-constantfold
10642   (let ((commit "0ff1d97a3fbcb89264f6a2af6ce62b73e7b421f4")
10643         (revision "1"))
10644     (package
10645       (name "sbcl-constantfold")
10646       (version (git-version "0.1" revision commit))
10647       (source
10648        (origin
10649          (method git-fetch)
10650          (uri (git-reference
10651                (url "https://github.com/numcl/constantfold.git")
10652                (commit commit)))
10653          (file-name (git-file-name name version))
10654          (sha256
10655           (base32
10656            "153h0569z6bff1qbad0bdssplwwny75l7ilqwcfqfdvzsxf9jh06"))))
10657       (build-system asdf-build-system/sbcl)
10658       (synopsis "Support library for numcl")
10659       (description
10660        "Support library for numcl.  Registers a function as an
10661 additional form that is considered as a candidate for a constant.")
10662       (home-page "https://github.com/numcl/constantfold")
10663       (license license:lgpl3+)
10664       (inputs
10665        `(("trivia" ,sbcl-trivia)
10666          ("alexandria" ,sbcl-alexandria)
10667          ("iterate" ,sbcl-iterate)
10668          ("lisp-namespace" ,sbcl-lisp-namespace)))
10669       (native-inputs
10670        `(("fiveam" ,sbcl-fiveam)))
10671       (arguments
10672        `(#:asd-system-name "constantfold"
10673          #:asd-file "constantfold.asd"
10674          #:test-asd-file "constantfold.test.asd")))))
10675
10676 (define-public cl-constantfold
10677   (sbcl-package->cl-source-package sbcl-constantfold))
10678
10679 (define-public sbcl-gtype
10680   (let ((commit "42275e3606242ae91e9c8dfa30c18ced50a35b66")
10681         (revision "1"))
10682     (package
10683       (name "sbcl-gtype")
10684       (version (git-version "0.1" revision commit))
10685       (source
10686        (origin
10687          (method git-fetch)
10688          (uri (git-reference
10689                (url "https://github.com/numcl/gtype.git")
10690                (commit commit)))
10691          (file-name (git-file-name name version))
10692          (sha256
10693           (base32
10694            "1f56dba998v945jcxhha391557n6md1ql25b7icfwwfivhmlaa9b"))))
10695       (build-system asdf-build-system/sbcl)
10696       (synopsis "C++/Julia-like parametric types in Common Lisp")
10697       (description
10698        "Support library for numcl that provides Julia-like runtime parametric
10699 type correctness in Common Lisp.  It is based on CLtL2 extensions.")
10700       (home-page "https://github.com/numcl/gtype")
10701       (license license:lgpl3+)
10702       (inputs
10703        `(("trivialib.type-unify" ,sbcl-trivialib-type-unify)
10704          ("trivial-cltl2" ,sbcl-trivial-cltl2)
10705          ("trivia" ,sbcl-trivia)
10706          ("alexandria" ,sbcl-alexandria)
10707          ("iterate" ,sbcl-iterate)
10708          ("type-r" ,sbcl-type-r)))
10709       (native-inputs
10710        `(("fiveam" ,sbcl-fiveam)))
10711       (arguments
10712        `(#:asd-system-name "gtype"
10713          #:asd-file "gtype.asd"
10714          #:test-asd-file "gtype.test.asd")))))
10715
10716 (define-public cl-gtype
10717   (sbcl-package->cl-source-package sbcl-gtype))
10718
10719 (define-public sbcl-numcl
10720   (let ((commit "1cf7dfa59f763a24a501092870e9c5ee745d0c17")
10721         (revision "1"))
10722     (package
10723       (name "sbcl-numcl")
10724       (version (git-version "0.1.0" revision commit))
10725       (source
10726        (origin
10727          (method git-fetch)
10728          (uri (git-reference
10729                (url "https://github.com/numcl/numcl.git")
10730                (commit commit)))
10731          (file-name (git-file-name name version))
10732          (sha256
10733           (base32
10734            "0i3jby9hf4ii7blivgyza80g0vmjfhk8537i5i7kqqk0i5sdnym2"))))
10735       (build-system asdf-build-system/sbcl)
10736       (synopsis "Numpy clone in Common Lisp")
10737       (description
10738        "This is a Numpy clone in Common Lisp.  At the moment the
10739 library is written in pure Common Lisp, focusing more on correctness
10740 and usefulness, not speed.  Track the progress at
10741 @url{https://github.com/numcl/numcl/projects/1}.")
10742       (home-page "https://github.com/numcl/numcl")
10743       (license license:lgpl3+)
10744       (inputs
10745        `(("trivia" ,sbcl-trivia)
10746          ("alexandria" ,sbcl-alexandria)
10747          ("iterate" ,sbcl-iterate)
10748          ("lisp-namespace" ,sbcl-lisp-namespace)
10749          ("type-r" ,sbcl-type-r)
10750          ("constantfold" ,sbcl-constantfold)
10751          ("cl-randist" ,sbcl-cl-randist)
10752          ("float-features" ,sbcl-float-features)
10753          ("function-cache" ,sbcl-function-cache)
10754          ("specialized-function" ,sbcl-specialized-function)
10755          ("gtype" ,sbcl-gtype)))
10756       (native-inputs
10757        `(("fiveam" ,sbcl-fiveam)))
10758       (arguments
10759        `(#:asd-system-name "numcl"
10760          #:asd-file "numcl.asd"
10761          #:test-asd-file "numcl.test.asd")))))
10762
10763 (define-public cl-numcl
10764   (sbcl-package->cl-source-package sbcl-numcl))
10765
10766 (define-public sbcl-pzmq
10767   (let ((commit "7c7390eedc469d033c72dc497984d1536ee75826")
10768         (revision "1"))
10769     (package
10770       (name "sbcl-pzmq")
10771       (version (git-version "0.0.0" revision commit))
10772       (source
10773        (origin
10774          (method git-fetch)
10775          (uri (git-reference
10776                (url "https://github.com/orivej/pzmq.git")
10777                (commit commit)))
10778          (file-name (git-file-name name version))
10779          (sha256
10780           (base32 "0gmwzf7h90wa7v4wnk49g0hv2mdalljpwhyigxcb967wzv8lqci9"))))
10781       (build-system asdf-build-system/sbcl)
10782       (native-inputs
10783        `(("bordeaux-threads" ,sbcl-bordeaux-threads)
10784          ("fiveam" ,sbcl-fiveam)
10785          ("let-plus" ,sbcl-let-plus)))
10786       (inputs
10787        `(("cffi" ,sbcl-cffi)
10788          ("cffi-grovel" ,sbcl-cffi-grovel)
10789          ("zeromq" ,zeromq)))
10790       (arguments
10791        `(#:phases (modify-phases %standard-phases
10792                     (add-after 'unpack 'fix-paths
10793                       (lambda* (#:key inputs #:allow-other-keys)
10794                         (substitute* "c-api.lisp"
10795                           (("\"libzmq")
10796                            (string-append "\""
10797                                           (assoc-ref inputs "zeromq")
10798                                           "/lib/libzmq")))
10799                         #t)))))
10800       (synopsis "Common Lisp bindings for the ZeroMQ library")
10801       (description "This Common Lisp library provides bindings for the ZeroMQ
10802 lightweight messaging kernel.")
10803       (home-page "https://github.com/orivej/pzmq")
10804       (license license:unlicense))))
10805
10806 (define-public cl-pzmq
10807   (sbcl-package->cl-source-package sbcl-pzmq))
10808
10809 (define-public ecl-pzmq
10810   (sbcl-package->ecl-package sbcl-pzmq))
10811
10812 (define-public sbcl-clss
10813   (let ((revision "1")
10814         (commit "2a8e8615ab55870d4ca01928f3ed3bbeb4e75c8d"))
10815     (package
10816       (name "sbcl-clss")
10817       (version (git-version "0.3.1" revision commit))
10818       (source
10819        (origin
10820          (method git-fetch)
10821          (uri
10822           (git-reference
10823            (url "https://github.com/Shinmera/clss.git")
10824            (commit commit)))
10825          (sha256
10826           (base32 "0la4dbcda78x29szanylccrsljqrn9d1mhh569sqkyp44ni5fv91"))
10827          (file-name (git-file-name name version))))
10828       (inputs
10829        `(("array-utils" ,sbcl-array-utils)
10830          ("plump" ,sbcl-plump)))
10831       (build-system asdf-build-system/sbcl)
10832       (synopsis "DOM tree searching engine based on CSS selectors")
10833       (description "CLSS is a DOM traversal engine based on CSS
10834 selectors.  It makes use of the Plump-DOM and is used by lQuery.")
10835       (home-page "https://github.com/Shinmera/clss")
10836       (license license:zlib))))
10837
10838 (define-public cl-clss
10839   (sbcl-package->cl-source-package sbcl-clss))
10840
10841 (define-public ecl-clss
10842   (sbcl-package->ecl-package sbcl-clss))
10843
10844 (define-public sbcl-lquery
10845   (let ((revision "1")
10846         (commit "8048111c6b83956daa632e7a3ffbd8c9c203bd8d"))
10847     (package
10848       (name "sbcl-lquery")
10849       (version (git-version "3.2.1" revision commit))
10850       (source
10851        (origin
10852          (method git-fetch)
10853          (uri
10854           (git-reference
10855            (url "https://github.com/Shinmera/lquery.git")
10856            (commit commit)))
10857          (sha256
10858           (base32 "0520mcpxc2d6fdm8z61arpgd2z38kan7cf06qs373n5r64rakz6w"))
10859          (file-name (git-file-name name version))))
10860       (native-inputs
10861        `(("fiveam" ,sbcl-fiveam)))
10862       (inputs
10863        `(("array-utils" ,sbcl-array-utils)
10864          ("form-fiddle" ,sbcl-form-fiddle)
10865          ("plump" ,sbcl-plump)
10866          ("clss" ,sbcl-clss)))
10867       (build-system asdf-build-system/sbcl)
10868       (synopsis "Library to allow jQuery-like HTML/DOM manipulation")
10869       (description "@code{lQuery} is a DOM manipulation library written in
10870 Common Lisp, inspired by and based on the jQuery syntax and
10871 functions.  It uses Plump and CLSS as DOM and selector engines.  The
10872 main idea behind lQuery is to provide a simple interface for crawling
10873 and modifying HTML sites, as well as to allow for an alternative
10874 approach to templating.")
10875       (home-page "https://github.com/Shinmera/lquery")
10876       (license license:zlib))))
10877
10878 (define-public cl-lquery
10879   (sbcl-package->cl-source-package sbcl-lquery))
10880
10881 (define-public ecl-lquery
10882   (sbcl-package->ecl-package sbcl-lquery))
10883
10884 (define-public sbcl-cl-mysql
10885   (let ((commit "ab56c279c1815aec6ca0bfe85164ff7e85cfb6f9")
10886         (revision "1"))
10887     (package
10888       (name "sbcl-cl-mysql")
10889       (version (git-version "0.1" revision commit))
10890       (source
10891        (origin
10892          (method git-fetch)
10893          (uri (git-reference
10894                (url "https://github.com/hackinghat/cl-mysql.git")
10895                (commit commit)))
10896          (file-name (git-file-name name version))
10897          (sha256
10898           (base32 "0dg5ynx2ww94d0qfwrdrm7plkn43h64hs4iiq9mj2s1s4ixnp3lr"))))
10899       (build-system asdf-build-system/sbcl)
10900       (native-inputs
10901        `(("stefil" ,sbcl-stefil)))
10902       (inputs
10903        `(("cffi" ,sbcl-cffi)
10904          ("mariadb-lib" ,mariadb "lib")))
10905       (arguments
10906        `(#:tests? #f ; TODO: Tests require a running server
10907          #:phases
10908          (modify-phases %standard-phases
10909            (add-after 'unpack 'fix-paths
10910              (lambda* (#:key inputs #:allow-other-keys)
10911                (substitute* "system.lisp"
10912                  (("libmysqlclient_r" all)
10913                   (string-append (assoc-ref inputs "mariadb-lib")
10914                                  "/lib/"
10915                                  all)))
10916                #t)))))
10917       (synopsis "Common Lisp wrapper for MySQL")
10918       (description
10919        "@code{cl-mysql} is a Common Lisp implementation of a MySQL wrapper.")
10920       (home-page "http://www.hackinghat.com/index.php/cl-mysql")
10921       (license license:expat))))
10922
10923 (define-public cl-mysql
10924   (sbcl-package->cl-source-package sbcl-cl-mysql))
10925
10926 (define-public sbcl-simple-date
10927   (let ((commit "74469b25bbda990ec9b77e0d0eccdba0cd7e721a")
10928         (revision "1"))
10929     (package
10930       (name "sbcl-simple-date")
10931       (version (git-version "1.19" revision commit))
10932       (source
10933        (origin
10934          (method git-fetch)
10935          (uri (git-reference
10936                (url "https://github.com/marijnh/Postmodern.git")
10937                (commit commit)))
10938          (file-name (git-file-name name version))
10939          (sha256
10940           (base32 "0im7ymnyxjhn2w74jfg76k5gpr0gl33n31akx33hl28722ljd0hd"))))
10941       (build-system asdf-build-system/sbcl)
10942       (native-inputs
10943        `(("fiveam" ,sbcl-fiveam)))
10944       (synopsis "Basic date and time objects for Common Lisp")
10945       (description
10946        "@code{simple-date} is a very basic implementation of date and time
10947 objects, used to support storing and retrieving time-related SQL types.")
10948       (home-page "https://marijnhaverbeke.nl/postmodern/")
10949       (license license:zlib))))
10950
10951 (define-public cl-simple-date
10952   (sbcl-package->cl-source-package sbcl-simple-date))
10953
10954 (define-public ecl-simple-date
10955   (sbcl-package->ecl-package sbcl-simple-date))
10956
10957 (define-public sbcl-cl-postgres
10958   (package
10959     (inherit sbcl-simple-date)
10960     (name "sbcl-cl-postgres")
10961     (native-inputs
10962      `(("fiveam" ,sbcl-fiveam)
10963        ("simple-date" ,sbcl-simple-date)))
10964     (inputs
10965      `(("md5" ,sbcl-md5)
10966        ("split-sequence" ,sbcl-split-sequence)
10967        ("usocket" ,sbcl-usocket)))
10968     (arguments
10969      `(#:tests? #f)) ; TODO: Break simple-date/postgres-glue circular dependency
10970     (synopsis "Common Lisp interface for PostgreSQL")
10971     (description
10972      "@code{cl-postgres} is a low-level library used for interfacing with
10973 a PostgreSQL server over a socket.")))
10974
10975 (define-public cl-postgres
10976   (sbcl-package->cl-source-package sbcl-cl-postgres))
10977
10978 (define-public sbcl-simple-date-postgres-glue
10979   (package
10980     (inherit sbcl-simple-date)
10981     (name "sbcl-simple-date-postgres-glue")
10982     (inputs
10983      `(("cl-postgres" ,sbcl-cl-postgres)
10984        ("simple-date" ,sbcl-simple-date)))
10985     (arguments
10986      `(#:asd-file "simple-date.asd"
10987        #:asd-system-name "simple-date/postgres-glue"))))
10988
10989 (define-public cl-simple-date-postgres-glue
10990   (sbcl-package->cl-source-package sbcl-simple-date-postgres-glue))
10991
10992 (define-public sbcl-s-sql
10993   (package
10994     (inherit sbcl-simple-date)
10995     (name "sbcl-s-sql")
10996     (inputs
10997      `(("alexandria" ,sbcl-alexandria)
10998        ("cl-postgres" ,sbcl-cl-postgres)))
10999     (arguments
11000      `(#:tests? #f)) ; TODO: Break postmodern circular dependency
11001     (synopsis "Lispy DSL for SQL")
11002     (description
11003      "@code{s-sql} is a Common Lisp library that can be used to compile
11004 s-expressions to strings of SQL code, escaping any Lisp values inside, and
11005 doing as much as possible of the work at compile time.")))
11006
11007 (define-public cl-s-sql
11008   (sbcl-package->cl-source-package sbcl-s-sql))
11009
11010 (define-public sbcl-postmodern
11011   (package
11012     (inherit sbcl-simple-date)
11013     (name "sbcl-postmodern")
11014     (native-inputs
11015      `(("fiveam" ,sbcl-fiveam)
11016        ("simple-date" ,sbcl-simple-date)
11017        ("simple-date-postgres-glue" ,sbcl-simple-date-postgres-glue)))
11018     (inputs
11019      `(("alexandria" ,sbcl-alexandria)
11020        ("bordeaux-threads" ,sbcl-bordeaux-threads)
11021        ("cl-postgres" ,sbcl-cl-postgres)
11022        ("closer-mop" ,sbcl-closer-mop)
11023        ("global-vars" ,sbcl-global-vars)
11024        ("s-sql" ,sbcl-s-sql)
11025        ("split-sequence" ,sbcl-split-sequence)))
11026     (arguments
11027      ;; TODO: Fix missing dependency errors for simple-date/postgres-glue,
11028      ;; cl-postgres/tests and s-sql/tests.
11029      `(#:tests? #f))
11030     (synopsis "Common Lisp library for interacting with PostgreSQL")
11031     (description
11032      "@code{postmodern} is a Common Lisp library for interacting with
11033 PostgreSQL databases.  It provides the following features:
11034
11035 @itemize
11036 @item Efficient communication with the database server without need for
11037 foreign libraries.
11038 @item Support for UTF-8 on Unicode-aware Lisp implementations.
11039 @item A syntax for mixing SQL and Lisp code.
11040 @item Convenient support for prepared statements and stored procedures.
11041 @item A metaclass for simple database-access objects.
11042 @end itemize\n")))
11043
11044 (define-public cl-postmodern
11045   (sbcl-package->cl-source-package sbcl-postmodern))
11046
11047 (define-public sbcl-dbi
11048   (package
11049     (name "sbcl-dbi")
11050     (version "0.9.4")
11051     (source
11052      (origin
11053        (method git-fetch)
11054        (uri (git-reference
11055              (url "https://github.com/fukamachi/cl-dbi.git")
11056              (commit version)))
11057        (file-name (git-file-name name version))
11058        (sha256
11059         (base32 "0m1fsravfaizamdak84adh3jxc4j91maqnrb4m08bfbmb04cdqhs"))))
11060     (build-system asdf-build-system/sbcl)
11061     (inputs
11062      `(("bordeaux-threads" ,sbcl-bordeaux-threads)
11063        ("closer-mop" ,sbcl-closer-mop)
11064        ("split-sequence" ,sbcl-split-sequence)))
11065     (arguments
11066      `(#:tests? #f)) ; TODO: Break circular dependency with dbd-*
11067     (synopsis "Database independent interface for Common Lisp")
11068     (description
11069      "@code{dbi} is a Common Lisp library providing a database independent
11070 interface for MySQL, PostgreSQL and SQLite.")
11071     (home-page "https://github.com/fukamachi/cl-dbi")
11072     (license license:llgpl)))
11073
11074 (define-public cl-dbi
11075   (sbcl-package->cl-source-package sbcl-dbi))
11076
11077 (define-public sbcl-dbd-mysql
11078   (package
11079    (inherit sbcl-dbi)
11080    (name "sbcl-dbd-mysql")
11081    (inputs
11082     `(("cl-mysql" ,sbcl-cl-mysql)
11083       ("dbi" ,sbcl-dbi)))
11084    (synopsis "Database driver for MySQL")))
11085
11086 (define-public cl-dbd-mysql
11087   (sbcl-package->cl-source-package sbcl-dbd-mysql))
11088
11089 (define-public sbcl-dbd-postgres
11090   (package
11091    (inherit sbcl-dbi)
11092    (name "sbcl-dbd-postgres")
11093    (inputs
11094     `(("cl-postgres" ,sbcl-cl-postgres)
11095       ("dbi" ,sbcl-dbi)
11096       ("trivial-garbage" ,sbcl-trivial-garbage)))
11097    (synopsis "Database driver for PostgreSQL")))
11098
11099 (define-public cl-dbd-postgres
11100   (sbcl-package->cl-source-package sbcl-dbd-postgres))
11101
11102 (define-public sbcl-dbd-sqlite3
11103   (package
11104    (inherit sbcl-dbi)
11105    (name "sbcl-dbd-sqlite3")
11106    (inputs
11107     `(("cl-sqlite" ,sbcl-cl-sqlite)
11108       ("dbi" ,sbcl-dbi)
11109       ("trivial-garbage" ,sbcl-trivial-garbage)))
11110    (synopsis "Database driver for SQLite3")))
11111
11112 (define-public cl-dbd-sqlite3
11113   (sbcl-package->cl-source-package sbcl-dbd-sqlite3))
11114
11115 (define-public sbcl-uffi
11116   (package
11117     (name "sbcl-uffi")
11118     (version "2.1.2")
11119     (source
11120      (origin
11121        (method git-fetch)
11122        (uri (git-reference
11123              (url "http://git.kpe.io/uffi.git")
11124              (commit (string-append "v" version))))
11125        (file-name (git-file-name name version))
11126        (sha256
11127         (base32 "1hqszvz0a3wk4s9faa83sc3vjxcb5rxmjclyr17yzwg55z733kry"))))
11128     (build-system asdf-build-system/sbcl)
11129     (arguments
11130      `(#:tests? #f ; TODO: Fix use of deprecated ASDF functions
11131        #:phases
11132        (modify-phases %standard-phases
11133          (add-after 'unpack 'fix-permissions
11134            (lambda _
11135              (make-file-writable "doc/html.tar.gz")
11136              #t)))))
11137     (synopsis "Universal foreign function library for Common Lisp")
11138     (description
11139      "UFFI provides a universal foreign function interface (FFI)
11140  for Common Lisp.")
11141     (home-page "http://quickdocs.org/uffi/")
11142     (license license:llgpl)))
11143
11144 (define-public cl-uffi
11145   (package
11146     (inherit (sbcl-package->cl-source-package sbcl-uffi))
11147     (arguments
11148      `(#:phases
11149        ;; asdf-build-system/source has its own phases and does not inherit
11150        ;; from asdf-build-system/sbcl phases.
11151        (modify-phases %standard-phases/source
11152          (add-after 'unpack 'fix-permissions
11153            (lambda _
11154              (make-file-writable "doc/html.tar.gz")
11155              #t)))))))
11156
11157 (define-public sbcl-clsql
11158   (package
11159     (name "sbcl-clsql")
11160     (version "6.7.0")
11161     (source
11162      (origin
11163        (method git-fetch)
11164        (uri (git-reference
11165              (url "http://git.kpe.io/clsql.git")
11166              (commit (string-append "v" version))))
11167        (file-name (git-file-name name version))
11168        (sha256
11169         (base32 "1v1k3s5bsy3lgd9gk459bzpb1r0kdjda25s29samxw4gsgf1fqvp"))
11170        (snippet
11171         '(begin
11172            ;; Remove precompiled libraries.
11173            (delete-file "db-mysql/clsql_mysql.dll")
11174            (delete-file "uffi/clsql_uffi.dll")
11175            (delete-file "uffi/clsql_uffi.lib")
11176            #t))))
11177     (build-system asdf-build-system/sbcl)
11178     (native-inputs
11179      `(("cffi-uffi-compat" ,sbcl-cffi-uffi-compat)
11180        ("rt" ,sbcl-rt)
11181        ("uffi" ,sbcl-uffi)))
11182     (arguments
11183      `(#:phases
11184        (modify-phases %standard-phases
11185          (add-after 'unpack 'fix-permissions
11186            (lambda _
11187              (make-file-writable "doc/html.tar.gz")
11188              #t))
11189          (add-after 'unpack 'fix-tests
11190            (lambda _
11191              (substitute* "clsql.asd"
11192                (("clsql-tests :force t")
11193                 "clsql-tests"))
11194              #t)))))
11195     (synopsis "Common Lisp SQL Interface library")
11196     (description
11197      "@code{clsql} is a Common Lisp interface to SQL RDBMS based on the
11198 Xanalys CommonSQL interface for Lispworks.  It provides low-level database
11199 interfaces as well as a functional and an object oriented interface.")
11200     (home-page "http://clsql.kpe.io/")
11201     (license license:llgpl)))
11202
11203 (define-public cl-clsql
11204   (package
11205     (inherit (sbcl-package->cl-source-package sbcl-clsql))
11206     (native-inputs
11207      `(("rt" ,cl-rt)))
11208     (inputs
11209      `(("mysql" ,mysql)
11210        ("postgresql" ,postgresql)
11211        ("sqlite" ,sqlite)
11212        ("zlib" ,zlib)))
11213     (propagated-inputs
11214      `(("cl-postgres" ,cl-postgres)
11215        ("cffi-uffi-compat" ,cl-cffi-uffi-compat)
11216        ("md5" ,cl-md5)
11217        ("uffi" ,cl-uffi)))
11218     (arguments
11219      `(#:phases
11220        ;; asdf-build-system/source has its own phases and does not inherit
11221        ;; from asdf-build-system/sbcl phases.
11222        (modify-phases %standard-phases/source
11223          (add-after 'unpack 'fix-permissions
11224            (lambda _
11225              (make-file-writable "doc/html.tar.gz")
11226              #t)))))))
11227
11228 (define-public sbcl-clsql-uffi
11229   (package
11230     (inherit sbcl-clsql)
11231     (name "sbcl-clsql-uffi")
11232     (inputs
11233      `(("cffi-uffi-compat" ,sbcl-cffi-uffi-compat)
11234        ("clsql" ,sbcl-clsql)
11235        ("uffi" ,sbcl-uffi)))
11236     (synopsis "UFFI helper functions for Common Lisp SQL interface library")))
11237
11238 (define-public sbcl-clsql-sqlite3
11239   (package
11240     (inherit sbcl-clsql)
11241     (name "sbcl-clsql-sqlite3")
11242     (inputs
11243      `(("clsql" ,sbcl-clsql)
11244        ("clsql-uffi" ,sbcl-clsql-uffi)
11245        ("sqlite" ,sqlite)))
11246     (arguments
11247      (substitute-keyword-arguments (package-arguments sbcl-clsql)
11248        ((#:phases phases '%standard-phases)
11249         `(modify-phases ,phases
11250            (add-after 'unpack 'fix-paths
11251              (lambda* (#:key inputs #:allow-other-keys)
11252                (substitute* "db-sqlite3/sqlite3-loader.lisp"
11253                  (("libsqlite3")
11254                   (string-append (assoc-ref inputs "sqlite")
11255                                  "/lib/libsqlite3")))
11256                #t))))))
11257     (synopsis "SQLite3 driver for Common Lisp SQL interface library")))
11258
11259 (define-public sbcl-clsql-postgresql
11260   (package
11261     (inherit sbcl-clsql)
11262     (name "sbcl-clsql-postgresql")
11263     (inputs
11264      `(("clsql" ,sbcl-clsql)
11265        ("clsql-uffi" ,sbcl-clsql-uffi)
11266        ("postgresql" ,postgresql)))
11267     (arguments
11268      (substitute-keyword-arguments (package-arguments sbcl-clsql)
11269        ((#:phases phases '%standard-phases)
11270         `(modify-phases ,phases
11271            (add-after 'unpack 'fix-paths
11272              (lambda* (#:key inputs #:allow-other-keys)
11273                (substitute* "db-postgresql/postgresql-loader.lisp"
11274                  (("libpq")
11275                   (string-append (assoc-ref inputs "postgresql")
11276                                  "/lib/libpq")))
11277                #t))))))
11278     (synopsis "PostgreSQL driver for Common Lisp SQL interface library")))
11279
11280 (define-public sbcl-clsql-postgresql-socket3
11281   (package
11282     (inherit sbcl-clsql)
11283     (name "sbcl-clsql-postgresql-socket3")
11284     (inputs
11285      `(("cl-postgres" ,sbcl-cl-postgres)
11286        ("clsql" ,sbcl-clsql)
11287        ("md5" ,sbcl-md5)))
11288     (arguments
11289      (substitute-keyword-arguments (package-arguments sbcl-clsql)
11290        ((#:phases phases '%standard-phases)
11291         `(modify-phases ,phases
11292            (add-after 'create-asd-file 'fix-asd-file
11293              (lambda* (#:key outputs #:allow-other-keys)
11294                (let* ((out (assoc-ref outputs "out"))
11295                       (lib (string-append out "/lib/" (%lisp-type)))
11296                       (asd (string-append lib "/clsql-postgresql-socket3.asd")))
11297                  (substitute* asd
11298                    (("CLSQL-POSTGRESQL-SOCKET-SYSTEM::")
11299                     "")))
11300                #t))))))
11301     (synopsis "PostgreSQL driver for Common Lisp SQL interface library")))
11302
11303 (define-public sbcl-clsql-mysql
11304   (package
11305     (inherit sbcl-clsql)
11306     (name "sbcl-clsql-mysql")
11307     (inputs
11308      `(("mysql" ,mysql)
11309        ("sbcl-clsql" ,sbcl-clsql)
11310        ("sbcl-clsql-uffi" ,sbcl-clsql-uffi)
11311        ("zlib" ,zlib)))
11312     (arguments
11313      (substitute-keyword-arguments (package-arguments sbcl-clsql)
11314        ((#:phases phases '%standard-phases)
11315         `(modify-phases ,phases
11316            (add-after 'unpack 'fix-paths
11317              (lambda* (#:key inputs outputs #:allow-other-keys)
11318                (let ((lib (string-append "#p\""
11319                                          (assoc-ref outputs "out")
11320                                          "/lib/\"")))
11321                  (substitute* "clsql-mysql.asd"
11322                    (("#p\"/usr/lib/clsql/clsql_mysql\\.so\"")
11323                     lib))
11324                  (substitute* "db-mysql/mysql-loader.lisp"
11325                    (("libmysqlclient" all)
11326                     (string-append (assoc-ref inputs "mysql") "/lib/" all))
11327                    (("clsql-mysql-system::\\*library-file-dir\\*")
11328                     lib)))
11329                #t))
11330            (add-before 'build 'build-helper-library
11331              (lambda* (#:key inputs outputs #:allow-other-keys)
11332                (let* ((mysql (assoc-ref inputs "mysql"))
11333                       (inc-dir (string-append mysql "/include/mysql"))
11334                       (lib-dir (string-append mysql "/lib"))
11335                       (shared-lib-dir (string-append (assoc-ref outputs "out")
11336                                                      "/lib"))
11337                       (shared-lib (string-append shared-lib-dir
11338                                                  "/clsql_mysql.so")))
11339                  (mkdir-p shared-lib-dir)
11340                  (invoke "gcc" "-fPIC" "-shared"
11341                          "-I" inc-dir
11342                          "db-mysql/clsql_mysql.c"
11343                          "-Wl,-soname=clsql_mysql"
11344                          "-L" lib-dir "-lmysqlclient" "-lz"
11345                          "-o" shared-lib)
11346                  #t)))))))
11347     (synopsis "MySQL driver for Common Lisp SQL interface library")))
11348
11349 (define-public sbcl-sycamore
11350   (let ((commit "fd2820fec165ad514493426dea209728f64e6d18"))
11351     (package
11352       (name "sbcl-sycamore")
11353       (version "0.0.20120604")
11354       (source
11355        (origin
11356          (method git-fetch)
11357          (uri (git-reference
11358                (url "https://github.com/ndantam/sycamore/")
11359                (commit commit)))
11360          (file-name (git-file-name name version))
11361          (sha256
11362           (base32 "00bv1aj89q5vldmq92zp2364jq312zjq2mbd3iyz1s2b4widzhl7"))))
11363       (build-system asdf-build-system/sbcl)
11364       (arguments
11365        `(#:asd-file "src/sycamore.asd"))
11366       (inputs
11367        `(("alexandria" ,sbcl-alexandria)
11368          ("cl-ppcre" ,sbcl-cl-ppcre)))
11369       (synopsis "Purely functional data structure library in Common Lisp")
11370       (description
11371        "Sycamore is a fast, purely functional data structure library in Common Lisp.
11372 If features:
11373
11374 @itemize
11375 @item Fast, purely functional weight-balanced binary trees.
11376 @item Leaf nodes are simple-vectors, greatly reducing tree height.
11377 @item Interfaces for tree Sets and Maps (dictionaries).
11378 @item Ropes.
11379 @item Purely functional pairing heaps.
11380 @item Purely functional amortized queue.
11381 @end itemize\n")
11382       (home-page "http://ndantam.github.io/sycamore/")
11383       (license license:bsd-3))))
11384
11385 (define-public cl-sycamore
11386   (sbcl-package->cl-source-package sbcl-sycamore))
11387
11388 (define-public sbcl-trivial-package-local-nicknames
11389   (package
11390     (name "sbcl-trivial-package-local-nicknames")
11391     (version "0.2")
11392     (home-page "https://github.com/phoe/trivial-package-local-nicknames")
11393     (source
11394      (origin
11395        (method git-fetch)
11396        (uri (git-reference
11397              (url home-page)
11398              (commit "16b7ad4c2b120f50da65154191f468ea5598460e")))
11399        (file-name (git-file-name name version))
11400        (sha256
11401         (base32 "18qc27xkjzdcqrilpk3pm7djldwq5rm3ggd5h9cr8hqcd54i2fqg"))))
11402     (build-system asdf-build-system/sbcl)
11403     (synopsis "Common Lisp compatibility library for package local nicknames")
11404     (description
11405      "This library is a portable compatibility layer around package local nicknames (PLN).
11406 This was done so there is a portability library for the PLN API not included
11407 in DEFPACKAGE.")
11408     (license license:unlicense)))
11409
11410 (define-public cl-trivial-package-local-nicknames
11411   (sbcl-package->cl-source-package sbcl-trivial-package-local-nicknames))
11412
11413 (define-public sbcl-enchant
11414   (let ((commit "6af162a7bf10541cbcfcfa6513894900329713fa"))
11415     (package
11416       (name "sbcl-enchant")
11417       (version (git-version "0.0.0" "1" commit))
11418       (home-page "https://github.com/tlikonen/cl-enchant")
11419       (source
11420        (origin
11421          (method git-fetch)
11422          (uri (git-reference
11423                (url home-page)
11424                (commit commit)))
11425          (file-name (git-file-name name version))
11426          (sha256
11427           (base32 "19yh5ihirzi1d8xqy1cjqipzd6ly3245cfxa5s9xx496rryz0s01"))))
11428       (build-system asdf-build-system/sbcl)
11429       (inputs
11430        `(("enchant" ,enchant)
11431          ("cffi" ,sbcl-cffi)))
11432       (arguments
11433        `(#:phases
11434          (modify-phases %standard-phases
11435            (add-after 'unpack 'fix-paths
11436              (lambda* (#:key inputs #:allow-other-keys)
11437                (substitute* "load-enchant.lisp"
11438                  (("libenchant")
11439                   (string-append
11440                    (assoc-ref inputs "enchant") "/lib/libenchant-2"))))))))
11441       (synopsis "Common Lisp interface for the Enchant spell-checker library")
11442       (description
11443        "Enchant is a Common Lisp interface for the Enchant spell-checker
11444 library.  The Enchant library is a generic spell-checker library which uses
11445 other spell-checkers transparently as back-end.  The library supports the
11446 multiple checkers, including Aspell and Hunspell.")
11447       (license license:public-domain))))
11448
11449 (define-public cl-enchant
11450   (sbcl-package->cl-source-package sbcl-enchant))
11451
11452 (define-public sbcl-cl-change-case
11453   (let ((commit "5ceff2a5f8bd845b6cb510c6364176b27a238fd3"))
11454     (package
11455       (name "sbcl-cl-change-case")
11456       (version (git-version "0.1.0" "1" commit))
11457       (home-page "https://github.com/rudolfochrist/cl-change-case")
11458       (source
11459        (origin
11460          (method git-fetch)
11461          (uri (git-reference
11462                (url home-page)
11463                (commit commit)))
11464          (file-name (git-file-name name version))
11465          (sha256
11466           (base32 "1afyglglk9z3yg8gylcl301bl2r8vq3sllyznzj9s5xi5gs6qyf2"))))
11467       (build-system asdf-build-system/sbcl)
11468       (inputs
11469        `(("cl-ppcre" ,sbcl-cl-ppcre)
11470          ("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)))
11471       (native-inputs
11472        `(("fiveam" ,sbcl-fiveam)))
11473       (arguments
11474        '(;; FIXME: Test pass but phase fails with 'Component
11475          ;; "cl-change-case-test" not found, required by'.
11476          #:tests? #f
11477          #:test-asd-file "cl-change-case-test.asd"))
11478       (synopsis "Convert Common Lisp strings between camelCase, PascalCase and more")
11479       (description
11480        "@code{cl-change-case} is library to convert strings between camelCase,
11481 PascalCase, snake_case, param-case, CONSTANT_CASE and more.")
11482       (license license:llgpl))))
11483
11484 (define-public cl-change-case
11485   (sbcl-package->cl-source-package sbcl-cl-change-case))
11486
11487 (define-public sbcl-moptilities
11488   (let ((commit "a436f16b357c96b82397ec018ea469574c10dd41"))
11489     (package
11490       (name "sbcl-moptilities")
11491       (version (git-version "0.3.13" "1" commit))
11492       (home-page "https://github.com/gwkkwg/moptilities/")
11493       (source
11494        (origin
11495          (method git-fetch)
11496          (uri (git-reference
11497                (url home-page)
11498                (commit commit)))
11499          (file-name (git-file-name name version))
11500          (sha256
11501           (base32 "1q12bqjbj47lx98yim1kfnnhgfhkl80102fkgp9pdqxg0fp6g5fc"))))
11502       (build-system asdf-build-system/sbcl)
11503       (inputs
11504        `(("closer-mop" ,sbcl-closer-mop)))
11505       (native-inputs
11506        `(("lift" ,sbcl-lift)))
11507       (synopsis "Compatibility layer for Common Lisp MOP implementation differences")
11508       (description
11509        "MOP utilities provide a common interface between Lisps and make the
11510 MOP easier to use.")
11511       (license license:expat))))
11512
11513 (define-public cl-moptilities
11514   (sbcl-package->cl-source-package sbcl-moptilities))
11515
11516 (define-public sbcl-osicat
11517   (let ((commit "de0c18a367eedc857e1902a7319828af072a0d97"))
11518     (package
11519       (name "sbcl-osicat")
11520       (version (git-version "0.7.0" "1" commit))
11521       (home-page "http://www.common-lisp.net/project/osicat/")
11522       (source
11523        (origin
11524          (method git-fetch)
11525          (uri (git-reference
11526                (url "https://github.com/osicat/osicat")
11527                (commit commit)))
11528          (file-name (git-file-name name version))
11529          (sha256
11530           (base32 "15viw5pi5sa7qq9b4n2rr3dj2jkqr180rh9z1lh8w3rgl42i2adc"))))
11531       (build-system asdf-build-system/sbcl)
11532       (arguments
11533        `(#:phases
11534          (modify-phases %standard-phases
11535            ;; The cleanup phase moves files around but we need to keep the
11536            ;; directory structure for the grovel-generated library.
11537            (replace 'cleanup
11538              (lambda* (#:key outputs #:allow-other-keys)
11539                (let* ((out (assoc-ref outputs "out"))
11540                       (lib (string-append out "/lib/sbcl/")))
11541                  (delete-file-recursively (string-append lib "src"))
11542                  (delete-file-recursively (string-append lib "tests"))
11543                  (for-each delete-file
11544                            (filter (lambda (file)
11545                                      (not (member (basename file) '("libosicat.so"))))
11546                                    (find-files (string-append lib "posix") ".*"))))
11547                #t)))))
11548       (inputs
11549        `(("alexandria" ,sbcl-alexandria)
11550          ("cffi" ,sbcl-cffi)
11551          ("trivial-features" ,sbcl-trivial-features)))
11552       (native-inputs
11553        `(("cffi-grovel" ,sbcl-cffi-grovel)
11554          ("rt" ,sbcl-rt)))
11555       (synopsis "Operating system interface for Common Lisp")
11556       (description
11557        "Osicat is a lightweight operating system interface for Common Lisp on
11558 Unix-platforms.  It is not a POSIX-style API, but rather a simple lispy
11559 accompaniment to the standard ANSI facilities.")
11560       (license license:expat))))
11561
11562 (define-public cl-osicat
11563   (sbcl-package->cl-source-package sbcl-osicat))