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 "412d17214e092220c65a5660f5cbbd9cb69b8fe4"))
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            "0n997yhcnzk048nalx8ys62ja2ac8iv4mbn3mb55iapl0321hghn"))))
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        ("bordeaux-threads" ,sbcl-bordeaux-threads)
2893        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2894     (arguments
2895      `(#:asd-file "glib/cl-cffi-gtk-glib.asd"
2896        #:phases
2897        (modify-phases %standard-phases
2898          (add-after 'unpack 'fix-paths
2899            (lambda* (#:key inputs #:allow-other-keys)
2900              (substitute* "glib/glib.init.lisp"
2901                (("libglib|libgthread" all)
2902                 (string-append (assoc-ref inputs "glib") "/lib/" all))))))))))
2903
2904 (define-public sbcl-cl-cffi-gtk-gobject
2905   (package
2906     (inherit sbcl-cl-cffi-gtk-boot0)
2907     (name "sbcl-cl-cffi-gtk-gobject")
2908     (inputs
2909      `(("glib" ,glib)
2910        ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
2911        ("trivial-garbage" ,sbcl-trivial-garbage)
2912        ("bordeaux-threads" ,sbcl-bordeaux-threads)
2913        ("closer-mop" ,sbcl-closer-mop)
2914        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2915     (arguments
2916      `(#:asd-file "gobject/cl-cffi-gtk-gobject.asd"
2917        #:phases
2918        (modify-phases %standard-phases
2919          (add-after 'unpack 'fix-paths
2920            (lambda* (#:key inputs #:allow-other-keys)
2921              (substitute* "gobject/gobject.init.lisp"
2922                (("libgobject" all) (string-append
2923                                     (assoc-ref inputs "glib") "/lib/" all)))))
2924          (add-after 'install 'link-source
2925            ;; Since source is particularly heavy (16MiB+), let's reuse it
2926            ;; across the different components of cl-ffi-gtk.
2927            (lambda* (#:key inputs outputs #:allow-other-keys)
2928              (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
2929                                                "/share/common-lisp/sbcl-source/"
2930                                                "cl-cffi-gtk-glib"))
2931                    (out-source (string-append (assoc-ref outputs "out")
2932                                               "/share/common-lisp/sbcl-source/"
2933                                               "cl-cffi-gtk-gobject")))
2934                (delete-file-recursively out-source)
2935                (symlink glib-source out-source)
2936                #t))))))))
2937
2938 (define-public sbcl-cl-cffi-gtk-gio
2939   (package
2940     (inherit sbcl-cl-cffi-gtk-boot0)
2941     (name "sbcl-cl-cffi-gtk-gio")
2942     (inputs
2943      `(("glib" ,glib)
2944        ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
2945        ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
2946        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2947     (arguments
2948      `(#:asd-file "gio/cl-cffi-gtk-gio.asd"
2949        #:phases
2950        (modify-phases %standard-phases
2951          (add-after 'unpack 'fix-paths
2952            (lambda* (#:key inputs #:allow-other-keys)
2953              (substitute* "gio/gio.init.lisp"
2954                (("libgio" all)
2955                 (string-append
2956                  (assoc-ref inputs "glib") "/lib/" all)))))
2957          (add-after 'install 'link-source
2958            ;; Since source is particularly heavy (16MiB+), let's reuse it
2959            ;; across the different components of cl-ffi-gtk.
2960            (lambda* (#:key inputs outputs #:allow-other-keys)
2961              (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
2962                                                "/share/common-lisp/sbcl-source/"
2963                                                "cl-cffi-gtk-glib"))
2964                    (out-source (string-append (assoc-ref outputs "out")
2965                                               "/share/common-lisp/sbcl-source/"
2966                                               "cl-cffi-gtk-gio")))
2967                (delete-file-recursively out-source)
2968                (symlink glib-source out-source)
2969                #t))))))))
2970
2971 (define-public sbcl-cl-cffi-gtk-cairo
2972   (package
2973     (inherit sbcl-cl-cffi-gtk-boot0)
2974     (name "sbcl-cl-cffi-gtk-cairo")
2975     (inputs
2976      `(("cairo" ,cairo)
2977        ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
2978        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2979     (arguments
2980      `(#:asd-file "cairo/cl-cffi-gtk-cairo.asd"
2981        #:phases
2982        (modify-phases %standard-phases
2983          (add-after 'unpack 'fix-paths
2984            (lambda* (#:key inputs #:allow-other-keys)
2985              (substitute* "cairo/cairo.init.lisp"
2986                (("libcairo" all)
2987                 (string-append
2988                  (assoc-ref inputs "cairo") "/lib/" all)))))
2989          (add-after 'install 'link-source
2990            ;; Since source is particularly heavy (16MiB+), let's reuse it
2991            ;; across the different components of cl-ffi-gtk.
2992            (lambda* (#:key inputs outputs #:allow-other-keys)
2993              (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
2994                                                "/share/common-lisp/sbcl-source/"
2995                                                "cl-cffi-gtk-glib"))
2996                    (out-source (string-append (assoc-ref outputs "out")
2997                                               "/share/common-lisp/sbcl-source/"
2998                                               "cl-cffi-gtk-cairo")))
2999                (delete-file-recursively out-source)
3000                (symlink glib-source out-source)
3001                #t))))))))
3002
3003 (define-public sbcl-cl-cffi-gtk-pango
3004   (package
3005     (inherit sbcl-cl-cffi-gtk-boot0)
3006     (name "sbcl-cl-cffi-gtk-pango")
3007     (inputs
3008      `(("pango" ,pango)
3009        ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
3010        ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
3011        ("cl-cffi-gtk-cairo" ,sbcl-cl-cffi-gtk-cairo)
3012        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
3013     (arguments
3014      `(#:asd-file "pango/cl-cffi-gtk-pango.asd"
3015        #:phases
3016        (modify-phases %standard-phases
3017          (add-after 'unpack 'fix-paths
3018            (lambda* (#:key inputs #:allow-other-keys)
3019              (substitute* "pango/pango.init.lisp"
3020                (("libpango" all)
3021                 (string-append
3022                  (assoc-ref inputs "pango") "/lib/" all)))))
3023          (add-after 'install 'link-source
3024            ;; Since source is particularly heavy (16MiB+), let's reuse it
3025            ;; across the different components of cl-ffi-gtk.
3026            (lambda* (#:key inputs outputs #:allow-other-keys)
3027              (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
3028                                                "/share/common-lisp/sbcl-source/"
3029                                                "cl-cffi-gtk-glib"))
3030                    (out-source (string-append (assoc-ref outputs "out")
3031                                               "/share/common-lisp/sbcl-source/"
3032                                               "cl-cffi-gtk-pango")))
3033                (delete-file-recursively out-source)
3034                (symlink glib-source out-source)
3035                #t))))))))
3036
3037 (define-public sbcl-cl-cffi-gtk-gdk-pixbuf
3038   (package
3039     (inherit sbcl-cl-cffi-gtk-boot0)
3040     (name "sbcl-cl-cffi-gtk-gdk-pixbuf")
3041     (inputs
3042      `(("gdk-pixbuf" ,gdk-pixbuf)
3043        ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
3044        ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
3045        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
3046     (arguments
3047      `(#:asd-file "gdk-pixbuf/cl-cffi-gtk-gdk-pixbuf.asd"
3048        #:phases
3049        (modify-phases %standard-phases
3050          (add-after 'unpack 'fix-paths
3051            (lambda* (#:key inputs #:allow-other-keys)
3052              (substitute* "gdk-pixbuf/gdk-pixbuf.init.lisp"
3053                (("libgdk_pixbuf" all)
3054                 (string-append
3055                  (assoc-ref inputs "gdk-pixbuf") "/lib/" all)))))
3056          (add-after 'install 'link-source
3057            ;; Since source is particularly heavy (16MiB+), let's reuse it
3058            ;; across the different components of cl-ffi-gtk.
3059            (lambda* (#:key inputs outputs #:allow-other-keys)
3060              (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
3061                                                "/share/common-lisp/sbcl-source/"
3062                                                "cl-cffi-gtk-glib"))
3063                    (out-source (string-append (assoc-ref outputs "out")
3064                                               "/share/common-lisp/sbcl-source/"
3065                                               "cl-cffi-gtk-gdk-pixbuf")))
3066                (delete-file-recursively out-source)
3067                (symlink glib-source out-source)
3068                #t))))))))
3069
3070 (define-public sbcl-cl-cffi-gtk-gdk
3071   (package
3072     (inherit sbcl-cl-cffi-gtk-boot0)
3073     (name "sbcl-cl-cffi-gtk-gdk")
3074     (inputs
3075      `(("gtk" ,gtk+)
3076        ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
3077        ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
3078        ("cl-cffi-gtk-gio" ,sbcl-cl-cffi-gtk-gio)
3079        ("cl-cffi-gtk-gdk-pixbuf" ,sbcl-cl-cffi-gtk-gdk-pixbuf)
3080        ("cl-cffi-gtk-cairo" ,sbcl-cl-cffi-gtk-cairo)
3081        ("cl-cffi-gtk-pango" ,sbcl-cl-cffi-gtk-pango)
3082        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
3083     (arguments
3084      `(#:asd-file "gdk/cl-cffi-gtk-gdk.asd"
3085        #:phases
3086        (modify-phases %standard-phases
3087          (add-after 'unpack 'fix-paths
3088            (lambda* (#:key inputs #:allow-other-keys)
3089              (substitute* "gdk/gdk.init.lisp"
3090                (("libgdk" all)
3091                 (string-append
3092                  (assoc-ref inputs "gtk") "/lib/" all)))
3093              (substitute* "gdk/gdk.package.lisp"
3094                (("libgtk" all)
3095                 (string-append
3096                  (assoc-ref inputs "gtk") "/lib/" all)))))
3097          (add-after 'install 'link-source
3098            ;; Since source is particularly heavy (16MiB+), let's reuse it
3099            ;; across the different components of cl-ffi-gtk.
3100            (lambda* (#:key inputs outputs #:allow-other-keys)
3101              (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
3102                                                "/share/common-lisp/sbcl-source/"
3103                                                "cl-cffi-gtk-glib"))
3104                    (out-source (string-append (assoc-ref outputs "out")
3105                                               "/share/common-lisp/sbcl-source/"
3106                                               "cl-cffi-gtk-gdk")))
3107                (delete-file-recursively out-source)
3108                (symlink glib-source out-source)
3109                #t))))))))
3110
3111 (define-public sbcl-cl-cffi-gtk
3112   (package
3113     (inherit sbcl-cl-cffi-gtk-boot0)
3114     (name "sbcl-cl-cffi-gtk")
3115     (inputs
3116      `(("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
3117        ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
3118        ("cl-cffi-gtk-gio" ,sbcl-cl-cffi-gtk-gio)
3119        ("cl-cffi-gtk-gdk" ,sbcl-cl-cffi-gtk-gdk)
3120        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
3121     (native-inputs
3122      `(("fiveam" ,sbcl-fiveam)))
3123     (arguments
3124      `(#:asd-file "gtk/cl-cffi-gtk.asd"
3125        #:test-asd-file "test/cl-cffi-gtk-test.asd"
3126        ;; TODO: Tests fail with memory fault.
3127        ;; See https://github.com/Ferada/cl-cffi-gtk/issues/24.
3128        #:tests? #f
3129        #:phases
3130        (modify-phases %standard-phases
3131          (add-after 'install 'link-source
3132            ;; Since source is particularly heavy (16MiB+), let's reuse it
3133            ;; across the different components of cl-ffi-gtk.
3134            (lambda* (#:key inputs outputs #:allow-other-keys)
3135              (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
3136                                                "/share/common-lisp/sbcl-source/"
3137                                                "cl-cffi-gtk-glib"))
3138                    (out-source (string-append (assoc-ref outputs "out")
3139                                               "/share/common-lisp/sbcl-source/"
3140                                               "cl-cffi-gtk")))
3141                (delete-file-recursively out-source)
3142                (symlink glib-source out-source)
3143                #t))))))))
3144
3145 (define-public cl-cffi-gtk
3146   (sbcl-package->cl-source-package sbcl-cl-cffi-gtk))
3147
3148 (define-public sbcl-cl-webkit
3149   (let ((commit "f93cb9697e8813068795fe4dc39ac950d814102d"))
3150     (package
3151       (name "sbcl-cl-webkit")
3152       (version (git-version "2.4" "3" commit))
3153       (source
3154        (origin
3155          (method git-fetch)
3156          (uri (git-reference
3157                (url "https://github.com/joachifm/cl-webkit")
3158                (commit commit)))
3159          (file-name (git-file-name "cl-webkit" version))
3160          (sha256
3161           (base32
3162            "1sjcw08kjpd5h83sms7zcq2nymddjygk9hm2rpgzrl524an9ziwc"))))
3163       (build-system asdf-build-system/sbcl)
3164       (inputs
3165        `(("cffi" ,sbcl-cffi)
3166          ("cl-cffi-gtk" ,sbcl-cl-cffi-gtk)
3167          ("webkitgtk" ,webkitgtk)))
3168       (arguments
3169        `(#:asd-file "webkit2/cl-webkit2.asd"
3170          #:asd-system-name "cl-webkit2"
3171          #:phases
3172          (modify-phases %standard-phases
3173            (add-after 'unpack 'fix-paths
3174              (lambda* (#:key inputs #:allow-other-keys)
3175                (substitute* "webkit2/webkit2.init.lisp"
3176                  (("libwebkit2gtk" all)
3177                   (string-append
3178                    (assoc-ref inputs "webkitgtk") "/lib/" all))))))))
3179       (home-page "https://github.com/joachifm/cl-webkit")
3180       (synopsis "Binding to WebKitGTK+ for Common Lisp")
3181       (description
3182        "@command{cl-webkit} is a binding to WebKitGTK+ for Common Lisp,
3183 currently targeting WebKit version 2.  The WebKitGTK+ library adds web
3184 browsing capabilities to an application, leveraging the full power of the
3185 WebKit browsing engine.")
3186       (license license:expat))))
3187
3188 (define-public cl-webkit
3189   (sbcl-package->cl-source-package sbcl-cl-webkit))
3190
3191 (define-public sbcl-lparallel
3192   (package
3193     (name "sbcl-lparallel")
3194     (version "2.8.4")
3195     (source
3196      (origin
3197        (method git-fetch)
3198        (uri (git-reference
3199              (url "https://github.com/lmj/lparallel/")
3200              (commit (string-append "lparallel-" version))))
3201        (file-name (git-file-name "lparallel" version))
3202        (sha256
3203         (base32
3204          "0g0aylrbbrqsz0ahmwhvnk4cmc2931fllbpcfgzsprwnqqd7vwq9"))))
3205     (build-system asdf-build-system/sbcl)
3206     (inputs
3207      `(("alexandria" ,sbcl-alexandria)
3208        ("bordeaux-threads" ,sbcl-bordeaux-threads)
3209        ("trivial-garbage" ,sbcl-trivial-garbage)))
3210     (home-page "https://lparallel.org/")
3211     (synopsis "Parallelism for Common Lisp")
3212     (description
3213      "@command{lparallel} is a library for parallel programming in Common
3214 Lisp, featuring:
3215
3216 @itemize
3217 @item a simple model of task submission with receiving queue,
3218 @item constructs for expressing fine-grained parallelism,
3219 @item asynchronous condition handling across thread boundaries,
3220 @item parallel versions of map, reduce, sort, remove, and many others,
3221 @item promises, futures, and delayed evaluation constructs,
3222 @item computation trees for parallelizing interconnected tasks,
3223 @item bounded and unbounded FIFO queues,
3224 @item high and low priority tasks,
3225 @item task killing by category,
3226 @item integrated timeouts.
3227 @end itemize\n")
3228     (license license:expat)))
3229
3230 (define-public cl-lparallel
3231   (sbcl-package->cl-source-package sbcl-lparallel))
3232
3233 (define-public ecl-lparallel
3234   (sbcl-package->ecl-package sbcl-lparallel))
3235
3236 (define-public sbcl-cl-markup
3237   (let ((commit "e0eb7debf4bdff98d1f49d0f811321a6a637b390"))
3238     (package
3239       (name "sbcl-cl-markup")
3240       (version (git-version "0.1" "1" commit))
3241       (source
3242        (origin
3243          (method git-fetch)
3244          (uri (git-reference
3245                (url "https://github.com/arielnetworks/cl-markup/")
3246                (commit commit)))
3247          (file-name (git-file-name "cl-markup" version))
3248          (sha256
3249           (base32
3250            "10l6k45971dl13fkdmva7zc6i453lmq9j4xax2ci6pjzlc6xjhp7"))))
3251       (build-system asdf-build-system/sbcl)
3252       (home-page "https://github.com/arielnetworks/cl-markup/")
3253       (synopsis "Markup generation library for Common Lisp")
3254       (description
3255        "A modern markup generation library for Common Lisp that features:
3256
3257 @itemize
3258 @item Fast (even faster through compiling the code)
3259 @item Safety
3260 @item Support for multiple document types (markup, xml, html, html5, xhtml)
3261 @item Output with doctype
3262 @item Direct output to stream
3263 @end itemize\n")
3264       (license license:lgpl3+))))
3265
3266 (define-public cl-markup
3267   (sbcl-package->cl-source-package sbcl-cl-markup))
3268
3269 (define-public ecl-cl-markup
3270   (sbcl-package->ecl-package sbcl-cl-markup))
3271
3272 (define-public sbcl-cl-css
3273   (let ((commit "8fe654c8f0cf95b300718101cce4feb517f78e2f"))
3274     (package
3275       (name "sbcl-cl-css")
3276       (version (git-version "0.1" "1" commit))
3277       (source
3278        (origin
3279          (method git-fetch)
3280          (uri (git-reference
3281                (url "https://github.com/inaimathi/cl-css/")
3282                (commit commit)))
3283          (file-name (git-file-name "cl-css" version))
3284          (sha256
3285           (base32
3286            "1lc42zi2sw11fl2589sc19nr5sd2p0wy7wgvgwaggxa5f3ajhsmd"))))
3287       (build-system asdf-build-system/sbcl)
3288       (home-page "https://github.com/inaimathi/cl-css/")
3289       (synopsis "Non-validating, inline CSS generator for Common Lisp")
3290       (description
3291        "This is a dead-simple, non validating, inline CSS generator for Common
3292 Lisp.  Its goals are axiomatic syntax, simple implementation to support
3293 portability, and boilerplate reduction in CSS.")
3294       (license license:expat))))
3295
3296 (define-public cl-css
3297   (sbcl-package->cl-source-package sbcl-cl-css))
3298
3299 (define-public ecl-cl-css
3300   (sbcl-package->ecl-package sbcl-cl-css))
3301
3302 (define-public sbcl-portable-threads
3303   (let ((commit "c0e61a1faeb0583c80fd3f20b16cc4c555226920"))
3304     (package
3305       (name "sbcl-portable-threads")
3306       (version (git-version "2.3" "1" commit))
3307       (source
3308        (origin
3309          (method git-fetch)
3310          (uri (git-reference
3311                (url "https://github.com/binghe/portable-threads/")
3312                (commit commit)))
3313          (file-name (git-file-name "portable-threads" version))
3314          (sha256
3315           (base32
3316            "03fmxyarc0xf4kavwkfa0a2spkyfrz6hbgbi9y4q7ny5aykdyfaq"))))
3317       (build-system asdf-build-system/sbcl)
3318       (arguments
3319        `(;; Tests seem broken.
3320          #:tests? #f))
3321       (home-page "https://github.com/binghe/portable-threads")
3322       (synopsis "Portable threads (and scheduled and periodic functions) API for Common Lisp")
3323       (description
3324        "Portable Threads (and Scheduled and Periodic Functions) API for Common
3325 Lisp (from GBBopen project).")
3326       (license license:asl2.0))))
3327
3328 (define-public cl-portable-threads
3329   (sbcl-package->cl-source-package sbcl-portable-threads))
3330
3331 (define-public ecl-portable-threada
3332   (sbcl-package->ecl-package sbcl-portable-threads))
3333
3334 (define sbcl-usocket-boot0
3335   ;; usocket's test rely on usocket-server which depends on usocket itself.
3336   ;; We break this cyclic dependency with -boot0 that packages usocket.
3337   (package
3338     (name "sbcl-usocket-boot0")
3339     (version "0.8.3")
3340     (source
3341      (origin
3342        (method git-fetch)
3343        (uri (git-reference
3344              (url "https://github.com/usocket/usocket/")
3345              (commit (string-append "v" version))))
3346        (file-name (git-file-name "usocket" version))
3347        (sha256
3348         (base32
3349          "0x746wr2324l6bn7skqzgkzcbj5kd0zp2ck0c8rldrw0rzabg826"))))
3350     (build-system asdf-build-system/sbcl)
3351     (inputs
3352      `(("split-sequence" ,sbcl-split-sequence)))
3353     (arguments
3354      `(#:tests? #f
3355        #:asd-system-name "usocket"))
3356     (home-page "https://common-lisp.net/project/usocket/")
3357     (synopsis "Universal socket library for Common Lisp (server side)")
3358     (description
3359      "This library strives to provide a portable TCP/IP and UDP/IP socket
3360 interface for as many Common Lisp implementations as possible, while keeping
3361 the abstraction and portability layer as thin as possible.")
3362     (license license:expat)))
3363
3364 (define-public sbcl-usocket-server
3365   (package
3366     (inherit sbcl-usocket-boot0)
3367     (name "sbcl-usocket-server")
3368     (inputs
3369      `(("bordeaux-threads" ,sbcl-bordeaux-threads)
3370        ("usocket" ,sbcl-usocket-boot0)))
3371     (arguments
3372      '(#:asd-system-name "usocket-server"))
3373     (synopsis "Universal socket library for Common Lisp (server side)")))
3374
3375 (define-public cl-usocket-server
3376   (sbcl-package->cl-source-package sbcl-usocket-server))
3377
3378 (define-public ecl-socket-server
3379   (sbcl-package->ecl-package sbcl-usocket-server))
3380
3381 (define-public sbcl-usocket
3382   (package
3383     (inherit sbcl-usocket-boot0)
3384     (name "sbcl-usocket")
3385     (arguments
3386      ;; FIXME: Tests need network access?
3387      `(#:tests? #f))
3388     (native-inputs
3389      ;; Testing only.
3390      `(("usocket-server" ,sbcl-usocket-server)
3391        ("rt" ,sbcl-rt)))))
3392
3393 (define-public cl-usocket
3394   (sbcl-package->cl-source-package sbcl-usocket))
3395
3396 (define-public ecl-usocket
3397   (sbcl-package->ecl-package sbcl-usocket))
3398
3399 (define-public sbcl-s-xml
3400   (package
3401     (name "sbcl-s-xml")
3402     (version "3")
3403     (source
3404      (origin
3405        (method url-fetch)
3406        (uri "https://common-lisp.net/project/s-xml/s-xml.tgz")
3407        (sha256
3408         (base32
3409          "061qcr0dzshsa38s5ma4ay924cwak2nq9gy59dw6v9p0qb58nzjf"))))
3410     (build-system asdf-build-system/sbcl)
3411     (home-page "https://common-lisp.net/project/s-xml/")
3412     (synopsis "Simple XML parser implemented in Common Lisp")
3413     (description
3414      "S-XML is a simple XML parser implemented in Common Lisp.  This XML
3415 parser implementation has the following features:
3416
3417 @itemize
3418 @item It works (handling many common XML usages).
3419 @item It is very small (the core is about 700 lines of code, including
3420 comments and whitespace).
3421 @item It has a core API that is simple, efficient and pure functional, much
3422 like that from SSAX (see also http://ssax.sourceforge.net).
3423 @item It supports different DOM models: an XSML-based one, an LXML-based one
3424 and a classic xml-element struct based one.
3425 @item It is reasonably time and space efficient (internally avoiding garbage
3426 generatation as much as possible).
3427 @item It does support CDATA.
3428 @item It should support the same character sets as your Common Lisp
3429 implementation.
3430 @item It does support XML name spaces.
3431 @end itemize
3432
3433 This XML parser implementation has the following limitations:
3434
3435 @itemize
3436 @item It does not support any special tags (like processing instructions).
3437 @item It is not validating, even skips DTD's all together.
3438 @end itemize\n")
3439     (license license:lgpl3+)))
3440
3441 (define-public cl-s-xml
3442   (sbcl-package->cl-source-package sbcl-s-xml))
3443
3444 (define-public ecl-s-xml
3445   (sbcl-package->ecl-package sbcl-s-xml))
3446
3447 (define-public sbcl-s-xml-rpc
3448   (package
3449     (name "sbcl-s-xml-rpc")
3450     (version "7")
3451     (source
3452      (origin
3453        (method url-fetch)
3454        (uri "https://common-lisp.net/project/s-xml-rpc/s-xml-rpc.tgz")
3455        (sha256
3456         (base32
3457          "02z7k163d51v0pzk8mn1xb6h5s6x64gjqkslhwm3a5x26k2gfs11"))))
3458     (build-system asdf-build-system/sbcl)
3459     (inputs
3460      `(("s-xml" ,sbcl-s-xml)))
3461     (home-page "https://common-lisp.net/project/s-xml-rpc/")
3462     (synopsis "Implementation of XML-RPC in Common Lisp for both client and server")
3463     (description
3464      "S-XML-RPC is an implementation of XML-RPC in Common Lisp for both
3465 client and server.")
3466     (license license:lgpl3+)))
3467
3468 (define-public cl-s-xml-rpc
3469   (sbcl-package->cl-source-package sbcl-s-xml-rpc))
3470
3471 (define-public ecl-s-xml-rpc
3472   (sbcl-package->ecl-package sbcl-s-xml-rpc))
3473
3474 (define-public sbcl-trivial-clipboard
3475   (let ((commit "5af3415d1484e6d69a1b5c178f24680d9fd01796"))
3476     (package
3477       (name "sbcl-trivial-clipboard")
3478       (version (git-version "0.0.0.0" "2" commit))
3479       (source
3480        (origin
3481          (method git-fetch)
3482          (uri (git-reference
3483                (url "https://github.com/snmsts/trivial-clipboard")
3484                (commit commit)))
3485          (file-name (git-file-name "trivial-clipboard" version))
3486          (sha256
3487           (base32
3488            "1gb515z5yq6h5548pb1fwhmb0hhq1ssyb78pvxh4alq799xipxs9"))))
3489       (build-system asdf-build-system/sbcl)
3490       (inputs
3491        `(("xclip" ,xclip)))
3492       (native-inputs
3493        `(("fiveam" ,sbcl-fiveam)))
3494       (arguments
3495        `(#:phases
3496          (modify-phases %standard-phases
3497            (add-after 'unpack 'fix-paths
3498              (lambda* (#:key inputs #:allow-other-keys)
3499                (substitute* "src/text.lisp"
3500                  (("\\(executable-find \"xclip\"\\)")
3501                   (string-append "(executable-find \""
3502                                  (assoc-ref inputs "xclip")
3503                                  "/bin/xclip\")"))))))))
3504       (home-page "https://github.com/snmsts/trivial-clipboard")
3505       (synopsis "Access system clipboard in Common Lisp")
3506       (description
3507        "@command{trivial-clipboard} gives access to the system clipboard.")
3508       (license license:expat))))
3509
3510 (define-public cl-trivial-clipboard
3511   (sbcl-package->cl-source-package sbcl-trivial-clipboard))
3512
3513 (define-public ecl-trivial-clipboard
3514   (sbcl-package->ecl-package sbcl-trivial-clipboard))
3515
3516 (define-public sbcl-trivial-backtrace
3517   (let ((commit "ca81c011b86424a381a7563cea3b924f24e6fbeb")
3518         (revision "1"))
3519     (package
3520      (name "sbcl-trivial-backtrace")
3521      (version (git-version "0.0.0" revision commit))
3522      (source
3523       (origin
3524        (method git-fetch)
3525        (uri (git-reference
3526              (url "https://github.com/gwkkwg/trivial-backtrace.git")
3527              (commit commit)))
3528        (file-name (git-file-name "trivial-backtrace" version))
3529        (sha256
3530         (base32 "10p41p43skj6cimdg8skjy7372s8v2xpkg8djjy0l8rm45i654k1"))))
3531      (build-system asdf-build-system/sbcl)
3532      (inputs
3533       `(("sbcl-lift" ,sbcl-lift)))
3534      (arguments
3535       `(#:phases
3536         (modify-phases %standard-phases
3537           (add-after 'check 'delete-test-results
3538             (lambda* (#:key outputs #:allow-other-keys)
3539               (let ((test-results (string-append (assoc-ref outputs "out")
3540                                                  "/share/common-lisp/"
3541                                                  (%lisp-type) "-source"
3542                                                  "/trivial-backtrace"
3543                                                  "/test-results")))
3544                 (when (file-exists? test-results)
3545                   (delete-file-recursively test-results)))
3546               #t)))))
3547      (home-page "https://common-lisp.net/project/trivial-backtrace/")
3548      (synopsis "Portable simple API to work with backtraces in Common Lisp")
3549      (description
3550       "On of the many things that didn't quite get into the Common Lisp
3551 standard was how to get a Lisp to output its call stack when something has
3552 gone wrong.  As such, each Lisp has developed its own notion of what to
3553 display, how to display it, and what sort of arguments can be used to
3554 customize it.  @code{trivial-backtrace} is a simple solution to generating a
3555 backtrace portably.")
3556      (license license:expat))))
3557
3558 (define-public cl-trivial-backtrace
3559   (sbcl-package->cl-source-package sbcl-trivial-backtrace))
3560
3561 (define-public sbcl-rfc2388
3562   (let ((commit "591bcf7e77f2c222c43953a80f8c297751dc0c4e")
3563         (revision "1"))
3564     (package
3565      (name "sbcl-rfc2388")
3566      (version (git-version "0.0.0" revision commit))
3567      (source
3568       (origin
3569        (method git-fetch)
3570        (uri (git-reference
3571              (url "https://github.com/jdz/rfc2388.git")
3572              (commit commit)))
3573        (file-name (git-file-name "rfc2388" version))
3574        (sha256
3575         (base32 "0phh5n3clhl9ji8jaxrajidn22d3f0aq87mlbfkkxlnx2pnw694k"))))
3576      (build-system asdf-build-system/sbcl)
3577      (home-page "https://github.com/jdz/rfc2388/")
3578      (synopsis "An implementation of RFC 2388 in Common Lisp")
3579      (description
3580       "This package contains an implementation of RFC 2388, which is used to
3581 process form data posted with HTTP POST method using enctype
3582 \"multipart/form-data\".")
3583      (license license:bsd-2))))
3584
3585 (define-public cl-rfc2388
3586   (sbcl-package->cl-source-package sbcl-rfc2388))
3587
3588 (define-public sbcl-md5
3589   (package
3590     (name "sbcl-md5")
3591     (version "2.0.4")
3592     (source
3593      (origin
3594        (method url-fetch)
3595        (uri (string-append
3596              "https://github.com/pmai/md5/archive/release-" version ".tar.gz"))
3597        (sha256
3598         (base32 "19yl9n0pjdz5gw4qi711lka97xcd9f81ylg434hk7jwn9f2s6w11"))))
3599     (build-system asdf-build-system/sbcl)
3600     (home-page "https://github.com/pmai/md5")
3601     (synopsis
3602      "Common Lisp implementation of the MD5 Message-Digest Algorithm (RFC 1321)")
3603     (description
3604      "This package implements The MD5 Message-Digest Algorithm, as defined in
3605 RFC 1321 by R. Rivest, published April 1992.")
3606     (license license:public-domain)))
3607
3608 (define-public cl-md5
3609   (sbcl-package->cl-source-package sbcl-md5))
3610
3611 (define-public sbcl-cl+ssl
3612   (let ((commit "141ae91416bc40f1618dc07e48429b84388aa599")
3613         (revision "1"))
3614     (package
3615       (name "sbcl-cl+ssl")
3616       (version (git-version "0.0.0" revision commit))
3617       (source
3618        (origin
3619          (method git-fetch)
3620          (uri (git-reference
3621                (url "https://github.com/cl-plus-ssl/cl-plus-ssl.git")
3622                (commit commit)))
3623          (file-name (git-file-name "cl+ssl" version))
3624          (sha256
3625           (base32 "1s0hg1h9sf8q89v0yrxmzg5f5sng29rgx3n21r9h9yql8351myan"))))
3626       (build-system asdf-build-system/sbcl)
3627       (arguments
3628        '(#:phases
3629          (modify-phases %standard-phases
3630            (add-after 'unpack 'fix-paths
3631              (lambda* (#:key inputs #:allow-other-keys)
3632                (substitute* "src/reload.lisp"
3633                  (("libssl.so" all)
3634                   (string-append
3635                    (assoc-ref inputs "openssl") "/lib/" all))))))))
3636       (inputs
3637        `(("openssl" ,openssl)
3638          ("sbcl-cffi" ,sbcl-cffi)
3639          ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)
3640          ("sbcl-flexi-streams" ,sbcl-flexi-streams)
3641          ("sbcl-bordeaux-threads" ,sbcl-bordeaux-threads)
3642          ("sbcl-trivial-garbage" ,sbcl-trivial-garbage)
3643          ("sbcl-alexandria" ,sbcl-alexandria)
3644          ("sbcl-trivial-features" ,sbcl-trivial-features)))
3645       (home-page "https://common-lisp.net/project/cl-plus-ssl/")
3646       (synopsis "Common Lisp bindings to OpenSSL")
3647       (description
3648        "This library is a fork of SSL-CMUCL.  The original SSL-CMUCL source
3649 code was written by Eric Marsden and includes contributions by Jochen Schmidt.
3650 Development into CL+SSL was done by David Lichteblau.")
3651       (license license:expat))))
3652
3653 (define-public cl-cl+ssl
3654   (sbcl-package->cl-source-package sbcl-cl+ssl))
3655
3656 (define-public sbcl-kmrcl
3657   (let ((version "1.109.0")
3658         (commit "5260068b2eb735af6796740c2db4955afac21636")
3659         (revision "1"))
3660     (package
3661       (name "sbcl-kmrcl")
3662       (version (git-version version revision commit))
3663       (source
3664        (origin
3665          (method git-fetch)
3666          (uri (git-reference
3667                (url "http://git.kpe.io/kmrcl.git/")
3668                (commit commit)))
3669          (file-name (git-file-name name version))
3670          (sha256
3671           (base32 "1va7xjgzfv674bpsli674i7zj3f7wg5kxic41kz18r6hh4n52dfv"))))
3672       (build-system asdf-build-system/sbcl)
3673       (arguments
3674        ;; Tests fail with: :FORCE and :FORCE-NOT arguments not allowed in a
3675        ;; nested call to ASDF/OPERATE:OPERATE unless identically to toplevel
3676        '(#:tests? #f))
3677       (inputs
3678        `(("sbcl-rt" ,sbcl-rt)))
3679       (home-page "http://files.kpe.io/kmrcl/")
3680       (synopsis "General utilities for Common Lisp programs")
3681       (description
3682        "KMRCL is a collection of utilities used by a number of Kevin
3683 Rosenberg's CL packages.")
3684       (license license:llgpl))))
3685
3686 (define-public cl-kmrcl
3687   (sbcl-package->cl-source-package sbcl-kmrcl))
3688
3689 (define-public sbcl-cl-base64
3690   (let ((version "3.3.3"))
3691     (package
3692       (name "sbcl-cl-base64")
3693       (version version)
3694       (source
3695        (origin
3696          (method git-fetch)
3697          (uri (git-reference
3698                (url "http://git.kpe.io/cl-base64.git")
3699                (commit (string-append "v" version))))
3700          (file-name (git-file-name "cl-base64" version))
3701          (sha256
3702           (base32 "1dw6j7n6gsd2qa0p0rbsjxj00acxx3i9ca1qkgl0liy8lpnwkypl"))))
3703       (build-system asdf-build-system/sbcl)
3704       (arguments
3705        ;; Tests fail with: :FORCE and :FORCE-NOT arguments not allowed
3706        ;; in a nested call to ASDF/OPERATE:OPERATE unless identically
3707        ;; to toplevel
3708        '(#:tests? #f))
3709       (inputs
3710        `(("sbcl-ptester" ,sbcl-ptester)
3711          ("sbcl-kmrcl" ,sbcl-kmrcl)))
3712       (home-page "http://files.kpe.io/cl-base64/")
3713       (synopsis
3714        "Common Lisp package to encode and decode base64 with URI support")
3715       (description
3716        "This package provides highly optimized base64 encoding and decoding.
3717 Besides conversion to and from strings, integer conversions are supported.
3718 Encoding with Uniform Resource Identifiers is supported by using a modified
3719 encoding table that uses only URI-compatible characters.")
3720       (license license:bsd-3))))
3721
3722 (define-public cl-base64
3723   (sbcl-package->cl-source-package sbcl-cl-base64))
3724
3725 (define-public sbcl-chunga
3726   (package
3727     (name "sbcl-chunga")
3728     (version "1.1.7")
3729     (source
3730      (origin
3731        (method git-fetch)
3732        (uri (git-reference
3733               (url "https://github.com/edicl/chunga.git")
3734               (commit (string-append "v" version))))
3735        (file-name (git-file-name name version))
3736        (sha256
3737         (base32 "0jzn3nyb3f22gm983rfk99smqs3mhb9ivjmasvhq9qla5cl9pyhd"))))
3738     (build-system asdf-build-system/sbcl)
3739     (inputs
3740      `(("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)))
3741     (home-page "https://edicl.github.io/chunga/")
3742     (synopsis "Portable chunked streams for Common Lisp")
3743     (description
3744      "Chunga implements streams capable of chunked encoding on demand as
3745 defined in RFC 2616.")
3746     (license license:bsd-2)))
3747
3748 (define-public cl-chunga
3749   (sbcl-package->cl-source-package sbcl-chunga))
3750
3751 (define-public sbcl-cl-who
3752   (let ((version "1.1.4")
3753         (commit "2c08caa4bafba720409af9171feeba3f32e86d32")
3754         (revision "1"))
3755     (package
3756       (name "sbcl-cl-who")
3757       (version (git-version version revision commit))
3758       (source
3759        (origin
3760          (method git-fetch)
3761          (uri (git-reference
3762                (url "https://github.com/edicl/cl-who.git")
3763                (commit commit)))
3764          (file-name (git-file-name name version))
3765          (sha256
3766           (base32
3767            "0yjb6sr3yazm288m318kqvj9xk8rm9n1lpimgf65ymqv0i5agxsb"))))
3768       (build-system asdf-build-system/sbcl)
3769       (native-inputs
3770        `(("sbcl-flexi-streams" ,sbcl-flexi-streams)))
3771       (home-page "https://edicl.github.io/cl-who/")
3772       (synopsis "Yet another Lisp markup language")
3773       (description
3774        "There are plenty of Lisp Markup Languages out there - every Lisp
3775 programmer seems to write at least one during his career - and CL-WHO (where
3776 WHO means \"with-html-output\" for want of a better acronym) is probably just
3777 as good or bad as the next one.")
3778       (license license:bsd-2))))
3779
3780 (define-public cl-cl-who
3781   (sbcl-package->cl-source-package sbcl-cl-who))
3782
3783 (define-public sbcl-chipz
3784   (let ((version "0.8")
3785         (commit "75dfbc660a5a28161c57f115adf74c8a926bfc4d")
3786         (revision "1"))
3787     (package
3788       (name "sbcl-chipz")
3789       (version (git-version version revision commit))
3790       (source
3791        (origin
3792          (method git-fetch)
3793          (uri (git-reference
3794                (url "https://github.com/froydnj/chipz.git")
3795                (commit commit)))
3796          (file-name (git-file-name name version))
3797          (sha256
3798           (base32
3799            "0plx4rs39zbs4gjk77h4a2q11zpy75fh9v8hnxrvsf8fnakajhwg"))))
3800       (build-system asdf-build-system/sbcl)
3801       (native-inputs
3802        `(("sbcl-flexi-streams" ,sbcl-flexi-streams)))
3803       (home-page "http://method-combination.net/lisp/chipz/")
3804       (synopsis
3805        "Common Lisp library for decompressing deflate, zlib, gzip, and bzip2
3806 data")
3807       (description
3808        "DEFLATE data, defined in RFC1951, forms the core of popular
3809 compression formats such as zlib (RFC 1950) and gzip (RFC 1952).  As such,
3810 Chipz also provides for decompressing data in those formats as well.  BZIP2 is
3811 the format used by the popular compression tool bzip2.")
3812       ;; The author describes it as "MIT-like"
3813       (license license:expat))))
3814
3815 (define-public cl-chipz
3816   (sbcl-package->cl-source-package sbcl-chipz))
3817
3818 (define-public sbcl-drakma
3819   (package
3820     (name "sbcl-drakma")
3821     (version "2.0.7")
3822     (source
3823      (origin
3824        (method git-fetch)
3825        (uri (git-reference
3826              (url "https://github.com/edicl/drakma.git")
3827              (commit (string-append "v" version))))
3828        (file-name (git-file-name name version))
3829        (sha256
3830         (base32
3831          "1441idnyif9xzx3ln1p3fg36k2v9h4wasjqrzc8y52j61420qpci"))))
3832     (build-system asdf-build-system/sbcl)
3833     (inputs
3834      `(("sbcl-puri" ,sbcl-puri)
3835        ("sbcl-cl-base64" ,sbcl-cl-base64)
3836        ("sbcl-chunga" ,sbcl-chunga)
3837        ("sbcl-flexi-streams" ,sbcl-flexi-streams)
3838        ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
3839        ("sbcl-chipz" ,sbcl-chipz)
3840        ("sbcl-usocket" ,sbcl-usocket)
3841        ("sbcl-cl+ssl" ,sbcl-cl+ssl)))
3842     (native-inputs
3843      `(("sbcl-fiveam" ,sbcl-fiveam)))
3844     (home-page "https://edicl.github.io/drakma/")
3845     (synopsis "HTTP client written in Common Lisp")
3846     (description
3847      "Drakma is a full-featured HTTP client implemented in Common Lisp.  It
3848 knows how to handle HTTP/1.1 chunking, persistent connections, re-usable
3849 sockets, SSL, continuable uploads, file uploads, cookies, and more.")
3850     (license license:bsd-2)))
3851
3852 (define-public cl-drakma
3853   (sbcl-package->cl-source-package sbcl-drakma))
3854
3855 (define-public ecl-drakma
3856   (sbcl-package->ecl-package sbcl-drakma))
3857
3858 (define-public sbcl-hunchentoot
3859   (package
3860     (name "sbcl-hunchentoot")
3861     (version "1.2.38")
3862     (source
3863      (origin
3864        (method git-fetch)
3865        (uri (git-reference
3866              (url "https://github.com/edicl/hunchentoot.git")
3867              (commit (string-append "v" version))))
3868        (file-name (git-file-name "hunchentoot" version))
3869        (sha256
3870         (base32 "1anpcad7w045m4rsjs1f3xdhjwx5cppq1h0vlb3q7dz81fi3i6yq"))))
3871     (build-system asdf-build-system/sbcl)
3872     (native-inputs
3873      `(("sbcl-cl-who" ,sbcl-cl-who)
3874        ("sbcl-drakma" ,sbcl-drakma)))
3875     (inputs
3876      `(("sbcl-chunga" ,sbcl-chunga)
3877        ("sbcl-cl-base64" ,sbcl-cl-base64)
3878        ("sbcl-cl-fad" ,sbcl-cl-fad)
3879        ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
3880        ("sbcl-flexi-streams" ,sbcl-flexi-streams)
3881        ("sbcl-cl+ssl" ,sbcl-cl+ssl)
3882        ("sbcl-md5" ,sbcl-md5)
3883        ("sbcl-rfc2388" ,sbcl-rfc2388)
3884        ("sbcl-trivial-backtrace" ,sbcl-trivial-backtrace)
3885        ("sbcl-usocket" ,sbcl-usocket)))
3886     (home-page "https://edicl.github.io/hunchentoot/")
3887     (synopsis "Web server written in Common Lisp")
3888     (description
3889      "Hunchentoot is a web server written in Common Lisp and at the same
3890 time a toolkit for building dynamic websites.  As a stand-alone web server,
3891 Hunchentoot is capable of HTTP/1.1 chunking (both directions), persistent
3892 connections (keep-alive), and SSL.")
3893     (license license:bsd-2)))
3894
3895 (define-public cl-hunchentoot
3896   (sbcl-package->cl-source-package sbcl-hunchentoot))
3897
3898 (define-public sbcl-trivial-types
3899   (package
3900     (name "sbcl-trivial-types")
3901     (version "0.0.1")
3902     (source
3903      (origin
3904        (method git-fetch)
3905        (uri (git-reference
3906              (url "https://github.com/m2ym/trivial-types.git")
3907              (commit "ee869f2b7504d8aa9a74403641a5b42b16f47d88")))
3908        (file-name (git-file-name name version))
3909        (sha256
3910         (base32 "1s4cp9bdlbn8447q7w7f1wkgwrbvfzp20mgs307l5pxvdslin341"))))
3911     (build-system asdf-build-system/sbcl)
3912     (home-page "https://github.com/m2ym/trivial-types")
3913     (synopsis "Trivial type definitions for Common Lisp")
3914     (description
3915      "TRIVIAL-TYPES provides missing but important type definitions such as
3916 PROPER-LIST, ASSOCIATION-LIST, PROPERTY-LIST and TUPLE.")
3917     (license license:llgpl)))
3918
3919 (define-public cl-trivial-types
3920   (sbcl-package->cl-source-package sbcl-trivial-types))
3921
3922 (define-public sbcl-cl-syntax
3923   (package
3924     (name "sbcl-cl-syntax")
3925     (version "0.0.3")
3926     (source
3927      (origin
3928        (method git-fetch)
3929        (uri (git-reference
3930              (url "https://github.com/m2ym/cl-syntax.git")
3931              (commit "03f0c329bbd55b8622c37161e6278366525e2ccc")))
3932        (file-name (git-file-name "cl-syntax" version))
3933        (sha256
3934         (base32 "17ran8xp77asagl31xv8w819wafh6whwfc9p6dgx22ca537gyl4y"))))
3935     (build-system asdf-build-system/sbcl)
3936     (arguments
3937      '(#:asd-file "cl-syntax.asd"
3938        #:asd-system-name "cl-syntax"))
3939     (inputs `(("sbcl-trivial-types" ,sbcl-trivial-types)
3940               ("sbcl-named-readtables" ,sbcl-named-readtables)))
3941     (home-page "https://github.com/m2ym/cl-syntax")
3942     (synopsis "Reader Syntax Coventions for Common Lisp and SLIME")
3943     (description
3944      "CL-SYNTAX provides Reader Syntax Coventions for Common Lisp and SLIME.")
3945     (license license:llgpl)))
3946
3947 (define-public cl-syntax
3948   (sbcl-package->cl-source-package sbcl-cl-syntax))
3949
3950 (define-public sbcl-cl-annot
3951   (let ((commit "c99e69c15d935eabc671b483349a406e0da9518d")
3952         (revision "1"))
3953     (package
3954       (name "sbcl-cl-annot")
3955       (version (git-version "0.0.0" revision commit))
3956       (source
3957        (origin
3958          (method git-fetch)
3959          (uri (git-reference
3960                (url "https://github.com/m2ym/cl-annot.git")
3961                (commit commit)))
3962          (file-name (git-file-name name version))
3963          (sha256
3964           (base32 "1wq1gs9jjd5m6iwrv06c2d7i5dvqsfjcljgbspfbc93cg5xahk4n"))))
3965       (build-system asdf-build-system/sbcl)
3966     (arguments
3967      '(#:asd-file "cl-annot.asd"
3968        #:asd-system-name "cl-annot"))
3969       (inputs
3970        `(("sbcl-alexandria" ,sbcl-alexandria)))
3971       (home-page "https://github.com/m2ym/cl-annot")
3972       (synopsis "Python-like Annotation Syntax for Common Lisp.")
3973       (description
3974        "@code{cl-annot} is an general annotation library for Common Lisp.")
3975       (license license:llgpl))))
3976
3977 (define-public cl-annot
3978   (sbcl-package->cl-source-package sbcl-cl-annot))
3979
3980 (define-public sbcl-cl-syntax-annot
3981   (package
3982     (name "sbcl-cl-syntax-annot")
3983     (version "0.0.3")
3984     (source
3985      (origin
3986        (method git-fetch)
3987        (uri (git-reference
3988              (url "https://github.com/m2ym/cl-syntax.git")
3989              (commit "03f0c329bbd55b8622c37161e6278366525e2ccc")))
3990        (file-name (git-file-name name version))
3991        (sha256
3992         (base32 "17ran8xp77asagl31xv8w819wafh6whwfc9p6dgx22ca537gyl4y"))))
3993     (build-system asdf-build-system/sbcl)
3994     (arguments
3995      '(#:asd-file "cl-syntax-annot.asd"
3996        #:asd-system-name "cl-syntax-annot"))
3997     (inputs
3998      `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
3999        ("sbcl-cl-annot" ,sbcl-cl-annot)))
4000     (home-page "https://github.com/m2ym/cl-syntax")
4001     (synopsis "Reader Syntax Coventions for Common Lisp and SLIME")
4002     (description
4003      "CL-SYNTAX provides Reader Syntax Coventions for Common Lisp and
4004 SLIME.")
4005     (license license:llgpl)))
4006
4007 (define-public cl-syntax-annot
4008   (sbcl-package->cl-source-package sbcl-cl-syntax-annot))
4009
4010 (define-public sbcl-cl-utilities
4011   (let ((commit "dce2d2f6387091ea90357a130fa6d13a6776884b")
4012         (revision "1"))
4013     (package
4014       (name "sbcl-cl-utilities")
4015       (version (git-version "0.0.0" revision commit))
4016       (source
4017        (origin
4018          (method url-fetch)
4019          (uri
4020           (string-append
4021            "https://gitlab.common-lisp.net/cl-utilities/cl-utilities/-/"
4022            "archive/" commit "/cl-utilities-" commit ".tar.gz"))
4023          (sha256
4024           (base32 "1r46v730yf96nk2vb24qmagv9x96xvd08abqwhf02ghgydv1a7z2"))))
4025       (build-system asdf-build-system/sbcl)
4026       (arguments
4027        '(#:asd-file "cl-utilities.asd"
4028          #:asd-system-name "cl-utilities"
4029          #:phases
4030          (modify-phases %standard-phases
4031            (add-after 'unpack 'fix-paths
4032              (lambda* (#:key inputs #:allow-other-keys)
4033                (substitute* "rotate-byte.lisp"
4034                  (("in-package :cl-utilities)" all)
4035                   "in-package :cl-utilities)\n\n#+sbcl\n(require :sb-rotate-byte)")))))))
4036       (home-page "http://common-lisp.net/project/cl-utilities")
4037       (synopsis "A collection of semi-standard utilities")
4038       (description
4039        "On Cliki.net <http://www.cliki.net/Common%20Lisp%20Utilities>, there
4040 is a collection of Common Lisp Utilities, things that everybody writes since
4041 they're not part of the official standard.  There are some very useful things
4042 there; the only problems are that they aren't implemented as well as you'd
4043 like (some aren't implemented at all) and they aren't conveniently packaged
4044 and maintained.  It takes quite a bit of work to carefully implement utilities
4045 for common use, commented and documented, with error checking placed
4046 everywhere some dumb user might make a mistake.")
4047       (license license:public-domain))))
4048
4049 (define-public cl-utilities
4050   (sbcl-package->cl-source-package sbcl-cl-utilities))
4051
4052 (define-public sbcl-map-set
4053   (let ((commit "7b4b545b68b8")
4054         (revision "1"))
4055     (package
4056       (name "sbcl-map-set")
4057       (version (git-version "0.0.0" revision commit))
4058       (source
4059        (origin
4060          (method url-fetch)
4061          (uri (string-append
4062                "https://bitbucket.org/tarballs_are_good/map-set/get/"
4063                commit ".tar.gz"))
4064          (sha256
4065           (base32 "1sx5j5qdsy5fklspfammwb16kjrhkggdavm922a9q86jm5l0b239"))))
4066       (build-system asdf-build-system/sbcl)
4067       (home-page "https://bitbucket.org/tarballs_are_good/map-set")
4068       (synopsis "Set-like data structure")
4069       (description
4070        "Implementation of a set-like data structure with constant time
4071 addition, removal, and random selection.")
4072       (license license:bsd-3))))
4073
4074 (define-public cl-map-set
4075   (sbcl-package->cl-source-package sbcl-map-set))
4076
4077 (define-public sbcl-quri
4078   (let ((commit "76b75103f21ead092c9f715512fa82441ef61185")
4079         (revision "1"))
4080     (package
4081       (name "sbcl-quri")
4082       (version (git-version "0.1.0" revision commit))
4083       (source
4084        (origin
4085          (method git-fetch)
4086          (uri (git-reference
4087                (url "https://github.com/fukamachi/quri.git")
4088                (commit commit)))
4089          (file-name (git-file-name name version))
4090          (sha256
4091           (base32 "1ccbxsgzdibmzq33mmbmmz9vwl6l03xh6nbpsh1hkdvdcl7q0a60"))))
4092       (build-system asdf-build-system/sbcl)
4093       (arguments
4094        ;; Tests fail with: Component QURI-ASD::QURI-TEST not found,
4095        ;; required by #<SYSTEM "quri">. Why?
4096        '(#:tests? #f))
4097       (native-inputs `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4098                        ("sbcl-prove" ,sbcl-prove)))
4099       (inputs `(("sbcl-babel" ,sbcl-babel)
4100                 ("sbcl-split-sequence" ,sbcl-split-sequence)
4101                 ("sbcl-cl-utilities" ,sbcl-cl-utilities)
4102                 ("sbcl-alexandria" ,sbcl-alexandria)))
4103       (home-page "https://github.com/fukamachi/quri")
4104       (synopsis "Yet another URI library for Common Lisp")
4105       (description
4106        "QURI (pronounced \"Q-ree\") is yet another URI library for Common
4107 Lisp. It is intended to be a replacement of PURI.")
4108       (license license:bsd-3))))
4109
4110 (define-public cl-quri
4111   (sbcl-package->cl-source-package sbcl-quri))
4112
4113 (define-public sbcl-myway
4114   (let ((commit "286230082a11f879c18b93f17ca571c5f676bfb7")
4115         (revision "1"))
4116     (package
4117      (name "sbcl-myway")
4118      (version (git-version "0.1.0" revision commit))
4119      (source
4120       (origin
4121        (method git-fetch)
4122        (uri (git-reference
4123              (url "https://github.com/fukamachi/myway.git")
4124              (commit commit)))
4125        (file-name (git-file-name "myway" version))
4126        (sha256
4127         (base32 "0briia9bk3lbr0frnx39d1qg6i38dm4j6z9w3yga3d40k6df4a90"))))
4128      (build-system asdf-build-system/sbcl)
4129      (arguments
4130       ;; Tests fail with: Component MYWAY-ASD::MYWAY-TEST not found, required
4131       ;; by #<SYSTEM "myway">. Why?
4132       '(#:tests? #f))
4133      (native-inputs
4134       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4135         ("sbcl-prove" ,sbcl-prove)))
4136      (inputs
4137       `(("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
4138         ("sbcl-quri" ,sbcl-quri)
4139         ("sbcl-map-set" ,sbcl-map-set)))
4140      (home-page "https://github.com/fukamachi/myway")
4141      (synopsis "Sinatra-compatible URL routing library for Common Lisp")
4142      (description "My Way is a Sinatra-compatible URL routing library.")
4143      (license license:llgpl))))
4144
4145 (define-public cl-myway
4146   (sbcl-package->cl-source-package sbcl-myway))
4147
4148 (define-public sbcl-xsubseq
4149   (let ((commit "5ce430b3da5cda3a73b9cf5cee4df2843034422b")
4150         (revision "1"))
4151     (package
4152      (name "sbcl-xsubseq")
4153      (version (git-version "0.0.1" revision commit))
4154      (source
4155       (origin
4156        (method git-fetch)
4157        (uri (git-reference
4158              (url "https://github.com/fukamachi/xsubseq")
4159              (commit commit)))
4160        (file-name (git-file-name name version))
4161        (sha256
4162         (base32 "1xz79q0p2mclf3sqjiwf6izdpb6xrsr350bv4mlmdlm6rg5r99px"))))
4163      (build-system asdf-build-system/sbcl)
4164      (arguments
4165       ;; Tests fail with: Component XSUBSEQ-ASD::XSUBSEQ-TEST not found,
4166       ;; required by #<SYSTEM "xsubseq">. Why?
4167       '(#:tests? #f))
4168      (native-inputs
4169       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4170         ("sbcl-prove" ,sbcl-prove)))
4171      (home-page "https://github.com/fukamachi/xsubseq")
4172      (synopsis "Efficient way to use \"subseq\"s in Common Lisp")
4173      (description
4174       "XSubseq provides functions to be able to handle \"subseq\"s more
4175 effieiently.")
4176      (license license:bsd-2))))
4177
4178 (define-public cl-xsubseq
4179   (sbcl-package->cl-source-package sbcl-xsubseq))
4180
4181 (define-public sbcl-smart-buffer
4182   (let ((commit "09b9a9a0b3abaa37abe9a730f5aac2643dca4e62")
4183         (revision "1"))
4184     (package
4185       (name "sbcl-smart-buffer")
4186       (version (git-version "0.0.1" revision commit))
4187       (source
4188        (origin
4189          (method git-fetch)
4190          (uri (git-reference
4191                (url "https://github.com/fukamachi/smart-buffer")
4192                (commit commit)))
4193          (file-name (git-file-name name version))
4194          (sha256
4195           (base32 "0qz1zzxx0wm5ff7gpgsq550a59p0qj594zfmm2rglj97dahj54l7"))))
4196       (build-system asdf-build-system/sbcl)
4197       (arguments
4198        ;; Tests fail with: Component SMART-BUFFER-ASD::SMART-BUFFER-TEST not
4199        ;; found, required by #<SYSTEM "smart-buffer">. Why?
4200        `(#:tests? #f))
4201       (native-inputs
4202        `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4203          ("sbcl-prove" ,sbcl-prove)))
4204       (inputs
4205        `(("sbcl-xsubseq" ,sbcl-xsubseq)
4206          ("sbcl-flexi-streams" ,sbcl-flexi-streams)))
4207       (home-page "https://github.com/fukamachi/smart-buffer")
4208       (synopsis "Smart octets buffer")
4209       (description
4210        "Smart-buffer provides an output buffer which changes the destination
4211 depending on content size.")
4212       (license license:bsd-3))))
4213
4214 (define-public cl-smart-buffer
4215   (sbcl-package->cl-source-package sbcl-smart-buffer))
4216
4217 (define-public sbcl-fast-http
4218   (let ((commit "f9e7597191bae380503e20724fd493a24d024935")
4219         (revision "1"))
4220     (package
4221       (name "sbcl-fast-http")
4222       (version (git-version "0.2.0" revision commit))
4223       (source
4224        (origin
4225          (method git-fetch)
4226          (uri (git-reference
4227                (url "https://github.com/fukamachi/fast-http")
4228                (commit commit)))
4229          (file-name (git-file-name name version))
4230          (sha256
4231           (base32 "0qdmwv2zm0sizxdb8nnclgwl0nfjcbjaimbakavikijw7lr9b4jp"))))
4232       (build-system asdf-build-system/sbcl)
4233       (arguments
4234        ;; Tests fail with: Component FAST-HTTP-ASD::FAST-HTTP-TEST not found,
4235        ;; required by #<SYSTEM "fast-http">. Why?
4236        `(#:tests? #f))
4237       (native-inputs
4238        `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4239          ("sbcl-prove" ,sbcl-prove)))
4240       (inputs
4241        `(("sbcl-alexandria" ,sbcl-alexandria)
4242          ("sbcl-proc-parse" ,sbcl-proc-parse)
4243          ("sbcl-xsubseq" ,sbcl-xsubseq)
4244          ("sbcl-smart-buffer" ,sbcl-smart-buffer)
4245          ("sbcl-cl-utilities" ,sbcl-cl-utilities)))
4246       (home-page "https://github.com/fukamachi/fast-http")
4247       (synopsis "HTTP request/response parser for Common Lisp")
4248       (description
4249        "@code{fast-http} is a HTTP request/response protocol parser for Common
4250 Lisp.")
4251       ;; Author specified the MIT license
4252       (license license:expat))))
4253
4254 (define-public cl-fast-http
4255   (sbcl-package->cl-source-package sbcl-fast-http))
4256
4257 (define-public sbcl-static-vectors
4258   (package
4259     (name "sbcl-static-vectors")
4260     (version "1.8.4")
4261     (source
4262      (origin
4263        (method git-fetch)
4264        (uri (git-reference
4265              (url "https://github.com/sionescu/static-vectors.git")
4266              (commit (string-append "v" version))))
4267        (file-name (git-file-name name version))
4268        (sha256
4269         (base32 "0qvf9z6bhwhm8n45fjwkm7j8dcb58szfvndky65cyn4lpdval7m1"))))
4270     (native-inputs
4271      `(("sbcl-fiveam" ,sbcl-fiveam)))
4272     (inputs
4273      `(("sbcl-cffi-grovel" ,sbcl-cffi-grovel)
4274        ("sbcl-cffi" ,sbcl-cffi)))
4275     (build-system asdf-build-system/sbcl)
4276     (home-page "https://github.com/sionescu/static-vectors")
4277     (synopsis "Allocate SIMPLE-ARRAYs in static memory")
4278     (description
4279      "With @code{static-vectors}, you can create vectors allocated in static
4280 memory.")
4281     (license license:expat)))
4282
4283 (define-public cl-static-vectors
4284   (sbcl-package->cl-source-package sbcl-static-vectors))
4285
4286 (define-public ecl-static-vectors
4287   (sbcl-package->ecl-package sbcl-static-vectors))
4288
4289 (define-public sbcl-marshal
4290   (let ((commit "eff1b15f2b0af2f26f71ad6a4dd5c4beab9299ec")
4291         (revision "1"))
4292     (package
4293      (name "sbcl-marshal")
4294      (version (git-version "1.3.0" revision commit))
4295      (source
4296       (origin
4297        (method git-fetch)
4298        (uri (git-reference
4299              (url "https://github.com/wlbr/cl-marshal.git")
4300              (commit commit)))
4301        (file-name (git-file-name name version))
4302        (sha256
4303         (base32 "08qs6fhk38xpkkjkpcj92mxx0lgy4ygrbbzrmnivdx281syr0gwh"))))
4304      (build-system asdf-build-system/sbcl)
4305      (home-page "https://github.com/wlbr/cl-marshal")
4306      (synopsis "Simple (de)serialization of Lisp datastructures")
4307      (description
4308       "Simple and fast marshalling of Lisp datastructures.  Convert any object
4309 into a string representation, put it on a stream an revive it from there.
4310 Only minimal changes required to make your CLOS objects serializable.")
4311      (license license:expat))))
4312
4313 (define-public cl-marshal
4314   (sbcl-package->cl-source-package sbcl-marshal))
4315
4316 (define-public sbcl-checkl
4317   (let ((commit "80328800d047fef9b6e32dfe6bdc98396aee3cc9")
4318         (revision "1"))
4319     (package
4320       (name "sbcl-checkl")
4321       (version (git-version "0.0.0" revision commit))
4322       (source
4323        (origin
4324          (method git-fetch)
4325          (uri (git-reference
4326                (url "https://github.com/rpav/CheckL.git")
4327                (commit commit)))
4328          (file-name (git-file-name name version))
4329          (sha256
4330           (base32 "0bpisihx1gay44xmyr1dmhlwh00j0zzi04rp9fy35i95l2r4xdlx"))))
4331       (build-system asdf-build-system/sbcl)
4332       (arguments
4333        ;; Error while trying to load definition for system checkl-test from
4334        ;; pathname [...]/checkl-test.asd: The function CHECKL:DEFINE-TEST-OP
4335        ;; is undefined.
4336        '(#:tests? #f))
4337       (native-inputs
4338        `(("sbcl-fiveam" ,sbcl-fiveam)))
4339       (inputs
4340        `(("sbcl-marshal" ,sbcl-marshal)))
4341       (home-page "https://github.com/rpav/CheckL/")
4342       (synopsis "Dynamic testing for Common Lisp")
4343       (description
4344        "CheckL lets you write tests dynamically, it checks resulting values
4345 against the last run.")
4346       ;; The author specifies both LLGPL and "BSD", but the "BSD" license
4347       ;; isn't specified anywhere, so I don't know which kind.  LLGPL is the
4348       ;; stronger of the two and so I think only listing this should suffice.
4349       (license license:llgpl))))
4350
4351 (define-public cl-checkl
4352   (sbcl-package->cl-source-package sbcl-checkl))
4353
4354 (define-public sbcl-fast-io
4355   (let ((commit "dc3a71db7e9b756a88781ae9c342fe9d4bbab51c")
4356         (revision "1"))
4357     (package
4358      (name "sbcl-fast-io")
4359      (version (git-version "1.0.0" revision commit))
4360      (source
4361       (origin
4362        (method git-fetch)
4363        (uri (git-reference
4364              (url "https://github.com/rpav/fast-io.git")
4365              (commit commit)))
4366        (file-name (git-file-name name version))
4367        (sha256
4368         (base32 "1jsp6xvi26ln6fdy5j5zi05xvan8jsqdhisv552dy6xg6ws8i1yq"))))
4369      (build-system asdf-build-system/sbcl)
4370      (arguments
4371       ;; Error while trying to load definition for system fast-io-test from
4372       ;; pathname [...]/fast-io-test.asd: The function CHECKL:DEFINE-TEST-OP
4373       ;; is undefined.
4374       '(#:tests? #f))
4375      (native-inputs
4376       `(("sbcl-fiveam" ,sbcl-fiveam)
4377         ("sbcl-checkl" ,sbcl-checkl)))
4378      (inputs
4379       `(("sbcl-alexandria" ,sbcl-alexandria)
4380         ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)
4381         ("sbcl-static-vectors" ,sbcl-static-vectors)))
4382      (home-page "https://github.com/rpav/fast-io")
4383      (synopsis "Fast octet-vector/stream I/O for Common Lisp")
4384      (description
4385       "Fast-io is about improving performance to octet-vectors and octet
4386 streams (though primarily the former, while wrapping the latter).")
4387      ;; Author specifies this as NewBSD which is an alias
4388      (license license:bsd-3))))
4389
4390 (define-public cl-fast-io
4391   (sbcl-package->cl-source-package sbcl-fast-io))
4392
4393 (define-public sbcl-jonathan
4394   (let ((commit "1f448b4f7ac8265e56e1c02b32ce383e65316300")
4395         (revision "1"))
4396     (package
4397      (name "sbcl-jonathan")
4398      (version (git-version "0.1.0" revision commit))
4399      (source
4400       (origin
4401        (method git-fetch)
4402        (uri (git-reference
4403              (url "https://github.com/Rudolph-Miller/jonathan.git")
4404              (commit commit)))
4405        (file-name (git-file-name name version))
4406        (sha256
4407         (base32 "14x4iwz3mbag5jzzzr4sb6ai0m9r4q4kyypbq32jmsk2dx1hi807"))))
4408      (build-system asdf-build-system/sbcl)
4409      (arguments
4410       ;; Tests fail with: Component JONATHAN-ASD::JONATHAN-TEST not found,
4411       ;; required by #<SYSTEM "jonathan">. Why?
4412       `(#:tests? #f))
4413      (native-inputs
4414       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4415         ("sbcl-prove" ,sbcl-prove)))
4416      (inputs
4417       `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
4418         ("sbcl-cl-syntax-annot" ,sbcl-cl-syntax-annot)
4419         ("sbcl-fast-io" ,sbcl-fast-io)
4420         ("sbcl-proc-parse" ,sbcl-proc-parse)
4421         ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)))
4422      (home-page "https://rudolph-miller.github.io/jonathan/overview.html")
4423      (synopsis "JSON encoder and decoder")
4424      (description
4425       "High performance JSON encoder and decoder.  Currently support: SBCL,
4426 CCL.")
4427      ;; Author specifies the MIT license
4428      (license license:expat))))
4429
4430 (define-public cl-jonathan
4431   (sbcl-package->cl-source-package sbcl-jonathan))
4432
4433 (define-public sbcl-http-body
4434   (let ((commit "dd01dc4f5842e3d29728552e5163acce8386eb73")
4435         (revision "1"))
4436     (package
4437      (name "sbcl-http-body")
4438      (version (git-version "0.1.0" revision commit))
4439      (source
4440       (origin
4441        (method git-fetch)
4442        (uri (git-reference
4443              (url "https://github.com/fukamachi/http-body")
4444              (commit commit)))
4445        (file-name (git-file-name name version))
4446        (sha256
4447         (base32 "1jd06snjvxcprhapgfq8sx0y5lrldkvhf206ix6d5a23dd6zcmr0"))))
4448      (build-system asdf-build-system/sbcl)
4449      (arguments
4450       ;; Tests fail with: Component HTTP-BODY-ASD::HTTP-BODY-TEST not
4451       ;; found, required by #<SYSTEM "http-body">. Why?
4452       `(#:tests? #f))
4453      (native-inputs
4454       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4455         ("sbcl-prove" ,sbcl-prove)))
4456      (inputs
4457       `(("sbcl-fast-http" ,sbcl-fast-http)
4458         ("sbcl-jonathan" ,sbcl-jonathan)
4459         ("sbcl-quri" ,sbcl-quri)))
4460      (home-page "https://github.com/fukamachi/http-body")
4461      (synopsis "HTTP POST data parser")
4462      (description
4463       "HTTP-Body parses HTTP POST data and returns POST parameters.  It
4464 supports application/x-www-form-urlencoded, application/json, and
4465 multipart/form-data.")
4466      (license license:bsd-2))))
4467
4468 (define-public cl-http-body
4469   (sbcl-package->cl-source-package sbcl-http-body))
4470
4471 (define-public sbcl-circular-streams
4472   (let ((commit "e770bade1919c5e8533dd2078c93c3d3bbeb38df")
4473         (revision "1"))
4474     (package
4475      (name "sbcl-circular-streams")
4476      (version (git-version "0.1.0" revision commit))
4477      (source
4478       (origin
4479        (method git-fetch)
4480        (uri (git-reference
4481              (url "https://github.com/fukamachi/circular-streams")
4482              (commit commit)))
4483        (file-name (git-file-name name version))
4484        (sha256
4485         (base32 "1wpw6d5cciyqcf92f7mvihak52pd5s47kk4qq6f0r2z2as68p5rs"))))
4486      (build-system asdf-build-system/sbcl)
4487      (arguments
4488       ;; The tests depend on cl-test-more which is now prove. Prove
4489       ;; tests aren't working for some reason.
4490       `(#:tests? #f))
4491      (inputs
4492       `(("sbcl-fast-io" ,sbcl-fast-io)
4493         ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)))
4494      (home-page "https://github.com/fukamachi/circular-streams")
4495      (synopsis "Circularly readable streams for Common Lisp")
4496      (description
4497       "Circular-Streams allows you to read streams circularly by wrapping real
4498 streams. Once you reach end-of-file of a stream, it's file position will be
4499 reset to 0 and you're able to read it again.")
4500      (license license:llgpl))))
4501
4502 (define-public cl-circular-streams
4503   (sbcl-package->cl-source-package sbcl-circular-streams))
4504
4505 (define-public sbcl-lack-request
4506   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4507         (revision "1"))
4508     (package
4509      (name "sbcl-lack-request")
4510      (version (git-version "0.1.0" revision commit))
4511      (source
4512       (origin
4513        (method git-fetch)
4514        (uri (git-reference
4515              (url "https://github.com/fukamachi/lack.git")
4516              (commit commit)))
4517        (file-name (git-file-name "lack-request" version))
4518        (sha256
4519         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4520      (build-system asdf-build-system/sbcl)
4521      (arguments
4522       '(#:asd-file "lack-request.asd"
4523         #:asd-system-name "lack-request"
4524         #:test-asd-file "t-lack-request.asd"
4525         ;; XXX: Component :CLACK-TEST not found
4526         #:tests? #f))
4527      (native-inputs
4528       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4529         ("sbcl-prove" ,sbcl-prove)))
4530      (inputs
4531       `(("sbcl-quri" ,sbcl-quri)
4532         ("sbcl-http-body" ,sbcl-http-body)
4533         ("sbcl-circular-streams" ,sbcl-circular-streams)))
4534      (home-page "https://github.com/fukamachi/lack")
4535      (synopsis "Lack, the core of Clack")
4536      (description
4537       "Lack is a Common Lisp library which allows web applications to be
4538 constructed of modular components.  It was originally a part of Clack, however
4539 it's going to be rewritten as an individual project since Clack v2 with
4540 performance and simplicity in mind.")
4541      (license license:llgpl))))
4542
4543 (define-public cl-lack-request
4544   (sbcl-package->cl-source-package sbcl-lack-request))
4545
4546 (define-public sbcl-local-time
4547   (let ((commit "beac054eef428552b63d4ae7820c32ffef9a3015")
4548         (revision "1"))
4549     (package
4550      (name "sbcl-local-time")
4551      (version (git-version "1.0.6" revision commit))
4552      (source
4553       (origin
4554        (method git-fetch)
4555        (uri (git-reference
4556              (url "https://github.com/dlowe-net/local-time.git")
4557              (commit commit)))
4558        (file-name (git-file-name name version))
4559        (sha256
4560         (base32 "0xhkmgxh41dg2wwlsp0h2l41jp144xn4gpxhh0lna6kh0560w2cc"))))
4561      (build-system asdf-build-system/sbcl)
4562      (arguments
4563       ;; TODO: Component :STEFIL not found, required by #<SYSTEM
4564       ;; "local-time/test">
4565       '(#:tests? #f))
4566      (native-inputs
4567       `(("stefil" ,sbcl-hu.dwim.stefil)))
4568      (inputs
4569       `(("sbcl-cl-fad" ,sbcl-cl-fad)))
4570      (home-page "https://common-lisp.net/project/local-time/")
4571      (synopsis "Time manipulation library for Common Lisp")
4572      (description
4573       "The LOCAL-TIME library is a Common Lisp library for the manipulation of
4574 dates and times.  It is based almost entirely upon Erik Naggum's paper \"The
4575 Long Painful History of Time\".")
4576      (license license:expat))))
4577
4578 (define-public cl-local-time
4579   (sbcl-package->cl-source-package sbcl-local-time))
4580
4581 (define-public sbcl-lack-response
4582   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4583         (revision "1"))
4584     (package
4585      (name "sbcl-lack-response")
4586      (version (git-version "0.1.0" revision commit))
4587      (source
4588       (origin
4589        (method git-fetch)
4590        (uri (git-reference
4591              (url "https://github.com/fukamachi/lack.git")
4592              (commit commit)))
4593        (file-name (git-file-name name version))
4594        (sha256
4595         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4596      (build-system asdf-build-system/sbcl)
4597      (arguments
4598       '(#:asd-file "lack-response.asd"
4599         #:asd-system-name "lack-response"
4600         ;; XXX: no tests for lack-response.
4601         #:tests? #f))
4602      (native-inputs
4603       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4604         ("sbcl-prove" ,sbcl-prove)))
4605      (inputs
4606       `(("sbcl-quri" ,sbcl-quri)
4607         ("sbcl-http-body" ,sbcl-http-body)
4608         ("sbcl-circular-streams" ,sbcl-circular-streams)
4609         ("sbcl-local-time" ,sbcl-local-time)))
4610      (home-page "https://github.com/fukamachi/lack")
4611      (synopsis "Lack, the core of Clack")
4612      (description
4613       "Lack is a Common Lisp library which allows web applications to be
4614 constructed of modular components.  It was originally a part of Clack, however
4615 it's going to be rewritten as an individual project since Clack v2 with
4616 performance and simplicity in mind.")
4617      (license license:llgpl))))
4618
4619 (define-public cl-lack-response
4620   (sbcl-package->cl-source-package sbcl-lack-response))
4621
4622 (define-public sbcl-lack-component
4623   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4624         (revision "1"))
4625     (package
4626      (name "sbcl-lack-component")
4627      (version (git-version "0.0.0" revision commit))
4628      (source
4629       (origin
4630        (method git-fetch)
4631        (uri (git-reference
4632              (url "https://github.com/fukamachi/lack.git")
4633              (commit commit)))
4634        (file-name (git-file-name "lack-component" version))
4635        (sha256
4636         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4637      (build-system asdf-build-system/sbcl)
4638      (arguments
4639       '(#:asd-file "lack-component.asd"
4640         #:asd-system-name "lack-component"
4641         #:test-asd-file "t-lack-component.asd"
4642         ;; XXX: Component :LACK-TEST not found
4643         #:tests? #f))
4644      (native-inputs
4645       `(("prove-asdf" ,sbcl-prove-asdf)))
4646      (home-page "https://github.com/fukamachi/lack")
4647      (synopsis "Lack, the core of Clack")
4648      (description
4649       "Lack is a Common Lisp library which allows web applications to be
4650 constructed of modular components.  It was originally a part of Clack, however
4651 it's going to be rewritten as an individual project since Clack v2 with
4652 performance and simplicity in mind.")
4653      (license license:llgpl))))
4654
4655 (define-public cl-lack-component
4656   (sbcl-package->cl-source-package sbcl-lack-component))
4657
4658 (define-public sbcl-lack-util
4659   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4660         (revision "1"))
4661     (package
4662      (name "sbcl-lack-util")
4663      (version (git-version "0.1.0" revision commit))
4664      (source
4665       (origin
4666        (method git-fetch)
4667        (uri (git-reference
4668              (url "https://github.com/fukamachi/lack.git")
4669              (commit commit)))
4670        (file-name (git-file-name "lack-util" version))
4671        (sha256
4672         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4673      (build-system asdf-build-system/sbcl)
4674      (arguments
4675       '(#:asd-file "lack-util.asd"
4676         #:asd-system-name "lack-util"
4677         #:test-asd-file "t-lack-util.asd"
4678         ;; XXX: Component :LACK-TEST not found
4679         #:tests? #f))
4680      (native-inputs
4681       `(("prove-asdf" ,sbcl-prove-asdf)))
4682      (inputs
4683       `(("sbcl-ironclad" ,sbcl-ironclad)))
4684      (home-page "https://github.com/fukamachi/lack")
4685      (synopsis "Lack, the core of Clack")
4686      (description
4687       "Lack is a Common Lisp library which allows web applications to be
4688 constructed of modular components.  It was originally a part of Clack, however
4689 it's going to be rewritten as an individual project since Clack v2 with
4690 performance and simplicity in mind.")
4691      (license license:llgpl))))
4692
4693 (define-public cl-lack-util
4694   (sbcl-package->cl-source-package sbcl-lack-util))
4695
4696 (define-public sbcl-lack-middleware-backtrace
4697   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4698         (revision "1"))
4699     (package
4700      (name "sbcl-lack-middleware-backtrace")
4701      (version (git-version "0.1.0" revision commit))
4702      (source
4703       (origin
4704        (method git-fetch)
4705        (uri (git-reference
4706              (url "https://github.com/fukamachi/lack.git")
4707              (commit commit)))
4708        (file-name (git-file-name "lack-middleware-backtrace" version))
4709        (sha256
4710         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4711      (build-system asdf-build-system/sbcl)
4712      (arguments
4713       '(#:asd-file "lack-middleware-backtrace.asd"
4714         #:asd-system-name "lack-middleware-backtrace"
4715         #:test-asd-file "t-lack-middleware-backtrace.asd"
4716         ;; XXX: Component :LACK not found
4717         #:tests? #f))
4718      (native-inputs
4719       `(("prove-asdf" ,sbcl-prove-asdf)))
4720      (home-page "https://github.com/fukamachi/lack")
4721      (synopsis "Lack, the core of Clack")
4722      (description
4723       "Lack is a Common Lisp library which allows web applications to be
4724 constructed of modular components.  It was originally a part of Clack, however
4725 it's going to be rewritten as an individual project since Clack v2 with
4726 performance and simplicity in mind.")
4727      (license license:llgpl))))
4728
4729 (define-public cl-lack-middleware-backtrace
4730   (sbcl-package->cl-source-package sbcl-lack-middleware-backtrace))
4731
4732 (define-public sbcl-trivial-mimes
4733   (let ((commit "303f8ac0aa6ca0bc139aa3c34822e623c3723fab")
4734         (revision "1"))
4735     (package
4736       (name "sbcl-trivial-mimes")
4737       (version (git-version "1.1.0" revision commit))
4738       (source
4739        (origin
4740          (method git-fetch)
4741          (uri (git-reference
4742                (url "https://github.com/Shinmera/trivial-mimes.git")
4743                (commit commit)))
4744          (file-name (git-file-name name version))
4745          (sha256
4746           (base32 "17jxgl47r695bvsb7wi3n2ws5rp1zzgvw0zii8cy5ggw4b4ayv6m"))))
4747       (build-system asdf-build-system/sbcl)
4748       (arguments
4749        '(#:phases
4750          (modify-phases %standard-phases
4751            (add-after
4752                'unpack 'fix-paths
4753              (lambda* (#:key inputs #:allow-other-keys)
4754                (let ((anchor "#p\"/etc/mime.types\""))
4755                  (substitute* "mime-types.lisp"
4756                    ((anchor all)
4757                     (string-append
4758                      anchor "\n"
4759                      "(asdf:system-relative-pathname :trivial-mimes "
4760                      "\"../../share/common-lisp/" (%lisp-type)
4761                      "-source/trivial-mimes/mime.types\")")))))))))
4762       (native-inputs
4763        `(("stefil" ,sbcl-hu.dwim.stefil)))
4764       (inputs
4765        `(("sbcl-cl-fad" ,sbcl-cl-fad)))
4766       (home-page "https://shinmera.github.io/trivial-mimes/")
4767       (synopsis "Tiny Common Lisp library to detect mime types in files")
4768       (description
4769        "This is a teensy library that provides some functions to determine the
4770 mime-type of a file.")
4771       (license license:artistic2.0))))
4772
4773 (define-public cl-trivial-mimes
4774   (sbcl-package->cl-source-package sbcl-trivial-mimes))
4775
4776 (define-public ecl-trivial-mimes
4777   (sbcl-package->ecl-package sbcl-trivial-mimes))
4778
4779 (define-public sbcl-lack-middleware-static
4780   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4781         (revision "1"))
4782     (package
4783      (name "sbcl-lack-middleware-static")
4784      (version (git-version "0.1.0" revision commit))
4785      (source
4786       (origin
4787        (method git-fetch)
4788        (uri (git-reference
4789              (url "https://github.com/fukamachi/lack.git")
4790              (commit commit)))
4791        (file-name (git-file-name "lack-middleware-static" version))
4792        (sha256
4793         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4794      (build-system asdf-build-system/sbcl)
4795      (arguments
4796       '(#:asd-file "lack-middleware-static.asd"
4797         #:asd-system-name "lack-middleware-static"
4798         #:test-asd-file "t-lack-middleware-static.asd"
4799         ;; XXX: Component :LACK not found
4800         #:tests? #f))
4801      (native-inputs
4802       `(("prove-asdf" ,sbcl-prove-asdf)))
4803      (inputs
4804       `(("sbcl-ironclad" ,sbcl-ironclad)
4805         ("sbcl-trivial-mimes" ,sbcl-trivial-mimes)
4806         ("sbcl-local-time" ,sbcl-local-time)))
4807      (home-page "https://github.com/fukamachi/lack")
4808      (synopsis "Lack, the core of Clack")
4809      (description
4810       "Lack is a Common Lisp library which allows web applications to be
4811 constructed of modular components.  It was originally a part of Clack, however
4812 it's going to be rewritten as an individual project since Clack v2 with
4813 performance and simplicity in mind.")
4814      (license license:llgpl))))
4815
4816 (define-public cl-lack-middleware-static
4817   (sbcl-package->cl-source-package sbcl-lack-middleware-static))
4818
4819 (define-public sbcl-lack
4820   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4821         (revision "1"))
4822     (package
4823      (name "sbcl-lack")
4824      (version (git-version "0.1.0" revision commit))
4825      (source
4826       (origin
4827        (method git-fetch)
4828        (uri (git-reference
4829              (url "https://github.com/fukamachi/lack.git")
4830              (commit commit)))
4831        (file-name (git-file-name "lack" version))
4832        (sha256
4833         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4834      (build-system asdf-build-system/sbcl)
4835      (arguments
4836       '(#:test-asd-file "t-lack.asd"
4837         ;; XXX: Component :CLACK not found
4838         #:tests? #f))
4839      (native-inputs
4840       `(("prove-asdf" ,sbcl-prove-asdf)))
4841      (inputs
4842       `(("sbcl-lack-component" ,sbcl-lack-component)
4843         ("sbcl-lack-util" ,sbcl-lack-util)))
4844      (home-page "https://github.com/fukamachi/lack")
4845      (synopsis "Lack, the core of Clack")
4846      (description
4847       "Lack is a Common Lisp library which allows web applications to be
4848 constructed of modular components.  It was originally a part of Clack, however
4849 it's going to be rewritten as an individual project since Clack v2 with
4850 performance and simplicity in mind.")
4851      (license license:llgpl))))
4852
4853 (define-public cl-lack
4854   (sbcl-package->cl-source-package sbcl-lack))
4855
4856 (define-public sbcl-ningle
4857   (let ((commit "50bd4f09b5a03a7249bd4d78265d6451563b25ad")
4858         (revision "1"))
4859     (package
4860       (name "sbcl-ningle")
4861       (version (git-version "0.3.0" revision commit))
4862       (source
4863        (origin
4864          (method git-fetch)
4865          (uri (git-reference
4866                (url "https://github.com/fukamachi/ningle.git")
4867                (commit commit)))
4868          (file-name (git-file-name name version))
4869          (sha256
4870           (base32 "1bsl8cnxhacb8p92z9n89vhk1ikmij5zavk0m2zvmj7iqm79jzgw"))))
4871       (build-system asdf-build-system/sbcl)
4872       (arguments
4873        ;; TODO: pull in clack-test
4874        '(#:tests? #f
4875          #:phases
4876          (modify-phases %standard-phases
4877            (delete 'cleanup-files)
4878            (delete 'cleanup)
4879            (add-before 'cleanup 'combine-fasls
4880              (lambda* (#:key outputs #:allow-other-keys)
4881                (let* ((out (assoc-ref outputs "out"))
4882                       (lib (string-append out "/lib/sbcl"))
4883                       (ningle-path (string-append lib "/ningle"))
4884                       (fasl-files (find-files out "\\.fasl$")))
4885                  (mkdir-p ningle-path)
4886                  (let ((fasl-path (lambda (name)
4887                                     (string-append ningle-path
4888                                                    "/"
4889                                                    (basename name)
4890                                                    "--system.fasl"))))
4891                    (for-each (lambda (file)
4892                                (rename-file file
4893                                             (fasl-path
4894                                              (basename file ".fasl"))))
4895                              fasl-files))
4896                  fasl-files)
4897                #t)))))
4898       (native-inputs
4899        `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4900          ("sbcl-prove" ,sbcl-prove)))
4901       (inputs
4902        `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
4903          ("sbcl-cl-syntax-annot" ,sbcl-cl-syntax-annot)
4904          ("sbcl-myway" ,sbcl-myway)
4905          ("sbcl-lack-request" ,sbcl-lack-request)
4906          ("sbcl-lack-response" ,sbcl-lack-response)
4907          ("sbcl-lack-component" ,sbcl-lack-component)
4908          ("sbcl-alexandria" ,sbcl-alexandria)
4909          ("sbcl-babel" ,sbcl-babel)))
4910       (home-page "https://8arrow.org/ningle/")
4911       (synopsis "Super micro framework for Common Lisp")
4912       (description
4913        "Ningle is a lightweight web application framework for Common Lisp.")
4914       (license license:llgpl))))
4915
4916 (define-public cl-ningle
4917   (sbcl-package->cl-source-package sbcl-ningle))
4918
4919 (define-public sbcl-clack
4920   (let ((commit "e3e032843bb1220ab96263c411aa7f2feb4746e0")
4921         (revision "1"))
4922     (package
4923      (name "sbcl-clack")
4924      (version (git-version "2.0.0" revision commit))
4925      (source
4926       (origin
4927        (method git-fetch)
4928        (uri (git-reference
4929              (url "https://github.com/fukamachi/clack.git")
4930              (commit commit)))
4931        (file-name (git-file-name name version))
4932        (sha256
4933         (base32 "1ymzs6qyrwhlj6cgqsnpyn6g5cbp7a3s1vgxwna20y2q7y4iacy0"))))
4934      (build-system asdf-build-system/sbcl)
4935      (inputs
4936       `(("sbcl-lack" ,sbcl-lack)
4937         ("sbcl-lack-middleware-backtrace" ,sbcl-lack-middleware-backtrace)
4938         ("sbcl-bordeaux-threads" ,sbcl-bordeaux-threads)))
4939      (home-page "https://github.com/fukamachi/clack")
4940      (synopsis "Web Application Environment for Common Lisp")
4941      (description
4942       "Clack is a web application environment for Common Lisp inspired by
4943 Python's WSGI and Ruby's Rack.")
4944      (license license:llgpl))))
4945
4946 (define-public cl-clack
4947   (sbcl-package->cl-source-package sbcl-clack))
4948
4949 (define-public sbcl-log4cl
4950   (let ((commit "611e094458504b938d49de904eab141285328c7c")
4951         (revision "1"))
4952     (package
4953       (name "sbcl-log4cl")
4954       (build-system asdf-build-system/sbcl)
4955       (version "1.1.2")
4956       (source
4957        (origin
4958          (method git-fetch)
4959          (uri (git-reference
4960                (url "https://github.com/sharplispers/log4cl")
4961                (commit commit)))
4962          (file-name (git-file-name name version))
4963          (sha256
4964           (base32
4965            "08jly0s0g26b56hhpfizxsb4j0yvbh946sd205gr42dkzv8l7dsc"))))
4966       ;; FIXME: tests require stefil, sbcl-hu.dwim.stefil wont work
4967       (arguments
4968        `(#:tests? #f))
4969       (inputs `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
4970       (synopsis "Common Lisp logging framework, modeled after Log4J")
4971       (home-page "https://github.com/7max/log4cl")
4972       (description "This is a Common Lisp logging framework that can log at
4973 various levels and mix text with expressions.")
4974       (license license:asl2.0))))
4975
4976 (define-public cl-log4cl
4977   (sbcl-package->cl-source-package sbcl-log4cl))
4978
4979 (define-public ecl-log4cl
4980   (sbcl-package->ecl-package sbcl-log4cl))
4981
4982 (define-public sbcl-find-port
4983   (let ((commit "00c96a25af93a0f8681d34ec548861f2d7485478")
4984         (revision "1"))
4985     (package
4986       (name "sbcl-find-port")
4987       (build-system asdf-build-system/sbcl)
4988       (version "0.1")
4989       (home-page "https://github.com/eudoxia0/find-port")
4990       (source
4991        (origin
4992          (method git-fetch)
4993          (uri (git-reference
4994                (url home-page)
4995                (commit commit)))
4996          (file-name (git-file-name name version))
4997          (sha256
4998           (base32
4999            "0d6dzbb45jh0rx90wgs6v020k2xa87mvzas3mvfzvivjvqqlpryq"))))
5000       (native-inputs
5001        `(("fiveam" ,sbcl-fiveam)))
5002       (inputs
5003        `(("sbcl-usocket" ,sbcl-usocket)))
5004       (synopsis "Find open ports programmatically in Common Lisp")
5005       (description "This is a small Common Lisp library that finds an open
5006 port within a range.")
5007       (license license:expat))))
5008
5009 (define-public cl-find-port
5010   (sbcl-package->cl-source-package sbcl-find-port))
5011
5012 (define-public ecl-find-port
5013   (sbcl-package->ecl-package sbcl-find-port))
5014
5015 (define-public sbcl-clunit
5016   (let ((commit "6f6d72873f0e1207f037470105969384f8380628")
5017         (revision "1"))
5018     (package
5019       (name "sbcl-clunit")
5020       (version (git-version "0.2.3" revision commit))
5021       (source
5022        (origin
5023          (method git-fetch)
5024          (uri (git-reference
5025                (url "https://github.com/tgutu/clunit.git")
5026                (commit commit)))
5027          (file-name (git-file-name name version))
5028          (sha256
5029           (base32
5030            "1idf2xnqzlhi8rbrqmzpmb3i1l6pbdzhhajkmhwbp6qjkmxa4h85"))))
5031       (build-system asdf-build-system/sbcl)
5032       (synopsis "CLUnit is a Common Lisp unit testing framework")
5033       (description
5034        "CLUnit is a Common Lisp unit testing framework.  It is designed
5035 to be easy to use so that you can quickly start testing.  CLUnit
5036 provides a rich set of features aimed at improving your unit testing
5037 experience.")
5038       (home-page "https://tgutu.github.io/clunit/")
5039       ;; MIT License
5040       (license license:expat))))
5041
5042 (define-public cl-clunit
5043   (sbcl-package->cl-source-package sbcl-clunit))
5044
5045 (define-public ecl-clunit
5046   (sbcl-package->ecl-package sbcl-clunit))
5047
5048 (define-public sbcl-py4cl
5049   (let ((commit "4c8a2b0814fd311f978964f825ce012290f60136")
5050         (revision "1"))
5051     (package
5052       (name "sbcl-py4cl")
5053       (version (git-version "0.0.0" revision commit))
5054       (source
5055        (origin
5056          (method git-fetch)
5057          (uri (git-reference
5058                (url "https://github.com/bendudson/py4cl.git")
5059                (commit commit)))
5060          (file-name (git-file-name name version))
5061          (sha256
5062           (base32
5063            "15mk7qdqjkj56gdnbyrdyz6r7m1h26ldvn6ch96pmvg5vmr1m45r"))
5064          (modules '((guix build utils)))))
5065       (build-system asdf-build-system/sbcl)
5066       (native-inputs
5067        `(("sbcl-clunit" ,sbcl-clunit)))
5068       (inputs
5069        `(("sbcl-trivial-garbage" ,sbcl-trivial-garbage)))
5070       (propagated-inputs
5071        ;; This package doesn't do anything without python available
5072        `(("python" ,python)
5073          ;; For multi-dimensional array support
5074          ("python-numpy" ,python-numpy)))
5075       (arguments
5076        '(#:phases
5077          (modify-phases %standard-phases
5078            (add-after 'unpack 'replace-*base-directory*-var
5079              (lambda* (#:key outputs #:allow-other-keys)
5080                ;; In the ASD, the author makes an attempt to
5081                ;; programatically determine the location of the
5082                ;; source-code so lisp can call into "py4cl.py". We can
5083                ;; hard-code this since we know where this file will
5084                ;; reside.
5085                (substitute* "src/callpython.lisp"
5086                  (("py4cl/config:\\*base-directory\\*")
5087                   (string-append
5088                    "\""
5089                    (assoc-ref outputs "out")
5090                    "/share/common-lisp/sbcl-source/py4cl/"
5091                    "\""))))))))
5092       (synopsis "Call python from Common Lisp")
5093       (description
5094        "Py4CL is a bridge between Common Lisp and Python, which enables Common
5095 Lisp to interact with Python code.  It uses streams to communicate with a
5096 separate python process, the approach taken by cl4py.  This is different to
5097 the CFFI approach used by burgled-batteries, but has the same goal.")
5098       (home-page "https://github.com/bendudson/py4cl")
5099       ;; MIT License
5100       (license license:expat))))
5101
5102 (define-public cl-py4cl
5103   (sbcl-package->cl-source-package sbcl-py4cl))
5104
5105 (define-public ecl-py4cl
5106   (sbcl-package->ecl-package sbcl-py4cl))
5107
5108 (define-public sbcl-parse-declarations
5109   (let ((commit "549aebbfb9403a7fe948654126b9c814f443f4f2")
5110         (revision "1"))
5111     (package
5112       (name "sbcl-parse-declarations")
5113       (version (git-version "1.0.0" revision commit))
5114       (source
5115        (origin
5116          (method git-fetch)
5117          (uri (git-reference
5118                (url (string-append
5119                      "https://gitlab.common-lisp.net/parse-declarations/"
5120                      "parse-declarations.git"))
5121                (commit commit)))
5122          (file-name (git-file-name name version))
5123          (sha256
5124           (base32 "03g5qks4c59nmxa48pbslxkfh77h8hn8566jddp6m9pl15dzzpxd"))))
5125       (build-system asdf-build-system/sbcl)
5126       (arguments
5127        `(#:asd-file "parse-declarations-1.0.asd"
5128          #:asd-system-name "parse-declarations-1.0"))
5129       (home-page "https://common-lisp.net/project/parse-declarations/")
5130       (synopsis "Parse, filter, and build declarations")
5131       (description
5132        "Parse-Declarations is a Common Lisp library to help writing
5133 macros which establish bindings.  To be semantically correct, such
5134 macros must take user declarations into account, as these may affect
5135 the bindings they establish.  Yet the ANSI standard of Common Lisp does
5136 not provide any operators to work with declarations in a convenient,
5137 high-level way.  This library provides such operators.")
5138       ;; MIT License
5139       (license license:expat))))
5140
5141 (define-public cl-parse-declarations
5142   (sbcl-package->cl-source-package sbcl-parse-declarations))
5143
5144 (define-public ecl-parse-declarations
5145   (sbcl-package->ecl-package sbcl-parse-declarations))
5146
5147 (define-public sbcl-cl-quickcheck
5148   (let ((commit "807b2792a30c883a2fbecea8e7db355b50ba662f")
5149         (revision "1"))
5150     (package
5151       (name "sbcl-cl-quickcheck")
5152       (version (git-version "0.0.4" revision commit))
5153       (source
5154        (origin
5155          (method git-fetch)
5156          (uri (git-reference
5157                (url "https://github.com/mcandre/cl-quickcheck.git")
5158                (commit commit)))
5159          (file-name (git-file-name name version))
5160          (sha256
5161           (base32
5162            "165lhypq5xkcys6hvzb3jq7ywnmqvzaflda29qk2cbs3ggas4767"))))
5163       (build-system asdf-build-system/sbcl)
5164       (synopsis
5165        "Common Lisp port of the QuickCheck unit test framework")
5166       (description
5167        "Common Lisp port of the QuickCheck unit test framework")
5168       (home-page "https://github.com/mcandre/cl-quickcheck")
5169       ;; MIT
5170       (license license:expat))))
5171
5172 (define-public cl-cl-quickcheck
5173   (sbcl-package->cl-source-package sbcl-cl-quickcheck))
5174
5175 (define-public ecl-cl-quickcheck
5176   (sbcl-package->ecl-package sbcl-cl-quickcheck))
5177
5178 (define-public sbcl-burgled-batteries3
5179   (let ((commit "f65f454d13bb6c40e17e9ec62e41eb5069e09760")
5180         (revision "2"))
5181     (package
5182       (name "sbcl-burgled-batteries3")
5183       (version (git-version "0.0.0" revision commit))
5184       (source
5185        (origin
5186          (method git-fetch)
5187          (uri (git-reference
5188                (url "https://github.com/snmsts/burgled-batteries3.git")
5189                (commit commit)))
5190          (file-name (git-file-name name version))
5191          (sha256
5192           (base32
5193            "1nzn7jawrfajyzwfnzrg2cmn9xxadcqh4szbpg0jggkhdkdzz4wa"))))
5194       (build-system asdf-build-system/sbcl)
5195       (arguments
5196        `(#:tests? #f
5197          #:modules (((guix build python-build-system) #:select (python-version))
5198                     ,@%asdf-build-system-modules)
5199          #:imported-modules ((guix build python-build-system)
5200                              ,@%asdf-build-system-modules)
5201          #:phases
5202          (modify-phases (@ (guix build asdf-build-system) %standard-phases)
5203            (add-after 'unpack 'set-*cpython-include-dir*-var
5204              (lambda* (#:key inputs #:allow-other-keys)
5205                (let ((python (assoc-ref inputs "python")))
5206                  (setenv "BB_PYTHON3_INCLUDE_DIR"
5207                          (string-append python "/include/python"
5208                                         (python-version python)
5209                                         "m"))
5210                  (setenv "BB_PYTHON3_DYLIB"
5211                          (string-append python "/lib/libpython3.so"))
5212                  #t))))))
5213       (native-inputs
5214        `(("sbcl-cl-fad" ,sbcl-cl-fad)
5215          ("sbcl-lift" ,sbcl-lift)
5216          ("sbcl-cl-quickcheck" ,sbcl-cl-quickcheck)))
5217       (inputs
5218        `(("python" ,python)
5219          ("sbcl-cffi" ,sbcl-cffi)
5220          ("sbcl-cffi-grovel" ,sbcl-cffi-grovel)
5221          ("sbcl-alexandria" , sbcl-alexandria)
5222          ("sbcl-parse-declarations-1.0" ,sbcl-parse-declarations)
5223          ("sbcl-trivial-garbage" ,sbcl-trivial-garbage)))
5224       (synopsis "Bridge between Python and Lisp (FFI bindings, etc.)")
5225       (description
5226        "This package provides a shim between Python3 (specifically, the
5227 CPython implementation of Python) and Common Lisp.")
5228       (home-page "https://github.com/snmsts/burgled-batteries3")
5229       (license license:expat))))
5230
5231 (define-public cl-burgled-batteries3
5232   (sbcl-package->cl-source-package sbcl-burgled-batteries3))
5233
5234 (define-public ecl-burgled-batteries3
5235   (sbcl-package->ecl-package sbcl-burgled-batteries3))
5236
5237 (define-public sbcl-metabang-bind
5238   (let ((commit "c93b7f7e1c18c954c2283efd6a7fdab36746ab5e")
5239         (revision "1"))
5240     (package
5241       (name "sbcl-metabang-bind")
5242       (version (git-version "0.8.0" revision commit))
5243       (source
5244        (origin
5245          (method git-fetch)
5246          (uri (git-reference
5247                (url "https://github.com/gwkkwg/metabang-bind.git")
5248                (commit commit)))
5249          (file-name (git-file-name name version))
5250          (sha256
5251           (base32
5252            "0hd0kr91795v77akpbcyqiss9p0p7ypa9dznrllincnmgvsxlmf0"))))
5253       (build-system asdf-build-system/sbcl)
5254       (native-inputs
5255        `(("sbcl-lift" ,sbcl-lift)))
5256       (synopsis "Macro that generalizes @code{multiple-value-bind} etc.")
5257       (description
5258        "Bind extends the idea of of let and destructing to provide a uniform
5259 syntax for all your accessor needs.  It combines @code{let},
5260 @code{destructuring-bind}, @code{with-slots}, @code{with-accessors}, structure
5261 editing, property or association-lists, and @code{multiple-value-bind} and a
5262 whole lot more into a single form.")
5263       (home-page "https://common-lisp.net/project/metabang-bind/")
5264       ;; MIT License
5265       (license license:expat))))
5266
5267 (define-public cl-metabang-bind
5268   (sbcl-package->cl-source-package sbcl-metabang-bind))
5269
5270 (define-public ecl-metabang-bind
5271   (sbcl-package->ecl-package sbcl-metabang-bind))
5272
5273 (define-public sbcl-fare-utils
5274   (let ((commit "66e9c6f1499140bc00ccc22febf2aa528cbb5724")
5275         (revision "1"))
5276     (package
5277       (name "sbcl-fare-utils")
5278       (version (git-version "1.0.0.5" revision commit))
5279       (source
5280        (origin
5281          (method git-fetch)
5282          (uri
5283           (git-reference
5284            (url
5285             "https://gitlab.common-lisp.net/frideau/fare-utils.git")
5286            (commit commit)))
5287          (file-name (git-file-name name version))
5288          (sha256
5289           (base32
5290            "01wsr1aap3jdzhn4hrqjbhsjx6qci9dbd3gh4gayv1p49rbg8aqr"))))
5291       (build-system asdf-build-system/sbcl)
5292       (arguments
5293        `(#:test-asd-file "test/fare-utils-test.asd"))
5294       (native-inputs
5295        `(("sbcl-hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
5296       (synopsis "Collection of utilities and data structures")
5297       (description
5298        "fare-utils is a small collection of utilities.  It contains a lot of
5299 basic everyday functions and macros.")
5300       (home-page "https://gitlab.common-lisp.net/frideau/fare-utils")
5301       ;; MIT License
5302       (license license:expat))))
5303
5304 (define-public cl-fare-utils
5305   (sbcl-package->cl-source-package sbcl-fare-utils))
5306
5307 (define-public ecl-fare-utils
5308   (sbcl-package->ecl-package sbcl-fare-utils))
5309
5310 (define-public sbcl-trivial-utf-8
5311   (let ((commit "4d427cfbb1c452436a0efb71c3205c9da67f718f")
5312         (revision "1"))
5313     (package
5314       (name "sbcl-trivial-utf-8")
5315       (version (git-version "0.0.0" revision commit))
5316       (source
5317        (origin
5318          (method git-fetch)
5319          (uri
5320           (git-reference
5321            (url (string-append "https://gitlab.common-lisp.net/"
5322                                "trivial-utf-8/trivial-utf-8.git"))
5323            (commit commit)))
5324          (file-name (git-file-name name version))
5325          (sha256
5326           (base32
5327            "1jz27gz8gvqdmvp3k9bxschs6d5b3qgk94qp2bj6nv1d0jc3m1l1"))))
5328       (arguments
5329        ;; Guix incorrectly assumes the "8" is part of the version
5330        ;; number and lobs it off.
5331        `(#:asd-file "trivial-utf-8.asd"
5332          #:asd-system-name "trivial-utf-8"))
5333       (build-system asdf-build-system/sbcl)
5334       (synopsis "UTF-8 input/output library")
5335       (description
5336        "The Babel library solves a similar problem while understanding more
5337 encodings.  Trivial UTF-8 was written before Babel existed, but for new
5338 projects you might be better off going with Babel.  The one plus that Trivial
5339 UTF-8 has is that it doesn't depend on any other libraries.")
5340       (home-page "https://common-lisp.net/project/trivial-utf-8/")
5341       (license license:bsd-3))))
5342
5343 (define-public cl-trivial-utf-8
5344   (sbcl-package->cl-source-package sbcl-trivial-utf-8))
5345
5346 (define-public ecl-trivial-utf-8
5347   (sbcl-package->ecl-package sbcl-trivial-utf-8))
5348
5349 (define-public sbcl-idna
5350   (package
5351     (name "sbcl-idna")
5352     (build-system asdf-build-system/sbcl)
5353     (version "0.2.2")
5354     (home-page "https://github.com/antifuchs/idna")
5355     (source
5356      (origin
5357        (method git-fetch)
5358        (uri (git-reference
5359              (url home-page)
5360              (commit version)))
5361        (file-name (git-file-name name version))
5362        (sha256
5363         (base32
5364          "00nbr3mffxhlq14gg9d16pa6691s4qh35inyw76v906s77khm5a2"))))
5365     (inputs
5366      `(("split-sequence" ,sbcl-split-sequence)))
5367     (synopsis "IDNA string encoding and decoding routines for Common Lisp")
5368     (description "This Common Lisp library provides string encoding and
5369 decoding routines for IDNA, the International Domain Names in Applications.")
5370     (license license:expat)))
5371
5372 (define-public cl-idna
5373   (sbcl-package->cl-source-package sbcl-idna))
5374
5375 (define-public ecl-idna
5376   (sbcl-package->ecl-package sbcl-idna))
5377
5378 (define-public sbcl-swap-bytes
5379   (package
5380     (name "sbcl-swap-bytes")
5381     (build-system asdf-build-system/sbcl)
5382     (version "1.2")
5383     (home-page "https://github.com/sionescu/swap-bytes")
5384     (source
5385      (origin
5386        (method git-fetch)
5387        (uri (git-reference
5388              (url home-page)
5389              (commit (string-append "v" version))))
5390        (file-name (git-file-name name version))
5391        (sha256
5392         (base32
5393          "1hw1v1lw26rifyznpnj1csphha9jgzwpiic16ni3pvs6hcsni9rz"))))
5394     (inputs
5395      `(("trivial-features" ,sbcl-trivial-features)))
5396     (native-inputs
5397      `(("fiveam" ,sbcl-fiveam)))
5398     (synopsis "Efficient endianness conversion for Common Lisp")
5399     (description "This Common Lisp library provides optimized byte-swapping
5400 primitives.  The library can change endianness of unsigned integers of length
5401 1/2/4/8.  Very useful in implementing various network protocols and file
5402 formats.")
5403     (license license:expat)))
5404
5405 (define-public cl-swap-bytes
5406   (sbcl-package->cl-source-package sbcl-swap-bytes))
5407
5408 (define-public ecl-swap-bytes
5409   (sbcl-package->ecl-package sbcl-swap-bytes))
5410
5411 (define-public sbcl-iolib.asdf
5412   ;; Latest release is from June 2017.
5413   (let ((commit "7f5ea3a8457a29d224b24653c2b3657fb1898021")
5414         (revision "2"))
5415     (package
5416       (name "sbcl-iolib.asdf")
5417       (build-system asdf-build-system/sbcl)
5418       (version (git-version "0.8.3" revision commit))
5419       (home-page "https://github.com/sionescu/iolib")
5420       (source
5421        (origin
5422          (method git-fetch)
5423          (uri (git-reference
5424                (url home-page)
5425                (commit commit)))
5426          (file-name (git-file-name name version))
5427          (sha256
5428           (base32
5429            "1bg5w7lm61hqk4b0svmri8a590q36z76jfa0sdgzb39r98c04w12"))))
5430       (inputs
5431        `(("alexandria" ,sbcl-alexandria)))
5432       (arguments
5433        '(#:asd-file "iolib.asdf.asd"))
5434       (synopsis "ASDF component classes for IOLib, a Common Lisp I/O library")
5435       (description "IOlib is to be a better and more modern I/O library than
5436 the standard Common Lisp library.  It contains a socket library, a DNS
5437 resolver, an I/O multiplexer(which supports @code{select(2)}, @code{epoll(4)}
5438 and @code{kqueue(2)}), a pathname library and file-system utilities.")
5439       (license license:expat))))
5440
5441 (define-public sbcl-iolib.conf
5442   (package
5443     (inherit sbcl-iolib.asdf)
5444     (name "sbcl-iolib.conf")
5445     (inputs
5446      `(("iolib.asdf" ,sbcl-iolib.asdf)))
5447     (arguments
5448      '(#:asd-file "iolib.conf.asd"))
5449     (synopsis "Compile-time configuration for IOLib, a Common Lisp I/O library")))
5450
5451 (define-public sbcl-iolib.common-lisp
5452   (package
5453     (inherit sbcl-iolib.asdf)
5454     (name "sbcl-iolib.common-lisp")
5455     (inputs
5456      `(("iolib.asdf" ,sbcl-iolib.asdf)
5457        ("iolib.conf" ,sbcl-iolib.conf)))
5458     (arguments
5459      '(#:asd-file "iolib.common-lisp.asd"))
5460     (synopsis "Slightly modified Common Lisp for IOLib, a Common Lisp I/O library")))
5461
5462 (define-public sbcl-iolib.base
5463   (package
5464     (inherit sbcl-iolib.asdf)
5465     (name "sbcl-iolib.base")
5466     (inputs
5467      `(("iolib.asdf" ,sbcl-iolib.asdf)
5468        ("iolib.conf" ,sbcl-iolib.conf)
5469        ("iolib.common-lisp" ,sbcl-iolib.common-lisp)
5470        ("split-sequence" ,sbcl-split-sequence)))
5471     (arguments
5472      '(#:asd-file "iolib.base.asd"))
5473     (synopsis "Base package for IOLib, a Common Lisp I/O library")))
5474
5475 (define-public sbcl-iolib.grovel
5476   (package
5477     (inherit sbcl-iolib.asdf)
5478     (name "sbcl-iolib.grovel")
5479     (inputs
5480      `(("iolib.asdf" ,sbcl-iolib.asdf)
5481        ("iolib.conf" ,sbcl-iolib.conf)
5482        ("iolib.base", sbcl-iolib.base)
5483        ("cffi", sbcl-cffi)))
5484     (arguments
5485      '(#:asd-file "iolib.grovel.asd"
5486        #:phases
5487        (modify-phases %standard-phases
5488          (add-after 'install 'install-header
5489            (lambda* (#:key outputs #:allow-other-keys)
5490              ;; This header is required by sbcl-iolib.
5491              (install-file "src/grovel/grovel-common.h"
5492                            (string-append (assoc-ref outputs "out")
5493                                           "/lib/sbcl"))
5494              #t)))))
5495     (synopsis "CFFI Groveller for IOLib, a Common Lisp I/O library")))
5496
5497 (define sbcl-iolib+syscalls
5498   (package
5499     (inherit sbcl-iolib.asdf)
5500     (name "sbcl-iolib+syscalls")
5501     (inputs
5502      `(("iolib.asdf" ,sbcl-iolib.asdf)
5503        ("iolib.conf" ,sbcl-iolib.conf)
5504        ("cffi-grovel" ,sbcl-cffi-grovel)
5505        ("iolib.base" ,sbcl-iolib.base)
5506        ("bordeaux-threads" ,sbcl-bordeaux-threads)
5507        ("idna" ,sbcl-idna)
5508        ("swap-bytes" ,sbcl-swap-bytes)
5509        ("libfixposix" ,libfixposix)
5510        ("cffi" ,sbcl-cffi)))
5511     (native-inputs
5512      `(("fiveam" ,sbcl-fiveam)))
5513     (arguments
5514      '(#:asd-file "iolib.asd"
5515        #:asd-system-name "iolib/syscalls"
5516        #:phases
5517        (modify-phases %standard-phases
5518          (add-after 'unpack 'fix-paths
5519            (lambda* (#:key inputs #:allow-other-keys)
5520              (substitute* "src/syscalls/ffi-functions-unix.lisp"
5521                (("\\(:default \"libfixposix\"\\)")
5522                 (string-append
5523                  "(:default \""
5524                  (assoc-ref inputs "libfixposix") "/lib/libfixposix\")")))
5525              ;; Socket tests need Internet access, disable them.
5526              (substitute* "iolib.asd"
5527                (("\\(:file \"sockets\" :depends-on \\(\"pkgdcl\" \"defsuites\"\\)\\)")
5528                 "")))))))
5529     (synopsis "Common Lisp I/O library")))
5530
5531 (define sbcl-iolib+multiplex
5532   (package
5533     (inherit sbcl-iolib+syscalls)
5534     (name "sbcl-iolib+multiplex")
5535     (inputs
5536      `(("iolib+syscalls" ,sbcl-iolib+syscalls)
5537        ,@(package-inputs sbcl-iolib+syscalls)))
5538     (arguments
5539      (substitute-keyword-arguments (package-arguments sbcl-iolib+syscalls)
5540        ((#:asd-system-name _) "iolib/multiplex")))))
5541
5542 (define sbcl-iolib+streams
5543   (package
5544     (inherit sbcl-iolib+syscalls)
5545     (name "sbcl-iolib+streams")
5546     (inputs
5547      `(("iolib+multiplex" ,sbcl-iolib+multiplex)
5548        ,@(package-inputs sbcl-iolib+syscalls)))
5549     (arguments
5550      (substitute-keyword-arguments (package-arguments sbcl-iolib+syscalls)
5551        ((#:asd-system-name _) "iolib/streams")))))
5552
5553 (define sbcl-iolib+sockets
5554   (package
5555     (inherit sbcl-iolib+syscalls)
5556     (name "sbcl-iolib+sockets")
5557     (inputs
5558      `(("iolib+syscalls" ,sbcl-iolib+syscalls)
5559        ("iolib+streams" ,sbcl-iolib+streams)
5560        ,@(package-inputs sbcl-iolib+syscalls)))
5561     (arguments
5562      (substitute-keyword-arguments (package-arguments sbcl-iolib+syscalls)
5563        ((#:asd-system-name _) "iolib/sockets")))))
5564
5565 (define-public sbcl-iolib
5566   (package
5567     (inherit sbcl-iolib+syscalls)
5568     (name "sbcl-iolib")
5569     (inputs
5570      `(("iolib+multiplex" ,sbcl-iolib+multiplex)
5571        ("iolib+streams" ,sbcl-iolib+streams)
5572        ("iolib+sockets" ,sbcl-iolib+sockets)
5573        ,@(package-inputs sbcl-iolib+syscalls)))
5574     (arguments
5575      (substitute-keyword-arguments (package-arguments sbcl-iolib+syscalls)
5576        ((#:asd-system-name _) "iolib")))))
5577
5578 (define-public cl-iolib
5579   (sbcl-package->cl-source-package sbcl-iolib))
5580
5581 (define-public sbcl-ieee-floats
5582   (let ((commit "566b51a005e81ff618554b9b2f0b795d3b29398d")
5583         (revision "1"))
5584     (package
5585       (name "sbcl-ieee-floats")
5586       (build-system asdf-build-system/sbcl)
5587       (version (git-version "20170924" revision commit))
5588       (home-page "https://github.com/marijnh/ieee-floats/")
5589       (source
5590        (origin
5591          (method git-fetch)
5592          (uri (git-reference
5593                (url home-page)
5594                (commit commit)))
5595          (file-name (git-file-name name version))
5596          (sha256
5597           (base32
5598            "1xyj49j9x3lc84cv3dhbf9ja34ywjk1c46dklx425fxw9mkwm83m"))))
5599       (native-inputs
5600        `(("fiveam" ,sbcl-fiveam)))
5601       (synopsis "IEEE 754 binary representation for floats in Common Lisp")
5602       (description "This is a Common Lisp library that converts
5603 floating point values to IEEE 754 binary representation.")
5604       (license license:bsd-3))))
5605
5606 (define-public cl-ieee-floats
5607   (sbcl-package->cl-source-package sbcl-ieee-floats))
5608
5609 (define sbcl-closure-common
5610   (let ((commit "e3c5f5f454b72b01b89115e581c3c52a7e201e5c")
5611         (revision "1"))
5612     (package
5613       (name "sbcl-closure-common")
5614       (build-system asdf-build-system/sbcl)
5615       (version (git-version "20101006" revision commit))
5616       (home-page "https://common-lisp.net/project/cxml/")
5617       (source
5618        (origin
5619          (method git-fetch)
5620          (uri (git-reference
5621                (url "https://github.com/sharplispers/closure-common")
5622                (commit commit)))
5623          (file-name (git-file-name name version))
5624          (sha256
5625           (base32
5626            "0k5r2qxn122pxi301ijir3nayi9sg4d7yiy276l36qmzwhp4mg5n"))))
5627       (inputs
5628        `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)
5629          ("babel" ,sbcl-babel)))
5630       (synopsis "Support Common Lisp library for CXML")
5631       (description "Closure-common is an internal helper library.  The name
5632 Closure is a reference to the web browser it was originally written for.")
5633       ;; TODO: License?
5634       (license #f))))
5635
5636 (define-public sbcl-cxml+xml
5637   (let ((commit "00b22bf4c4cf11c993d5866fae284f95ab18e6bf")
5638         (revision "1"))
5639     (package
5640       (name "sbcl-cxml+xml")
5641       (build-system asdf-build-system/sbcl)
5642       (version (git-version "0.0.0" revision commit))
5643       (home-page "https://common-lisp.net/project/cxml/")
5644       (source
5645        (origin
5646          (method git-fetch)
5647          (uri (git-reference
5648                (url "https://github.com/sharplispers/cxml")
5649                (commit commit)))
5650          (file-name (git-file-name name version))
5651          (sha256
5652           (base32
5653            "13kif7rf3gqdycsk9zq0d7y0g9y81krkl0z87k0p2fkbjfgrph37"))))
5654       (inputs
5655        `(("closure-common" ,sbcl-closure-common)
5656          ("puri" ,sbcl-puri)
5657          ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
5658       (arguments
5659        `(#:asd-file "cxml.asd"
5660          #:asd-system-name "cxml/xml"))
5661       (synopsis "Common Lisp XML parser")
5662       (description "CXML implements a namespace-aware, validating XML 1.0
5663 parser as well as the DOM Level 2 Core interfaces.  Two parser interfaces are
5664 offered, one SAX-like, the other similar to StAX.")
5665       (license license:llgpl))))
5666
5667 (define sbcl-cxml+dom
5668   (package
5669     (inherit sbcl-cxml+xml)
5670     (name "sbcl-cxml+dom")
5671     (inputs
5672      `(("closure-common" ,sbcl-closure-common)
5673        ("puri" ,sbcl-puri)
5674        ("cxml+xml" ,sbcl-cxml+xml)))
5675     (arguments
5676      `(#:asd-file "cxml.asd"
5677        #:asd-system-name "cxml/dom"))))
5678
5679 (define sbcl-cxml+klacks
5680   (package
5681     (inherit sbcl-cxml+xml)
5682     (name "sbcl-cxml+klacks")
5683     (inputs
5684      `(("closure-common" ,sbcl-closure-common)
5685        ("puri" ,sbcl-puri)
5686        ("cxml+xml" ,sbcl-cxml+xml)))
5687     (arguments
5688      `(#:asd-file "cxml.asd"
5689        #:asd-system-name "cxml/klacks"))))
5690
5691 (define sbcl-cxml+test
5692   (package
5693     (inherit sbcl-cxml+xml)
5694     (name "sbcl-cxml+test")
5695     (inputs
5696      `(("closure-common" ,sbcl-closure-common)
5697        ("puri" ,sbcl-puri)
5698        ("cxml+xml" ,sbcl-cxml+xml)))
5699     (arguments
5700      `(#:asd-file "cxml.asd"
5701        #:asd-system-name "cxml/test"))))
5702
5703 (define-public sbcl-cxml
5704   (package
5705     (inherit sbcl-cxml+xml)
5706     (name "sbcl-cxml")
5707     (inputs
5708      `(("closure-common" ,sbcl-closure-common)
5709        ("puri" ,sbcl-puri)
5710        ("trivial-gray-streams" ,sbcl-trivial-gray-streams)
5711        ("cxml+dom" ,sbcl-cxml+dom)
5712        ("cxml+klacks" ,sbcl-cxml+klacks)
5713        ("cxml+test" ,sbcl-cxml+test)))
5714     (arguments
5715      `(#:asd-file "cxml.asd"
5716        #:asd-system-name "cxml"
5717        #:phases
5718        (modify-phases %standard-phases
5719          (add-after 'build 'install-dtd
5720            (lambda* (#:key outputs #:allow-other-keys)
5721              (install-file "catalog.dtd"
5722                            (string-append
5723                             (assoc-ref outputs "out")
5724                             "/lib/" (%lisp-type)))))
5725          (add-after 'create-asd 'remove-component
5726            ;; XXX: The original .asd has no components, but our build system
5727            ;; creates an entry nonetheless.  We need to remove it for the
5728            ;; generated .asd to load properly.  See trivia.trivial for a
5729            ;; similar problem.
5730            (lambda* (#:key outputs #:allow-other-keys)
5731              (let* ((out (assoc-ref outputs "out"))
5732                     (asd (string-append out "/lib/sbcl/cxml.asd")))
5733                (substitute* asd
5734                  (("  :components
5735 ")
5736                   ""))
5737                (substitute* asd
5738                  ((" *\\(\\(:compiled-file \"cxml--system\"\\)\\)")
5739                   ""))))))))))
5740
5741 (define-public cl-cxml
5742   (sbcl-package->cl-source-package sbcl-cxml))
5743
5744 (define-public sbcl-cl-reexport
5745   (let ((commit "312f3661bbe187b5f28536cd7ec2956e91366c3b")
5746         (revision "1"))
5747     (package
5748       (name "sbcl-cl-reexport")
5749       (build-system asdf-build-system/sbcl)
5750       (version (git-version "0.1" revision commit))
5751       (home-page "https://github.com/takagi/cl-reexport")
5752       (source
5753        (origin
5754          (method git-fetch)
5755          (uri (git-reference
5756                (url home-page)
5757                (commit commit)))
5758          (file-name (git-file-name name version))
5759          (sha256
5760           (base32
5761            "1cwpn1m3wrl0fl9plznn7p464db646gnfc8zkyk97dyxski2aq0x"))))
5762       (inputs
5763        `(("alexandria" ,sbcl-alexandria)))
5764       (arguments
5765        ;; TODO: Tests fail because cl-test-more is missing, but I can't find it online.
5766        `(#:tests? #f))
5767       (synopsis "HTTP cookie manager for Common Lisp")
5768       (description "cl-cookie is a Common Lisp library featuring parsing of
5769 cookie headers, cookie creation, cookie jar creation and more.")
5770       (license license:llgpl))))
5771
5772 (define-public cl-reexport
5773   (sbcl-package->cl-source-package sbcl-cl-reexport))
5774
5775 (define-public sbcl-cl-cookie
5776   (let ((commit "cea55aed8b9ad25fafd13defbcb9fe8f41b29546")
5777         (revision "1"))
5778     (package
5779       (name "sbcl-cl-cookie")
5780       (build-system asdf-build-system/sbcl)
5781       (version (git-version "0.9.10" revision commit))
5782       (home-page "https://github.com/fukamachi/cl-cookie")
5783       (source
5784        (origin
5785          (method git-fetch)
5786          (uri (git-reference
5787                (url home-page)
5788                (commit commit)))
5789          (file-name (git-file-name name version))
5790          (sha256
5791           (base32
5792            "090g7z75h98zvc1ldx0vh4jn4086dhjm2w30jcwkq553qmyxwl8h"))))
5793       (inputs
5794        `(("proc-parse" ,sbcl-proc-parse)
5795          ("alexandria" ,sbcl-alexandria)
5796          ("quri" ,sbcl-quri)
5797          ("cl-ppcre" ,sbcl-cl-ppcre)
5798          ("local-time" ,sbcl-local-time)))
5799       (native-inputs
5800        `(("prove-asdf" ,sbcl-prove-asdf)
5801          ("prove" ,sbcl-prove)))
5802       (arguments
5803        ;; TODO: Tests fail because cl-cookie depends on cl-cookie-test.
5804        `(#:tests? #f))
5805       (synopsis "HTTP cookie manager for Common Lisp")
5806       (description "cl-cookie is a Common Lisp library featuring parsing of
5807 cookie headers, cookie creation, cookie jar creation and more.")
5808       (license license:bsd-2))))
5809
5810 (define-public cl-cookie
5811   (sbcl-package->cl-source-package sbcl-cl-cookie))
5812
5813 (define-public sbcl-dexador
5814   (let ((commit "a2714d126cc94bc7a9a6e1e3c08de455b3a66378")
5815         (revision "1"))
5816     (package
5817       (name "sbcl-dexador")
5818       (build-system asdf-build-system/sbcl)
5819       (version (git-version "0.9.10" revision commit))
5820       (home-page "https://github.com/fukamachi/dexador")
5821       (source
5822        (origin
5823          (method git-fetch)
5824          (uri (git-reference
5825                (url home-page)
5826                (commit commit)))
5827          (file-name (git-file-name name version))
5828          (sha256
5829           (base32
5830            "0nbqgn4v3l2z6m1k1bdxfnqpfrk84nxdmz7csz11zzcfs4flkv79"))))
5831       (inputs
5832        `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)
5833          ("babel" ,sbcl-babel)
5834          ("usocket" ,sbcl-usocket)
5835          ("fast-http" ,sbcl-fast-http)
5836          ("quri" ,sbcl-quri)
5837          ("fast-io" ,sbcl-fast-io)
5838          ("chunga" ,sbcl-chunga)
5839          ("cl-ppcre" ,sbcl-cl-ppcre)
5840          ("cl-cookie" ,sbcl-cl-cookie)
5841          ("trivial-mimes" ,sbcl-trivial-mimes)
5842          ("chipz" ,sbcl-chipz)
5843          ("cl-base64" ,sbcl-cl-base64)
5844          ("cl-reexport" ,sbcl-cl-reexport)
5845          ("cl+ssl" ,sbcl-cl+ssl)
5846          ("bordeaux-threads" ,sbcl-bordeaux-threads)
5847          ("alexandria" ,sbcl-alexandria)))
5848       (native-inputs
5849        `(("prove" ,sbcl-prove)
5850          ("prove-asdf" ,sbcl-prove-asdf)
5851          ("lack-request" ,sbcl-lack-request)
5852          ("clack" ,sbcl-clack)
5853          ("babel" ,sbcl-babel)
5854          ("alexandria" ,sbcl-alexandria)
5855          ("cl-ppcre" ,sbcl-cl-ppcre)
5856          ("local-time" ,sbcl-local-time)))
5857       (arguments
5858        ;; TODO: Circular dependency: tests depend on clack-test which depends on dexador.
5859        `(#:tests? #f
5860          #:phases
5861          (modify-phases %standard-phases
5862            (add-after 'unpack 'fix-permissions
5863              (lambda _ (make-file-writable "t/data/test.gz") #t)))))
5864       (synopsis "Yet another HTTP client for Common Lisp")
5865       (description "Dexador is yet another HTTP client for Common Lisp with
5866 neat APIs and connection-pooling.  It is meant to supersede Drakma.")
5867       (license license:expat))))
5868
5869 (define-public cl-dexador
5870   (package
5871     (inherit (sbcl-package->cl-source-package sbcl-dexador))
5872     (arguments
5873      `(#:phases
5874        ;; asdf-build-system/source has its own phases and does not inherit
5875        ;; from asdf-build-system/sbcl phases.
5876        (modify-phases %standard-phases/source
5877          (add-after 'unpack 'fix-permissions
5878            (lambda _ (make-file-writable "t/data/test.gz") #t)))))))
5879
5880 (define-public ecl-dexador
5881   (sbcl-package->ecl-package sbcl-dexador))
5882
5883 (define-public sbcl-lisp-namespace
5884   (let ((commit "28107cafe34e4c1c67490fde60c7f92dc610b2e0")
5885         (revision "1"))
5886     (package
5887       (name "sbcl-lisp-namespace")
5888       (build-system asdf-build-system/sbcl)
5889       (version (git-version "0.1" revision commit))
5890       (home-page "https://github.com/guicho271828/lisp-namespace")
5891       (source
5892        (origin
5893          (method git-fetch)
5894          (uri (git-reference
5895                (url home-page)
5896                (commit commit)))
5897          (file-name (git-file-name name version))
5898          (sha256
5899           (base32
5900            "1jw2wykp06z2afb9nm1lgfzll5cjlj36pnknjx614057zkkxq4iy"))))
5901       (inputs
5902        `(("alexandria" ,sbcl-alexandria)))
5903       (native-inputs
5904        `(("fiveam" ,sbcl-fiveam)))
5905       (arguments
5906        `(#:test-asd-file "lisp-namespace.test.asd"
5907         ;; XXX: Component LISP-NAMESPACE-ASD::LISP-NAMESPACE.TEST not found
5908          #:tests? #f))
5909       (synopsis "LISP-N, or extensible namespaces in Common Lisp")
5910       (description "Common Lisp already has major 2 namespaces, function
5911 namespace and value namespace (or variable namespace), but there are actually
5912 more — e.g., class namespace.
5913 This library offers macros to deal with symbols from any namespace.")
5914       (license license:llgpl))))
5915
5916 (define-public cl-lisp-namespace
5917   (sbcl-package->cl-source-package sbcl-lisp-namespace))
5918
5919 (define-public sbcl-trivial-cltl2
5920   (let ((commit "8eec8407df833e8f27df8a388bc10913f16d9e83")
5921         (revision "1"))
5922     (package
5923       (name "sbcl-trivial-cltl2")
5924       (build-system asdf-build-system/sbcl)
5925       (version (git-version "0.1.1" revision commit))
5926       (home-page "https://github.com/Zulu-Inuoe/trivial-cltl2")
5927       (source
5928        (origin
5929          (method git-fetch)
5930          (uri (git-reference
5931                (url home-page)
5932                (commit commit)))
5933          (file-name (git-file-name name version))
5934          (sha256
5935           (base32
5936            "1dyyxz17vqv8hlfwq287gl8xxbvcnq798ajb7p5jdjz91wqf4bgk"))))
5937       (synopsis "Simple CLtL2 compatibility layer for Common Lisp")
5938       (description "This library is a portable compatibility layer around
5939 \"Common Lisp the Language, 2nd
5940 Edition\" (@url{https://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node102.html})
5941 and it exports symbols from implementation-specific packages.")
5942       (license license:llgpl))))
5943
5944 (define-public cl-trivial-cltl2
5945   (sbcl-package->cl-source-package sbcl-trivial-cltl2))
5946
5947 (define-public sbcl-introspect-environment
5948   (let ((commit "fff42f8f8fd0d99db5ad6c5812e53de7d660020b")
5949         (revision "1"))
5950     (package
5951       (name "sbcl-introspect-environment")
5952       (build-system asdf-build-system/sbcl)
5953       (version (git-version "0.1" revision commit))
5954       (home-page "https://github.com/Bike/introspect-environment")
5955       (source
5956        (origin
5957          (method git-fetch)
5958          (uri (git-reference
5959                (url home-page)
5960                (commit commit)))
5961          (file-name (git-file-name name version))
5962          (sha256
5963           (base32
5964            "1i305n0wfmpac63ni4i3vixnnkl8daw5ncxy0k3dv92krgx6qzhp"))))
5965       (native-inputs
5966        `(("fiveam" ,sbcl-fiveam)))
5967       (synopsis "Common Lisp environment introspection portability layer")
5968       (description "This library is a small interface to portable but
5969 nonstandard introspection of Common Lisp environments.  It is intended to
5970 allow a bit more compile-time introspection of environments in Common Lisp.
5971
5972 Quite a bit of information is available at the time a macro or compiler-macro
5973 runs; inlining info, type declarations, that sort of thing.  This information
5974 is all standard - any Common Lisp program can @code{(declare (integer x))} and
5975 such.
5976
5977 This info ought to be accessible through the standard @code{&environment}
5978 parameters, but it is not.  Several implementations keep the information for
5979 their own purposes but do not make it available to user programs, because
5980 there is no standard mechanism to do so.
5981
5982 This library uses implementation-specific hooks to make information available
5983 to users.  This is currently supported on SBCL, CCL, and CMUCL.  Other
5984 implementations have implementations of the functions that do as much as they
5985 can and/or provide reasonable defaults.")
5986       (license license:wtfpl2))))
5987
5988 (define-public cl-introspect-environment
5989   (sbcl-package->cl-source-package sbcl-introspect-environment))
5990
5991 (define-public sbcl-type-i
5992   (let ((commit "dea233f45f94064105ec09f0767de338f67dcbe2")
5993         (revision "1"))
5994     (package
5995       (name "sbcl-type-i")
5996       (build-system asdf-build-system/sbcl)
5997       (version (git-version "0.1" revision commit))
5998       (home-page "https://github.com/guicho271828/type-i")
5999       (source
6000        (origin
6001          (method git-fetch)
6002          (uri (git-reference
6003                (url home-page)
6004                (commit commit)))
6005          (file-name (git-file-name name version))
6006          (sha256
6007           (base32
6008            "039g5pbrhh65s0bhr9314gmd2nwc2y5lp2377c5qrc2lxky89qs3"))))
6009       (inputs
6010        `(("alexandria" ,sbcl-alexandria)
6011          ("introspect-environment" ,sbcl-introspect-environment)
6012          ("trivia.trivial" ,sbcl-trivia.trivial)))
6013       (native-inputs
6014        `(("fiveam" ,sbcl-fiveam)))
6015       (arguments
6016        `(#:test-asd-file "type-i.test.asd"))
6017       (synopsis "Type inference utility on unary predicates for Common Lisp")
6018       (description "This library tries to provide a way to detect what kind of
6019 type the given predicate is trying to check.  This is different from inferring
6020 the return type of a function.")
6021       (license license:llgpl))))
6022
6023 (define-public cl-type-i
6024   (sbcl-package->cl-source-package sbcl-type-i))
6025
6026 (define-public sbcl-optima
6027   (let ((commit "373b245b928c1a5cce91a6cb5bfe5dd77eb36195")
6028         (revision "1"))
6029     (package
6030       (name "sbcl-optima")
6031       (build-system asdf-build-system/sbcl)
6032       (version (git-version "1.0" revision commit))
6033       (home-page "https://github.com/m2ym/optima")
6034       (source
6035        (origin
6036          (method git-fetch)
6037          (uri (git-reference
6038                (url home-page)
6039                (commit commit)))
6040          (file-name (git-file-name name version))
6041          (sha256
6042           (base32
6043            "1yw4ymq7ms89342kkvb3aqxgv0w38m9kd8ikdqxxzyybnkjhndal"))))
6044       (inputs
6045        `(("alexandria" ,sbcl-alexandria)
6046          ("closer-mop" ,sbcl-closer-mop)))
6047       (native-inputs
6048        `(("eos" ,sbcl-eos)))
6049       (arguments
6050        ;; XXX: Circular dependencies: tests depend on optima.ppcre which depends on optima.
6051        `(#:tests? #f
6052          #:test-asd-file "optima.test.asd"))
6053       (synopsis "Optimized pattern matching library for Common Lisp")
6054       (description "Optima is a fast pattern matching library which uses
6055 optimizing techniques widely used in the functional programming world.")
6056       (license license:expat))))
6057
6058 (define-public cl-optima
6059   (sbcl-package->cl-source-package sbcl-optima))
6060
6061 (define-public sbcl-fare-quasiquote
6062   (let ((commit "640d39a0451094071b3e093c97667b3947f43639")
6063         (revision "1"))
6064     (package
6065       (name "sbcl-fare-quasiquote")
6066       (build-system asdf-build-system/sbcl)
6067       (version (git-version "1.0.1" revision commit))
6068       (home-page "https://gitlab.common-lisp.net/frideau/fare-quasiquote")
6069       (source
6070        (origin
6071          (method git-fetch)
6072          (uri (git-reference
6073                (url (string-append "https://gitlab.common-lisp.net/frideau/"
6074                                    "fare-quasiquote.git"))
6075                (commit commit)))
6076          (file-name (git-file-name name version))
6077          (sha256
6078           (base32 "1g6q11l50kgija9f55lzqpcwvaq0ljiw8v1j265hnyg6nahjwjvg"))))
6079       (inputs
6080        `(("fare-utils" ,sbcl-fare-utils)))
6081       (arguments
6082        ;; XXX: Circular dependencies: Tests depend on subsystems,
6083        ;; which depend on the main systems.
6084        `(#:tests? #f
6085          #:phases
6086          (modify-phases %standard-phases
6087            ;; XXX: Require 1.0.0 version of fare-utils, and we package some
6088            ;; commits after 1.0.0.5, but ASDF fails to read the
6089            ;; "-REVISION-COMMIT" part generated by Guix.
6090            (add-after 'unpack 'patch-requirement
6091              (lambda _
6092                (substitute* "fare-quasiquote.asd"
6093                  (("\\(:version \"fare-utils\" \"1.0.0\"\\)")
6094                   "\"fare-utils\"")))))))
6095       (synopsis "Pattern-matching friendly implementation of quasiquote")
6096       (description "The main purpose of this n+2nd reimplementation of
6097 quasiquote is enable matching of quasiquoted patterns, using Optima or
6098 Trivia.")
6099       (license license:expat))))
6100
6101 (define-public cl-fare-quasiquote
6102   (sbcl-package->cl-source-package sbcl-fare-quasiquote))
6103
6104 (define-public sbcl-fare-quasiquote-optima
6105   (package
6106     (inherit sbcl-fare-quasiquote)
6107     (name "sbcl-fare-quasiquote-optima")
6108     (inputs
6109      `(("optima" ,sbcl-optima)
6110        ("fare-quasiquote" ,sbcl-fare-quasiquote)))
6111     (arguments
6112      '(#:phases
6113        (modify-phases %standard-phases
6114          (add-after 'unpack 'patch-requirement
6115            (lambda _
6116              (substitute* "fare-quasiquote-optima.asd"
6117                (("\\(:version \"optima\" \"1\\.0\"\\)")
6118                 "\"optima\""))
6119              #t)))))))
6120
6121 (define-public cl-fare-quasiquote-optima
6122   (sbcl-package->cl-source-package sbcl-fare-quasiquote-optima))
6123
6124 (define-public sbcl-fare-quasiquote-readtable
6125   (package
6126     (inherit sbcl-fare-quasiquote)
6127     (name "sbcl-fare-quasiquote-readtable")
6128     (inputs
6129      `(("fare-quasiquote" ,sbcl-fare-quasiquote)
6130        ("named-readtables" ,sbcl-named-readtables)))
6131     (description "The main purpose of this n+2nd reimplementation of
6132 quasiquote is enable matching of quasiquoted patterns, using Optima or
6133 Trivia.
6134
6135 This package uses fare-quasiquote with named-readtable.")))
6136
6137 (define-public cl-fare-quasiquote-readtable
6138   (sbcl-package->cl-source-package sbcl-fare-quasiquote-readtable))
6139
6140 ;; TODO: Add support for component-less system in asdf-build-system/sbcl.
6141 (define-public sbcl-fare-quasiquote-extras
6142   (package
6143     (inherit sbcl-fare-quasiquote)
6144     (name "sbcl-fare-quasiquote-extras")
6145     (build-system asdf-build-system/sbcl)
6146     (inputs
6147      `(("fare-quasiquote-optima" ,sbcl-fare-quasiquote-optima)
6148        ("fare-quasiquote-readtable" ,sbcl-fare-quasiquote-readtable)))
6149     (arguments
6150      `(#:phases
6151        (modify-phases %standard-phases
6152          (replace 'build
6153            (lambda* (#:key outputs #:allow-other-keys)
6154              (let* ((out (assoc-ref outputs "out"))
6155                     (lib (string-append out "/lib/" (%lisp-type))))
6156                (mkdir-p lib)
6157                (install-file "fare-quasiquote-extras.asd" lib)
6158                (make-file-writable
6159                 (string-append lib "/fare-quasiquote-extras.asd"))
6160                #t)))
6161          (add-after 'create-asd-file 'fix-asd-file
6162            (lambda* (#:key outputs #:allow-other-keys)
6163              (let* ((out (assoc-ref outputs "out"))
6164                     (lib (string-append out "/lib/" (%lisp-type)))
6165                     (asd (string-append lib "/fare-quasiquote-extras.asd")))
6166                (substitute* asd
6167                  ((":class")
6168                   "")
6169                  (("asdf/bundle:prebuilt-system")
6170                   "")
6171                  ((":components")
6172                   "")
6173                  (("\\(\\(:compiled-file \"fare-quasiquote-extras--system\"\\)\\)")
6174                   "")))
6175              #t)))))
6176     (description "This library combines @code{fare-quasiquote-readtable} and
6177 @code{fare-quasiquote-optima}.")))
6178
6179 (define-public cl-fare-quasiquote-extras
6180   (package
6181     (inherit cl-fare-quasiquote)
6182     (name "cl-fare-quasiquote-extras")
6183     (build-system asdf-build-system/source)
6184     (propagated-inputs
6185      `(("fare-quasiquote" ,cl-fare-quasiquote)
6186        ("fare-quasiquote-optima" ,cl-fare-quasiquote-optima)
6187        ("fare-quasiquote-readtable" ,cl-fare-quasiquote-readtable)))
6188     (description "This library combines @code{fare-quasiquote-readtable} and
6189 @code{fare-quasiquote-optima}.")))
6190
6191 (define-public sbcl-trivia.level0
6192   (let ((commit "574901ac376ae54c9d37169fd5efab9b3b8fcc63")
6193         (revision "1"))
6194     (package
6195       (name "sbcl-trivia.level0")
6196       (build-system asdf-build-system/sbcl)
6197       (version (git-version "0.0.0" revision commit))
6198       (home-page "https://github.com/guicho271828/trivia")
6199       (source
6200        (origin
6201          (method git-fetch)
6202          (uri (git-reference
6203                (url home-page)
6204                (commit commit)))
6205          (file-name (git-file-name name version))
6206          (sha256
6207           (base32
6208            "0hf53n71xzr9sjwrxis5fivx3drclf4s39h5ck8vh21ndqj9zvdk"))))
6209       (inputs
6210        `(("alexandria" ,sbcl-alexandria)))
6211       (synopsis "Pattern matching in Common Lisp")
6212       (description "Trivia is a pattern matching compiler that is compatible
6213 with Optima, another pattern matching library for Common Lisp.  It is meant to
6214 be faster and more extensible than Optima.")
6215       (license license:llgpl))))
6216
6217 (define-public sbcl-trivia.level1
6218   (package
6219     (inherit sbcl-trivia.level0)
6220     (name "sbcl-trivia.level1")
6221     (inputs
6222      `(("trivia.level0" ,sbcl-trivia.level0)))
6223     (description "Trivia is a pattern matching compiler that is compatible
6224 with Optima, another pattern matching library for Common Lisp.  It is meant to
6225 be faster and more extensible than Optima.
6226
6227 This system contains the core patterns of Trivia.")))
6228
6229 (define-public sbcl-trivia.level2
6230   (package
6231     (inherit sbcl-trivia.level0)
6232     (name "sbcl-trivia.level2")
6233     (inputs
6234      `(("trivia.level1" ,sbcl-trivia.level1)
6235        ("lisp-namespace" ,sbcl-lisp-namespace)
6236        ("trivial-cltl2" ,sbcl-trivial-cltl2)
6237        ("closer-mop" ,sbcl-closer-mop)))
6238     (description "Trivia is a pattern matching compiler that is compatible
6239 with Optima, another pattern matching library for Common Lisp.  It is meant to
6240 be faster and more extensible than Optima.
6241
6242 This system contains a non-optimized pattern matcher compatible with Optima,
6243 with extensible optimizer interface.")))
6244
6245 (define-public sbcl-trivia.trivial
6246   (package
6247     (inherit sbcl-trivia.level0)
6248     (name "sbcl-trivia.trivial")
6249     (inputs
6250      `(("trivia.level2" ,sbcl-trivia.level2)))
6251     (arguments
6252      `(#:phases
6253        (modify-phases %standard-phases
6254          (replace 'create-asd-file
6255            (lambda* (#:key outputs inputs #:allow-other-keys)
6256              (let* ((out (assoc-ref outputs "out"))
6257                     (lib (string-append out "/lib/" (%lisp-type)))
6258                     (level2 (assoc-ref inputs "trivia.level2")))
6259                (mkdir-p lib)
6260                (install-file "trivia.trivial.asd" lib)
6261                ;; XXX: This .asd does not have any component and the build
6262                ;; system fails to work in this case.  We should update the
6263                ;; build system to handle component-less .asd.
6264                ;; TODO: How do we append to file in Guile?  It seems that
6265                ;; (open-file ... "a") gets a "Permission denied".
6266                (substitute* (string-append lib "/trivia.trivial.asd")
6267                  (("\"\\)")
6268                   (string-append "\")
6269
6270 (progn (asdf/source-registry:ensure-source-registry)
6271        (setf (gethash
6272                \"trivia.level2\"
6273                asdf/source-registry:*source-registry*)
6274              #p\""
6275                                  level2
6276                                  "/share/common-lisp/sbcl-bundle-systems/trivia.level2.asd\"))")))))))))
6277     (description "Trivia is a pattern matching compiler that is compatible
6278 with Optima, another pattern matching library for Common Lisp.  It is meant to
6279 be faster and more extensible than Optima.
6280
6281 This system contains the base level system of Trivia with a trivial optimizer.")))
6282
6283 (define-public sbcl-trivia.balland2006
6284   (package
6285     (inherit sbcl-trivia.level0)
6286     (name "sbcl-trivia.balland2006")
6287     (inputs
6288      `(("trivia.trivial" ,sbcl-trivia.trivial)
6289        ("iterate" ,sbcl-iterate)
6290        ("type-i" ,sbcl-type-i)
6291        ("alexandria" ,sbcl-alexandria)))
6292     (arguments
6293      ;; Tests are done in trivia itself.
6294      `(#:tests? #f))
6295     (description "Trivia is a pattern matching compiler that is compatible
6296 with Optima, another pattern matching library for Common Lisp.  It is meant to
6297 be faster and more extensible than Optima.
6298
6299 This system contains the base level system of Trivia with a trivial optimizer.")))
6300
6301 (define-public sbcl-trivia.ppcre
6302   (package
6303     (inherit sbcl-trivia.level0)
6304     (name "sbcl-trivia.ppcre")
6305     (inputs
6306      `(("trivia.trivial" ,sbcl-trivia.trivial)
6307        ("cl-ppcre" ,sbcl-cl-ppcre)))
6308     (description "Trivia is a pattern matching compiler that is compatible
6309 with Optima, another pattern matching library for Common Lisp.  It is meant to
6310 be faster and more extensible than Optima.
6311
6312 This system contains the PPCRE extension.")))
6313
6314 (define-public sbcl-trivia.quasiquote
6315   (package
6316     (inherit sbcl-trivia.level0)
6317     (name "sbcl-trivia.quasiquote")
6318     (inputs
6319      `(("trivia.trivial" ,sbcl-trivia.trivial)
6320        ("fare-quasiquote" ,sbcl-fare-quasiquote)
6321        ("fare-quasiquote-readtable" ,sbcl-fare-quasiquote-readtable)))
6322     (description "Trivia is a pattern matching compiler that is compatible
6323 with Optima, another pattern matching library for Common Lisp.  It is meant to
6324 be faster and more extensible than Optima.
6325
6326 This system contains the fare-quasiquote extension.")))
6327
6328 (define-public sbcl-trivia.cffi
6329   (package
6330     (inherit sbcl-trivia.level0)
6331     (name "sbcl-trivia.cffi")
6332     (inputs
6333      `(("cffi" ,sbcl-cffi)
6334        ("trivia.trivial" ,sbcl-trivia.trivial)))
6335     (description "Trivia is a pattern matching compiler that is compatible
6336 with Optima, another pattern matching library for Common Lisp.  It is meant to
6337 be faster and more extensible than Optima.
6338
6339 This system contains the CFFI foreign slot access extension.")))
6340
6341 (define-public sbcl-trivia
6342   (package
6343     (inherit sbcl-trivia.level0)
6344     (name "sbcl-trivia")
6345     (inputs
6346      `(("trivia.balland2006" ,sbcl-trivia.balland2006)))
6347     (native-inputs
6348      `(("fiveam" ,sbcl-fiveam)
6349        ("trivia.ppcre" ,sbcl-trivia.ppcre)
6350        ("trivia.quasiquote" ,sbcl-trivia.quasiquote)
6351        ("trivia.cffi" ,sbcl-trivia.cffi)
6352        ("optima" ,sbcl-optima)))
6353     (arguments
6354      `(#:test-asd-file "trivia.test.asd"
6355        #:phases
6356        (modify-phases %standard-phases
6357          (add-after 'create-asd 'remove-component
6358            ;; XXX: The original .asd has no components, but our build system
6359            ;; creates an entry nonetheless.  We need to remove it for the
6360            ;; generated .asd to load properly.  See trivia.trivial for a
6361            ;; similar problem.
6362            (lambda* (#:key outputs #:allow-other-keys)
6363              (let* ((out (assoc-ref outputs "out"))
6364                     (asd (string-append out "/lib/" (%lisp-type) "/trivia.asd")))
6365                (substitute* asd
6366                  (("  :components
6367 ")
6368                   ""))
6369                (substitute* asd
6370                  ((" *\\(\\(:compiled-file \"trivia--system\"\\)\\)")
6371                   ""))))))))
6372     (description "Trivia is a pattern matching compiler that is compatible
6373 with Optima, another pattern matching library for Common Lisp.  It is meant to
6374 be faster and more extensible than Optima.")))
6375
6376 (define-public cl-trivia
6377   (sbcl-package->cl-source-package sbcl-trivia))
6378
6379 (define-public sbcl-mk-string-metrics
6380   (package
6381     (name "sbcl-mk-string-metrics")
6382     (version "0.1.2")
6383     (home-page "https://github.com/cbaggers/mk-string-metrics/")
6384     (source (origin
6385               (method git-fetch)
6386               (uri (git-reference
6387                     (url home-page)
6388                     (commit version)))
6389               (sha256
6390                (base32 "0bg0bv2mfd4k0g3x72x563hvmrx18xavaffr6xk5rh4if5j7kcf6"))
6391               (file-name (git-file-name name version))))
6392     (build-system asdf-build-system/sbcl)
6393     (synopsis "Calculate various string metrics efficiently in Common Lisp")
6394     (description "This library implements efficient algorithms that calculate
6395 various string metrics in Common Lisp:
6396
6397 @itemize
6398 @item Damerau-Levenshtein distance
6399 @item Hamming distance
6400 @item Jaccard similarity coefficient
6401 @item Jaro distance
6402 @item Jaro-Winkler distance
6403 @item Levenshtein distance
6404 @item Normalized Damerau-Levenshtein distance
6405 @item Normalized Levenshtein distance
6406 @item Overlap coefficient
6407 @end itemize\n")
6408     (license license:x11)))
6409
6410 (define-public cl-mk-string-metrics
6411   (sbcl-package->cl-source-package sbcl-mk-string-metrics))
6412
6413 (define-public sbcl-cl-str
6414   (let ((commit "eb480f283e28802d67b35bf916506701152f9a2a"))
6415     (package
6416       (name "sbcl-cl-str")
6417       (version (git-version "0.17" "1" commit))
6418       (home-page "https://github.com/vindarel/cl-str")
6419       (source (origin
6420                 (method git-fetch)
6421                 (uri (git-reference
6422                       (url home-page)
6423                       (commit commit)))
6424                 (sha256
6425                  (base32 "1hpq5m8zjjnzns370zy27z2vcm1p8n2ka5ij2x67gyc9amz9vla0"))
6426                 (file-name (git-file-name name version))))
6427       (build-system asdf-build-system/sbcl)
6428       (inputs
6429        `(("cl-ppcre" ,sbcl-cl-ppcre)
6430          ("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)
6431          ("cl-change-case" ,sbcl-cl-change-case)))
6432       (native-inputs
6433        `(("prove" ,sbcl-prove)
6434          ("prove-asdf" ,sbcl-prove-asdf)))
6435       (arguments
6436        `(#:asd-file "str.asd"
6437          #:asd-system-name "str"
6438          #:test-asd-file "str.test.asd"))
6439       (synopsis "Modern, consistent and terse Common Lisp string manipulation library")
6440       (description "A modern and consistent Common Lisp string manipulation
6441 library that focuses on modernity, simplicity and discoverability:
6442 @code{(str:trim s)} instead of @code{(string-trim '(#\\Space ...) s)}), or
6443 @code{str:concat strings} instead of an unusual format construct; one
6444 discoverable library instead of many; consistency and composability, where
6445 @code{s} is always the last argument, which makes it easier to feed pipes and
6446 arrows.")
6447       (license license:expat))))
6448
6449 (define-public cl-str
6450   (sbcl-package->cl-source-package sbcl-cl-str))
6451
6452 (define-public sbcl-cl-xmlspam
6453   (let ((commit "ea06abcca2a73a9779bcfb09081e56665f94e22a"))
6454     (package
6455       (name "sbcl-cl-xmlspam")
6456       (build-system asdf-build-system/sbcl)
6457       (version (git-version "0.0.0" "1" commit))
6458       (home-page "https://github.com/rogpeppe/cl-xmlspam")
6459       (source
6460        (origin
6461          (method git-fetch)
6462          (uri (git-reference
6463                (url home-page)
6464                (commit commit)))
6465          (file-name (string-append name "-" version))
6466          (sha256
6467           (base32
6468            "0w4rqvrgdgk3fwfq3kx4r7wwdr2bv3b6n3bdqwsiriw9psqzpz2s"))))
6469       (inputs
6470        `(("cxml" ,sbcl-cxml)
6471          ("cl-ppcre" ,sbcl-cl-ppcre)))
6472       (synopsis "Concise, regexp-like pattern matching on streaming XML for Common Lisp")
6473       (description "CXML does an excellent job at parsing XML elements, but what
6474 do you do when you have a XML file that's larger than you want to fit in
6475 memory, and you want to extract some information from it?  Writing code to deal
6476 with SAX events, or even using Klacks, quickly becomes tedious.
6477 @code{cl-xmlspam} (for XML Stream PAttern Matcher) is designed to make it easy
6478 to write code that mirrors the structure of the XML that it's parsing.  It
6479 also makes it easy to shift paradigms when necessary - the usual Lisp control
6480 constructs can be used interchangeably with pattern matching, and the full
6481 power of CXML is available when necessary.")
6482       (license license:bsd-3))))
6483
6484 ;; TODO: dbus uses ASDF's package-inferred-system which is not supported by
6485 ;; asdf-build-system/sbcl as of 2019-08-02.  We should fix
6486 ;; asdf-build-system/sbcl.
6487 (define-public cl-dbus
6488   (let ((commit "24b452df3a45ca5dc95015500f34baad175c981a")
6489         (revision "1"))
6490     (package
6491       (name "cl-dbus")
6492       (build-system asdf-build-system/source)
6493       (version (git-version "20190408" revision commit))
6494       (home-page "https://github.com/death/dbus")
6495       (source
6496        (origin
6497          (method git-fetch)
6498          (uri (git-reference
6499                (url home-page)
6500                (commit commit)))
6501          (file-name (git-file-name name version))
6502          (sha256
6503           (base32
6504            "0fw2q866yddbf23nk9pxphm9gsasx35vjyss82xzvndnjmzlqfl5"))))
6505       ;; Inputs must be propagated or else packages depending on this won't
6506       ;; have the necessary packages.
6507       (propagated-inputs
6508        `(("alexandria" ,sbcl-alexandria)
6509          ("trivial-garbage" ,sbcl-trivial-garbage)
6510          ("babel" ,sbcl-babel)
6511          ("iolib" ,sbcl-iolib)
6512          ("ieee-floats" ,sbcl-ieee-floats)
6513          ("flexi-streams" ,sbcl-flexi-streams)
6514          ("cl-xmlspam" ,sbcl-cl-xmlspam)
6515          ("ironclad" ,sbcl-ironclad)))
6516       (synopsis "D-Bus client library for Common Lisp")
6517       (description "This is a Common Lisp library that publishes D-Bus
6518 objects as well as send and notify other objects connected to a bus.")
6519       (license license:bsd-2))))
6520
6521 (define-public sbcl-cl-hooks
6522   (let ((commit "5b638083f3b4f1221a52631d9c8a0a265565cac7")
6523         (revision "1"))
6524     (package
6525       (name "sbcl-cl-hooks")
6526       (build-system asdf-build-system/sbcl)
6527       (version (git-version "0.2.1" revision commit))
6528       (home-page "https://github.com/scymtym/architecture.hooks")
6529       (source
6530        (origin
6531          (method git-fetch)
6532          (uri (git-reference
6533                (url home-page)
6534                (commit commit)))
6535          (file-name (git-file-name name version))
6536          (sha256
6537           (base32
6538            "0bg3l0a28lw5gqqjp6p6b5nhwqk46sgkb7184w5qbfngw1hk8x9y"))))
6539       (inputs
6540        `(("alexandria" ,sbcl-alexandria)
6541          ("let-plus" ,sbcl-let-plus)
6542          ("trivial-garbage" ,sbcl-trivial-garbage)
6543          ("closer-mop" ,sbcl-closer-mop)))
6544       (native-inputs
6545        `(("fiveam" ,sbcl-fiveam)))
6546       (synopsis "Hooks extension point mechanism (as in Emacs) for Common Lisp")
6547       (description "A hook, in the present context, is a certain kind of
6548 extension point in a program that allows interleaving the execution of
6549 arbitrary code with the execution of a the program without introducing any
6550 coupling between the two.  Hooks are used extensively in the extensible editor
6551 Emacs.
6552
6553 In the Common LISP Object System (CLOS), a similar kind of extensibility is
6554 possible using the flexible multi-method dispatch mechanism.  It may even seem
6555 that the concept of hooks does not provide any benefits over the possibilities
6556 of CLOS.  However, there are some differences:
6557
6558 @itemize
6559
6560 @item There can be only one method for each combination of specializers and
6561 qualifiers.  As a result this kind of extension point cannot be used by
6562 multiple extensions independently.
6563 @item Removing code previously attached via a @code{:before}, @code{:after} or
6564 @code{:around} method can be cumbersome.
6565 @item There could be other or even multiple extension points besides @code{:before}
6566 and @code{:after} in a single method.
6567 @item Attaching codes to individual objects using eql specializers can be
6568 cumbersome.
6569 @item Introspection of code attached a particular extension point is
6570 cumbersome since this requires enumerating and inspecting the methods of a
6571 generic function.
6572 @end itemize
6573
6574 This library tries to complement some of these weaknesses of method-based
6575 extension-points via the concept of hooks.")
6576       (license license:llgpl))))
6577
6578 (define-public cl-hooks
6579   (sbcl-package->cl-source-package sbcl-cl-hooks))
6580
6581 (define-public ecl-cl-hooks
6582   (sbcl-package->ecl-package sbcl-cl-hooks))
6583
6584 (define-public sbcl-s-sysdeps
6585   ;; No release since 2013.
6586   (let ((commit "9aa23bbdceb24bcdbe0e7c39fa1901858f823106")
6587         (revision "2"))
6588     (package
6589       (name "sbcl-s-sysdeps")
6590       (build-system asdf-build-system/sbcl)
6591       (version (git-version "1" revision commit))
6592       (home-page "https://github.com/svenvc/s-sysdeps")
6593       (source
6594        (origin
6595          (method git-fetch)
6596          (uri (git-reference
6597                (url home-page)
6598                (commit commit)))
6599          (file-name (git-file-name name version))
6600          (sha256
6601           (base32
6602            "1fh8r7kf8s3hvqdg6b71b8p7w3v2kkga9bw8j3qqdxhzr6anpm0b"))))
6603       (inputs
6604        `(("bordeaux-threads" ,sbcl-bordeaux-threads)
6605          ("usocket" ,sbcl-usocket)
6606          ("usocket-server" ,sbcl-usocket-server)))
6607       (synopsis "Common Lisp abstraction layer over platform dependent functionality")
6608       (description "@code{s-sysdeps} is an abstraction layer over platform
6609 dependent functionality.  This simple package is used as a building block in a
6610 number of other open source projects.
6611
6612 @code{s-sysdeps} abstracts:
6613
6614 @itemize
6615 @item managing processes,
6616 @item implementing a standard TCP/IP server,
6617 @item opening a client TCP/IP socket stream,
6618 @item working with process locks.
6619 @end itemize\n")
6620       (license license:llgpl))))
6621
6622 (define-public cl-s-sysdeps
6623   (sbcl-package->cl-source-package sbcl-s-sysdeps))
6624
6625 (define-public ecl-s-sysdeps
6626   (sbcl-package->ecl-package sbcl-s-sysdeps))
6627
6628 (define-public sbcl-cl-prevalence
6629   (let ((commit "c163c227ed85d430b82cb1e3502f72d4f88e3cfa")
6630         (revision "1"))
6631     (package
6632       (name "sbcl-cl-prevalence")
6633       (build-system asdf-build-system/sbcl)
6634       (version (git-version "5" revision commit))
6635       (home-page "https://github.com/40ants/cl-prevalence")
6636       (source
6637        (origin
6638          (method git-fetch)
6639          (uri (git-reference
6640                (url home-page)
6641                (commit commit)))
6642          (file-name (git-file-name name version))
6643          (sha256
6644           (base32
6645            "1i9zj1q2ahgwch56an21yzbgkynz0kab9fyxkq9mg8p3xrv38jjn"))))
6646       (inputs
6647        `(("s-sysdeps" ,sbcl-s-sysdeps)
6648          ("s-xml" ,sbcl-s-xml)))
6649       (synopsis "Implementation of object prevalence for Common Lisp")
6650       (description "This Common Lisp library implements object prevalence (see
6651 @url{https://en.wikipedia.org/wiki/System_prevalence}).  It allows
6652 for (de)serializing to and from s-exps as well as XML.  Serialization of arbitrary
6653 classes and cyclic data structures are supported.")
6654       (license license:llgpl))))
6655
6656 (define-public cl-prevalence
6657   (sbcl-package->cl-source-package sbcl-cl-prevalence))
6658
6659 (define-public ecl-cl-prevalence
6660   (sbcl-package->ecl-package sbcl-cl-prevalence))
6661
6662 (define-public sbcl-series
6663   (let ((commit "da9061b336119d1e5214aff9117171d494d5a58a")
6664         (revision "1"))
6665     (package
6666       (name "sbcl-series")
6667       (version (git-version "2.2.11" revision commit))
6668       (source
6669        (origin
6670          (method git-fetch)
6671          (uri (git-reference
6672                (url "git://git.code.sf.net/p/series/series")
6673                (commit commit)))
6674          (file-name (git-file-name name version))
6675          (sha256
6676           (base32
6677            "07hk2lhfx42zk018pxqvn4gs77vd4n4g8m4xxbqaxgca76mifwfw"))))
6678       (build-system asdf-build-system/sbcl)
6679       (arguments
6680        ;; Disable the tests, they are apparently buggy and I didn't find
6681        ;; a simple way to make them run and pass.
6682        '(#:tests? #f))
6683       (synopsis "Series data structure for Common Lisp")
6684       (description
6685        "This Common Lisp library provides a series data structure much like
6686 a sequence, with similar kinds of operations.  The difference is that in many
6687 situations, operations on series may be composed functionally and yet execute
6688 iteratively, without the need to construct intermediate series values
6689 explicitly.  In this manner, series provide both the clarity of a functional
6690 programming style and the efficiency of an iterative programming style.")
6691       (home-page "http://series.sourceforge.net/")
6692       (license license:expat))))
6693
6694 (define-public cl-series
6695   (sbcl-package->cl-source-package sbcl-series))
6696
6697 (define-public ecl-series
6698   (sbcl-package->ecl-package sbcl-series))
6699
6700 (define-public sbcl-periods
6701   (let ((commit "983d4a57325db3c8def942f163133cec5391ec28")
6702         (revision "1"))
6703     (package
6704       (name "sbcl-periods")
6705       (version (git-version "0.0.2" revision commit))
6706       (source
6707        (origin
6708          (method git-fetch)
6709          (uri (git-reference
6710                (url "https://github.com/jwiegley/periods.git")
6711                (commit commit)))
6712          (file-name (git-file-name name version))
6713          (sha256
6714           (base32
6715            "0z30jr3lxz3cmi019fsl4lgcgwf0yqpn95v9zkkkwgymdrkd4lga"))))
6716       (build-system asdf-build-system/sbcl)
6717       (inputs
6718        `(("local-time" ,sbcl-local-time)))
6719       (synopsis "Common Lisp library for manipulating date/time objects")
6720       (description
6721        "Periods is a Common Lisp library providing a set of utilities for
6722 manipulating times, distances between times, and both contiguous and
6723 discontiguous ranges of time.")
6724       (home-page "https://github.com/jwiegley/periods")
6725       (license license:bsd-3))))
6726
6727 (define-public cl-periods
6728   (sbcl-package->cl-source-package sbcl-periods))
6729
6730 (define-public ecl-periods
6731   (sbcl-package->ecl-package sbcl-periods))
6732
6733 (define-public sbcl-periods-series
6734   (package
6735     (inherit sbcl-periods)
6736     (name "sbcl-periods-series")
6737     (inputs
6738      `(("periods" ,sbcl-periods)
6739        ("series" ,sbcl-series)))
6740     (arguments
6741      '(#:asd-file "periods-series.asd"
6742        #:asd-system-name "periods-series"))
6743     (description
6744      "Periods-series is an extension of the periods Common Lisp library
6745 providing functions compatible with the series Common Lisp library.")))
6746
6747 (define-public cl-periods-series
6748   (sbcl-package->cl-source-package sbcl-periods-series))
6749
6750 (define-public ecl-periods-series
6751   (sbcl-package->ecl-package sbcl-periods-series))
6752
6753 (define-public sbcl-metatilities-base
6754   (let ((commit "6eaa9e3ff0939a93a92109dd0fcd218de85417d5")
6755         (revision "1"))
6756     (package
6757       (name "sbcl-metatilities-base")
6758       (version (git-version "0.6.6" revision commit))
6759       (source
6760        (origin
6761          (method git-fetch)
6762          (uri (git-reference
6763                (url "https://github.com/gwkkwg/metatilities-base.git")
6764                (commit commit)))
6765          (file-name (git-file-name name version))
6766          (sha256
6767           (base32
6768            "0xpa86pdzlnf4v5g64j3ifaplx71sx2ha8b7vvakswi652679ma0"))))
6769       (build-system asdf-build-system/sbcl)
6770       (native-inputs
6771        `(("lift" ,sbcl-lift)))
6772       (synopsis "Core of the metatilities Common Lisp library")
6773       (description
6774        "Metatilities-base is the core of the metatilities Common Lisp library
6775 which implements a set of utilities.")
6776       (home-page "https://common-lisp.net/project/metatilities-base/")
6777       (license license:expat))))
6778
6779 (define-public cl-metatilities-base
6780   (sbcl-package->cl-source-package sbcl-metatilities-base))
6781
6782 (define-public ecl-metatilities-base
6783   (sbcl-package->ecl-package sbcl-metatilities-base))
6784
6785 (define-public sbcl-cl-containers
6786   (let ((commit "3d1df53c22403121bffb5d553cf7acb1503850e7")
6787         (revision "3"))
6788     (package
6789       (name "sbcl-cl-containers")
6790       (version (git-version "0.12.1" revision commit))
6791       (source
6792        (origin
6793          (method git-fetch)
6794          (uri (git-reference
6795                (url "https://github.com/gwkkwg/cl-containers.git")
6796                (commit commit)))
6797          (file-name (git-file-name name version))
6798          (sha256
6799           (base32
6800            "18s6jfq11n8nv9k4biz32pm1s7y9zl054ry1gmdbcf39nisy377y"))))
6801       (build-system asdf-build-system/sbcl)
6802       (native-inputs
6803        `(("lift" ,sbcl-lift)))
6804       (inputs
6805        `(("metatilities-base" ,sbcl-metatilities-base)))
6806       (arguments
6807        '(#:phases
6808          (modify-phases %standard-phases
6809            (add-after 'unpack 'relax-version-checks
6810              (lambda _
6811                (substitute* "cl-containers.asd"
6812                  (("\\(:version \"metatilities-base\" \"0\\.6\\.6\"\\)")
6813                   "\"metatilities-base\""))
6814                (substitute* "cl-containers-test.asd"
6815                  (("\\(:version \"lift\" \"1\\.7\\.0\"\\)")
6816                   "\"lift\""))
6817                #t)))))
6818       (synopsis "Container library for Common Lisp")
6819       (description
6820        "Common Lisp ships with a set of powerful built in data structures
6821 including the venerable list, full featured arrays, and hash-tables.
6822 CL-containers enhances and builds on these structures by adding containers
6823 that are not available in native Lisp (for example: binary search trees,
6824 red-black trees, sparse arrays and so on), and by providing a standard
6825 interface so that they are simpler to use and so that changing design
6826 decisions becomes significantly easier.")
6827       (home-page "https://common-lisp.net/project/cl-containers/")
6828       (license license:expat))))
6829
6830 (define-public cl-containers
6831   (sbcl-package->cl-source-package sbcl-cl-containers))
6832
6833 (define-public ecl-cl-containers
6834   (sbcl-package->ecl-package sbcl-cl-containers))
6835
6836 (define-public sbcl-xlunit
6837   (let ((commit "3805d34b1d8dc77f7e0ee527a2490194292dd0fc")
6838         (revision "1"))
6839     (package
6840       (name "sbcl-xlunit")
6841       (version (git-version "0.6.3" revision commit))
6842       (source
6843        (origin
6844          (method git-fetch)
6845          (uri (git-reference
6846                (url "http://git.kpe.io/xlunit.git")
6847                (commit commit)))
6848          (file-name (git-file-name name version))
6849          (sha256
6850           (base32
6851            "0argfmp9nghs4sihyj3f8ch9qfib2b7ll07v5m9ziajgzsfl5xw3"))))
6852       (build-system asdf-build-system/sbcl)
6853       (arguments
6854        '(#:phases
6855          (modify-phases %standard-phases
6856            (add-after 'unpack 'fix-tests
6857              (lambda _
6858                (substitute* "xlunit.asd"
6859                  ((" :force t") ""))
6860                #t)))))
6861       (synopsis "Unit testing package for Common Lisp")
6862       (description
6863        "The XLUnit package is a toolkit for building test suites.  It is based
6864 on the XPTest package by Craig Brozensky and the JUnit package by Kent Beck.")
6865       (home-page "http://quickdocs.org/xlunit/")
6866       (license license:bsd-3))))
6867
6868 (define-public cl-xlunit
6869   (sbcl-package->cl-source-package sbcl-xlunit))
6870
6871 (define-public ecl-xlunit
6872   (sbcl-package->ecl-package sbcl-xlunit))
6873
6874 (define-public sbcl-fprog
6875   (let ((commit "7016d1a98215f82605d1c158e7a16504ca1f4636")
6876         (revision "1"))
6877     (package
6878       (name "sbcl-fprog")
6879       (version (git-version "1.0.0" revision commit))
6880       (source
6881        (origin
6882          (method git-fetch)
6883          (uri (git-reference
6884                (url "https://github.com/jwiegley/cambl.git")
6885                (commit commit)))
6886          (file-name (git-file-name name version))
6887          (sha256
6888           (base32
6889            "103mry04j2k9vznsxm7wcvccgxkil92cdrv52miwcmxl8daa4jiz"))))
6890       (build-system asdf-build-system/sbcl)
6891       (synopsis "Functional programming utilities for Common Lisp")
6892       (description
6893        "@code{fprog} is a Common Lisp library allowing iteration over
6894 immutable lists sharing identical sublists.")
6895       (home-page "https://github.com/jwiegley/cambl")
6896       (license license:bsd-3))))
6897
6898 (define-public cl-fprog
6899   (sbcl-package->cl-source-package sbcl-fprog))
6900
6901 (define-public ecl-fprog
6902   (sbcl-package->ecl-package sbcl-fprog))
6903
6904 (define-public sbcl-cambl
6905   (let ((commit "7016d1a98215f82605d1c158e7a16504ca1f4636")
6906         (revision "1"))
6907     (package
6908       (inherit sbcl-fprog)
6909       (name "sbcl-cambl")
6910       (version (git-version "4.0.0" revision commit))
6911       (native-inputs
6912        `(("xlunit" ,sbcl-xlunit)))
6913       (inputs
6914        `(("alexandria" ,sbcl-alexandria)
6915          ("cl-containers" ,sbcl-cl-containers)
6916          ("local-time" ,sbcl-local-time)
6917          ("periods" ,sbcl-periods)
6918          ("fprog" ,sbcl-fprog)))
6919       (synopsis "Commoditized amounts and balances for Common Lisp")
6920       (description
6921        "CAMBL is a Common Lisp library providing a convenient facility for
6922 working with commoditized values.  It does not allow compound units (and so is
6923 not suited for scientific operations) but does work rather nicely for the
6924 purpose of financial calculations."))))
6925
6926 (define-public cl-cambl
6927   (sbcl-package->cl-source-package sbcl-cambl))
6928
6929 (define-public ecl-cambl
6930   (sbcl-package->ecl-package sbcl-cambl))
6931
6932 (define-public sbcl-cl-ledger
6933   (let ((commit "08e0be41795e804cd36142e51756ad0b1caa377b")
6934         (revision "1"))
6935     (package
6936       (name "sbcl-cl-ledger")
6937       (version (git-version "4.0.0" revision commit))
6938       (source
6939        (origin
6940          (method git-fetch)
6941          (uri (git-reference
6942                (url "https://github.com/ledger/cl-ledger.git")
6943                (commit commit)))
6944          (file-name (git-file-name name version))
6945          (sha256
6946           (base32
6947            "1via0qf6wjcyxnfbmfxjvms0ik9j8rqbifgpmnhrzvkhrq9pv8h1"))))
6948       (build-system asdf-build-system/sbcl)
6949       (inputs
6950        `(("cambl" ,sbcl-cambl)
6951          ("cl-ppcre" ,sbcl-cl-ppcre)
6952          ("local-time" ,sbcl-local-time)
6953          ("periods-series" ,sbcl-periods-series)))
6954       (arguments
6955        '(#:phases
6956          (modify-phases %standard-phases
6957            (add-after 'unpack 'fix-system-definition
6958              (lambda _
6959                (substitute* "cl-ledger.asd"
6960                  (("  :build-operation program-op") "")
6961                  (("  :build-pathname \"cl-ledger\"") "")
6962                  (("  :entry-point \"ledger::main\"") ""))
6963                #t)))))
6964       (synopsis "Common Lisp port of the Ledger accounting system")
6965       (description
6966        "CL-Ledger is a Common Lisp port of the Ledger double-entry accounting
6967 system.")
6968       (home-page "https://github.com/ledger/cl-ledger")
6969       (license license:bsd-3))))
6970
6971 (define-public cl-ledger
6972   (sbcl-package->cl-source-package sbcl-cl-ledger))
6973
6974 (define-public ecl-cl-ledger
6975   (sbcl-package->ecl-package sbcl-cl-ledger))
6976
6977 (define-public sbcl-bst
6978   (let ((commit "34f9c7e8e0a9f2c952fe310ab36cb630d5d9c15a")
6979         (revision "1"))
6980     (package
6981       (name "sbcl-bst")
6982       (version (git-version "1.1" revision commit))
6983       (source
6984        (origin
6985          (method git-fetch)
6986          (uri (git-reference
6987                (url "https://github.com/glv2/bst.git")
6988                (commit commit)))
6989          (file-name (git-file-name name version))
6990          (sha256
6991           (base32
6992            "1amxns7hvvh4arwbh8ciwfzplg127vh37dnbamv1m1kmmnmihfc8"))))
6993       (build-system asdf-build-system/sbcl)
6994       (native-inputs
6995        `(("alexandria" ,sbcl-alexandria)
6996          ("fiveam" ,sbcl-fiveam)))
6997       (synopsis "Binary search tree for Common Lisp")
6998       (description
6999        "BST is a Common Lisp library for working with binary search trees that
7000 can contain any kind of values.")
7001       (home-page "https://github.com/glv2/bst")
7002       (license license:gpl3))))
7003
7004 (define-public cl-bst
7005   (sbcl-package->cl-source-package sbcl-bst))
7006
7007 (define-public ecl-bst
7008   (sbcl-package->ecl-package sbcl-bst))
7009
7010 (define-public sbcl-cl-octet-streams
7011   (package
7012     (name "sbcl-cl-octet-streams")
7013     (version "1.0")
7014     (source
7015      (origin
7016        (method git-fetch)
7017        (uri (git-reference
7018              (url "https://github.com/glv2/cl-octet-streams.git")
7019              (commit (string-append "v" version))))
7020        (file-name (git-file-name name version))
7021        (sha256
7022         (base32
7023          "1d7mn6ydv0j2x4r7clpc9ijjwrnfpxmvhifv8n5j7jh7s744sf8d"))))
7024     (build-system asdf-build-system/sbcl)
7025     (native-inputs
7026      `(("fiveam" ,sbcl-fiveam)))
7027     (inputs
7028      `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
7029     (synopsis "In-memory octet streams for Common Lisp")
7030     (description
7031      "CL-octet-streams is a library implementing in-memory octet
7032 streams for Common Lisp.  It was inspired by the trivial-octet-streams and
7033 cl-plumbing libraries.")
7034     (home-page "https://github.com/glv2/cl-octet-streams")
7035     (license license:gpl3+)))
7036
7037 (define-public cl-octet-streams
7038   (sbcl-package->cl-source-package sbcl-cl-octet-streams))
7039
7040 (define-public ecl-cl-octet-streams
7041   (sbcl-package->ecl-package sbcl-cl-octet-streams))
7042
7043 (define-public sbcl-lzlib
7044   (let ((commit "0de1db7129fef9a58a059d35a2fa2ecfc5b47b47")
7045         (revision "1"))
7046     (package
7047       (name "sbcl-lzlib")
7048       (version (git-version "1.0" revision commit))
7049       (source
7050        (origin
7051          (method git-fetch)
7052          (uri (git-reference
7053                (url "https://github.com/glv2/cl-lzlib.git")
7054                (commit commit)))
7055          (file-name (git-file-name name version))
7056          (sha256
7057           (base32
7058            "12ny7vj52fgnd8hb8fc8mry92vq4c1x72x2350191m4476j95clz"))))
7059       (build-system asdf-build-system/sbcl)
7060       (native-inputs
7061        `(("fiveam" ,sbcl-fiveam)))
7062       (inputs
7063        `(("cffi" ,sbcl-cffi)
7064          ("cl-octet-streams" ,sbcl-cl-octet-streams)
7065          ("lzlib" ,lzlib)))
7066       (arguments
7067        '(#:phases
7068          (modify-phases %standard-phases
7069            (add-after 'unpack 'fix-paths
7070              (lambda* (#:key inputs #:allow-other-keys)
7071                (substitute* "src/lzlib.lisp"
7072                  (("liblz\\.so")
7073                   (string-append (assoc-ref inputs "lzlib") "/lib/liblz.so")))
7074                #t)))))
7075       (synopsis "Common Lisp library for lzip (de)compression")
7076       (description
7077        "This Common Lisp library provides functions for lzip (LZMA)
7078 compression/decompression using bindings to the lzlib C library.")
7079       (home-page "https://github.com/glv2/cl-lzlib")
7080       (license license:gpl3+))))
7081
7082 (define-public cl-lzlib
7083   (sbcl-package->cl-source-package sbcl-lzlib))
7084
7085 (define-public ecl-lzlib
7086   (sbcl-package->ecl-package sbcl-lzlib))
7087
7088 (define-public sbcl-chanl
7089   (let ((commit "56e90a126c78b39bb621a01585e8d3b985238e8c")
7090         (revision "1"))
7091     (package
7092       (name "sbcl-chanl")
7093       (version (git-version "0.4.1" revision commit))
7094       (source
7095        (origin
7096          (method git-fetch)
7097          (uri (git-reference
7098                (url "https://github.com/zkat/chanl.git")
7099                (commit commit)))
7100          (file-name (git-file-name name version))
7101          (sha256
7102           (base32
7103            "0b1cf6c12qx5cy1fw2z42jgh566rp3l8nv5qf0qqc569s7bgmrh4"))))
7104       (build-system asdf-build-system/sbcl)
7105       (native-inputs
7106        `(("fiveam" ,sbcl-fiveam)))
7107       (inputs
7108        `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
7109       (synopsis "Portable channel-based concurrency for Common Lisp")
7110       (description "Common Lisp library for channel-based concurrency.  In
7111 a nutshell, you create various threads sequentially executing tasks you need
7112 done, and use channel objects to communicate and synchronize the state of these
7113 threads.")
7114       (home-page "https://github.com/zkat/chanl")
7115       (license (list license:expat license:bsd-3)))))
7116
7117 (define-public cl-chanl
7118   (sbcl-package->cl-source-package sbcl-chanl))
7119
7120 (define-public ecl-chanl
7121   (sbcl-package->ecl-package sbcl-chanl))
7122
7123 (define-public sbcl-cl-store
7124   (let ((commit "c787337a16ea8cf8a06227f35933a4ec774746b3")
7125         (revision "1"))
7126     (package
7127       (name "sbcl-cl-store")
7128       (version (git-version "0.8.11" revision commit))
7129       (source
7130        (origin
7131          (method git-fetch)
7132          (uri (git-reference
7133                (url "https://github.com/skypher/cl-store.git")
7134                (commit commit)))
7135          (file-name (git-file-name name version))
7136          (sha256
7137           (base32
7138            "194srkg8nrym19c6i7zbnkzshc1qhqa82m53qnkirz9fw928bqxr"))))
7139       (build-system asdf-build-system/sbcl)
7140       (native-inputs
7141        `(("rt" ,sbcl-rt)))
7142       (synopsis "Common Lisp library to serialize data")
7143       (description
7144        "CL-STORE is a portable serialization package which should give you the
7145 ability to store all Common Lisp data types into streams.")
7146       (home-page "https://www.common-lisp.net/project/cl-store/")
7147       (license license:expat))))
7148
7149 (define-public cl-store
7150   (sbcl-package->cl-source-package sbcl-cl-store))
7151
7152 (define-public ecl-cl-store
7153   (sbcl-package->ecl-package sbcl-cl-store))
7154
7155 (define-public sbcl-cl-gobject-introspection
7156   (let ((commit "7b703e2384945ea0ac39d9b766de434a08d81560")
7157         (revision "0"))
7158     (package
7159       (name "sbcl-cl-gobject-introspection")
7160       (version (git-version "0.3" revision commit))
7161       (home-page "https://github.com/andy128k/cl-gobject-introspection")
7162       (source
7163        (origin
7164          (method git-fetch)
7165          (uri (git-reference
7166                (url home-page)
7167                (commit commit)))
7168          (file-name (git-file-name name version))
7169          (sha256
7170           (base32
7171            "1zcqd2qj14f6b38vys8gr89s6cijsp9r8j43xa8lynilwva7bwyh"))))
7172       (build-system asdf-build-system/sbcl)
7173       (inputs
7174        `(("alexandria" ,sbcl-alexandria)
7175          ("cffi" ,sbcl-cffi)
7176          ("iterate" ,sbcl-iterate)
7177          ("trivial-garbage" ,sbcl-trivial-garbage)
7178          ("glib" ,glib)
7179          ("gobject-introspection" ,gobject-introspection)))
7180       (native-inputs
7181        `(("fiveam" ,sbcl-fiveam)))
7182       (arguments
7183        ;; TODO: Tests fail, see
7184        ;; https://github.com/andy128k/cl-gobject-introspection/issues/70.
7185        '(#:tests? #f
7186          #:phases
7187          (modify-phases %standard-phases
7188            (add-after (quote unpack) (quote fix-paths)
7189              (lambda* (#:key inputs #:allow-other-keys)
7190                (substitute* "src/init.lisp"
7191                  (("libgobject-2\\.0\\.so")
7192                   (string-append (assoc-ref inputs "glib") "/lib/libgobject-2.0.so"))
7193                  (("libgirepository-1\\.0\\.so")
7194                   (string-append (assoc-ref inputs "gobject-introspection")
7195                                  "/lib/libgirepository-1.0.so")))
7196                #t)))))
7197       (synopsis "Common Lisp bindings to GObject Introspection")
7198       (description
7199        "This library is a bridge between Common Lisp and GObject
7200 Introspection, which enables Common Lisp programs to access the full interface
7201 of C+GObject libraries without the need of writing dedicated bindings.")
7202       (license (list license:bsd-3
7203                      ;; Tests are under a different license.
7204                      license:llgpl)))))
7205
7206 (define-public cl-gobject-introspection
7207   (sbcl-package->cl-source-package sbcl-cl-gobject-introspection))
7208
7209 (define-public sbcl-string-case
7210   (let ((commit "718c761e33749e297cd2809c7ba3ade1985c49f7")
7211         (revision "0"))
7212     (package
7213       (name "sbcl-string-case")
7214       (version (git-version "0.0.2" revision commit))
7215       (home-page "https://github.com/pkhuong/string-case")
7216       (source
7217        (origin
7218          (method git-fetch)
7219          (uri (git-reference
7220                (url home-page)
7221                (commit commit)))
7222          (file-name (git-file-name name version))
7223          (sha256
7224           (base32
7225            "1n5i3yh0h5s636rcnwn7jwqy3rjflikra04lymimhpcshhjsk0md"))))
7226       (build-system asdf-build-system/sbcl)
7227       (synopsis "Efficient string= case in Common Lisp")
7228       (description
7229        "@code{string-case} is a Common Lisp macro that generates specialised decision
7230 trees to dispatch on string equality.")
7231       (license license:bsd-3))))
7232
7233 (define-public cl-string-case
7234   (sbcl-package->cl-source-package sbcl-string-case))
7235
7236 (define-public ecl-string-case
7237   (sbcl-package->ecl-package sbcl-string-case))
7238
7239 (define-public sbcl-global-vars
7240   (let ((commit "c749f32c9b606a1457daa47d59630708ac0c266e")
7241         (revision "0"))
7242     (package
7243       (name "sbcl-global-vars")
7244       (version (git-version "1.0.0" revision commit))
7245       (home-page "https://github.com/lmj/global-vars")
7246       (source
7247        (origin
7248          (method git-fetch)
7249          (uri (git-reference
7250                (url home-page)
7251                (commit commit)))
7252          (file-name (git-file-name name version))
7253          (sha256
7254           (base32
7255            "06m3xc8l3pgsapl8fvsi9wf6y46zs75cp9zn7zh6dc65v4s5wz3d"))))
7256       (build-system asdf-build-system/sbcl)
7257       (synopsis "Efficient global variables in Common Lisp")
7258       (description
7259        "In Common Lisp, a special variable that is never dynamically bound
7260 typically serves as a stand-in for a global variable.  The @code{global-vars}
7261 library provides true global variables that are implemented by some compilers.
7262 An attempt to rebind a global variable properly results in a compiler error.
7263 That is, a global variable cannot be dynamically bound.
7264
7265 Global variables therefore allow us to communicate an intended usage that
7266 differs from special variables.  Global variables are also more efficient than
7267 special variables, especially in the presence of threads.")
7268       (license license:expat))))
7269
7270 (define-public cl-global-vars
7271   (sbcl-package->cl-source-package sbcl-global-vars))
7272
7273 (define-public ecl-global-vars
7274   (sbcl-package->ecl-package sbcl-global-vars))
7275
7276 (define-public sbcl-trivial-file-size
7277   (let ((commit "1c1d672a01a446ba0391dbb4ffc40be3b0476f23")
7278         (revision "0"))
7279     (package
7280       (name "sbcl-trivial-file-size")
7281       (version (git-version "0.0.0" revision commit))
7282       (home-page "https://github.com/ruricolist/trivial-file-size")
7283       (source
7284        (origin
7285          (method git-fetch)
7286          (uri (git-reference
7287                (url home-page)
7288                (commit commit)))
7289          (file-name (git-file-name name version))
7290          (sha256
7291           (base32
7292            "17pp86c9zs4y7i1sh7q9gbfw9iqv6655k7fz8qbj9ly1ypgxp4qs"))))
7293       (build-system asdf-build-system/sbcl)
7294       (native-inputs
7295        `(("fiveam" ,sbcl-fiveam)))
7296       (synopsis "Size of a file in bytes in Common Lisp")
7297       (description
7298        "The canonical way to determine the size of a file in bytes, using Common Lisp,
7299 is to open the file with an element type of (unsigned-byte 8) and then
7300 calculate the length of the stream.  This is less than ideal.  In most cases
7301 it is better to get the size of the file from its metadata, using a system
7302 call.
7303
7304 This library exports a single function, file-size-in-octets.  It returns the
7305 size of a file in bytes, using system calls when possible.")
7306       (license license:expat))))
7307
7308 (define-public cl-trivial-file-size
7309   (sbcl-package->cl-source-package sbcl-trivial-file-size))
7310
7311 (define-public ecl-trivial-file-size
7312   (sbcl-package->ecl-package sbcl-trivial-file-size))
7313
7314 (define-public sbcl-trivial-macroexpand-all
7315   (let ((commit "933270ac7107477de1bc92c1fd641fe646a7a8a9")
7316         (revision "0"))
7317     (package
7318       (name "sbcl-trivial-macroexpand-all")
7319       (version (git-version "0.0.0" revision commit))
7320       (home-page "https://github.com/cbaggers/trivial-macroexpand-all")
7321       (source
7322        (origin
7323          (method git-fetch)
7324          (uri (git-reference
7325                (url home-page)
7326                (commit commit)))
7327          (file-name (git-file-name name version))
7328          (sha256
7329           (base32
7330            "191hnn4b5j4i3crydmlzbm231kj0h7l8zj6mzj69r1npbzkas4bd"))))
7331       (build-system asdf-build-system/sbcl)
7332       (native-inputs
7333        `(("fiveam" ,sbcl-fiveam)))
7334       (synopsis "Portable macroexpand-all for Common Lisp")
7335       (description
7336        "This library provides a macroexpand-all function that calls the
7337 implementation specific equivalent.")
7338       (license license:unlicense))))
7339
7340 (define-public cl-trivial-macroexpand-all
7341   (sbcl-package->cl-source-package sbcl-trivial-macroexpand-all))
7342
7343 (define-public ecl-trivial-macroexpand-all
7344   (sbcl-package->ecl-package sbcl-trivial-macroexpand-all))
7345
7346 (define-public sbcl-serapeum
7347   (let ((commit "64f0c4a161bbbda7c275012ca1415b4293b9e169")
7348         (revision "1"))
7349     (package
7350       (name "sbcl-serapeum")
7351       (version (git-version "0.0.0" revision commit))
7352       (home-page "https://github.com/ruricolist/serapeum")
7353       (source
7354        (origin
7355          (method git-fetch)
7356          (uri (git-reference
7357                (url home-page)
7358                (commit commit)))
7359          (file-name (git-file-name name version))
7360          (sha256
7361           (base32
7362            "0djnj0py8hdjnk5j6shjq2kbmyxqd5sw79cilcfmpfz4dzjdgkx9"))))
7363       (build-system asdf-build-system/sbcl)
7364       (inputs
7365        `(("alexandria" ,sbcl-alexandria)
7366          ("trivia" ,sbcl-trivia)
7367          ("trivia.quasiquote" ,sbcl-trivia.quasiquote)
7368          ("split-sequence" ,sbcl-split-sequence)
7369          ("string-case" ,sbcl-string-case)
7370          ("parse-number" ,sbcl-parse-number)
7371          ("trivial-garbage" ,sbcl-trivial-garbage)
7372          ("bordeaux-threads" ,sbcl-bordeaux-threads)
7373          ("named-readtables" ,sbcl-named-readtables)
7374          ("fare-quasiquote-extras" ,sbcl-fare-quasiquote-extras)
7375          ("parse-declarations-1.0" ,sbcl-parse-declarations)
7376          ("global-vars" ,sbcl-global-vars)
7377          ("trivial-file-size" ,sbcl-trivial-file-size)
7378          ("trivial-macroexpand-all" ,sbcl-trivial-macroexpand-all)))
7379       (native-inputs
7380        `(("fiveam" ,sbcl-fiveam)
7381          ("local-time" ,sbcl-local-time)))
7382       (arguments
7383        '(#:phases
7384          (modify-phases %standard-phases
7385            (add-after 'unpack 'disable-failing-tests
7386              (lambda* (#:key inputs #:allow-other-keys)
7387                (substitute* "serapeum.asd"
7388                  ;; Guix does not have Quicklisp, and probably never will.
7389                  (("\\(:file \"quicklisp\"\\)") ""))
7390                #t)))))
7391       (synopsis "Common Lisp utility library beyond Alexandria")
7392       (description
7393        "Serapeum is a conservative library of Common Lisp utilities.  It is a
7394 supplement, not a competitor, to Alexandria.")
7395       (license license:expat))))
7396
7397 (define-public cl-serapeum
7398   (sbcl-package->cl-source-package sbcl-serapeum))
7399
7400 (define-public sbcl-arrows
7401   (let ((commit "df7cf0067e0132d9697ac8b1a4f1b9c88d4f5382")
7402         (revision "0"))
7403     (package
7404       (name "sbcl-arrows")
7405       (version (git-version "0.2.0" revision commit))
7406       (source
7407        (origin
7408          (method git-fetch)
7409          (uri (git-reference
7410                (url "https://gitlab.com/Harleqin/arrows.git")
7411                (commit commit)))
7412          (file-name (git-file-name name version))
7413          (sha256
7414           (base32
7415            "042k9vkssrqx9nhp14wdzm942zgdxvp35mba0p2syz98i75im2yy"))))
7416       (build-system asdf-build-system/sbcl)
7417       (native-inputs
7418        `(("hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
7419       (synopsis "Clojure-like arrow macros for Common Lisp")
7420       (description
7421        "This library implements the @code{->} and @code{->>} macros from
7422 Clojure, as well as several expansions on the idea.")
7423       (home-page "https://gitlab.com/Harleqin/arrows")
7424       (license license:public-domain))))
7425
7426 (define-public cl-arrows
7427   (sbcl-package->cl-source-package sbcl-arrows))
7428
7429 (define-public ecl-arrows
7430   (sbcl-package->ecl-package sbcl-arrows))
7431
7432 (define-public sbcl-simple-parallel-tasks
7433   (let ((commit "db460f7a3f7bbfe2d3a2223ed21e162068d04dda")
7434         (revision "0"))
7435     (package
7436       (name "sbcl-simple-parallel-tasks")
7437       (version (git-version "1.0" revision commit))
7438       (source
7439        (origin
7440          (method git-fetch)
7441          (uri (git-reference
7442                (url "https://github.com/glv2/simple-parallel-tasks.git")
7443                (commit commit)))
7444          (file-name (git-file-name name version))
7445          (sha256
7446           (base32
7447            "0amw3qk23wnlyrsgzszs6rs7y4zvxv8dr03rnqhc60mnm8ds4dd5"))))
7448       (build-system asdf-build-system/sbcl)
7449       (native-inputs
7450        `(("fiveam" ,sbcl-fiveam)))
7451       (inputs
7452        `(("chanl" ,sbcl-chanl)))
7453       (synopsis "Common Lisp library to evaluate some forms in parallel")
7454       (description "This is a simple Common Lisp library to evaluate some
7455 forms in parallel.")
7456       (home-page "https://github.com/glv2/simple-parallel-tasks")
7457       (license license:gpl3))))
7458
7459 (define-public cl-simple-parallel-tasks
7460   (sbcl-package->cl-source-package sbcl-simple-parallel-tasks))
7461
7462 (define-public ecl-simple-parallel-tasks
7463   (sbcl-package->ecl-package sbcl-simple-parallel-tasks))
7464
7465 (define-public sbcl-cl-heap
7466   (package
7467     (name "sbcl-cl-heap")
7468     (version "0.1.6")
7469     (source
7470      (origin
7471        (method url-fetch)
7472        (uri (string-append "https://common-lisp.net/project/cl-heap/releases/"
7473                            "cl-heap_" version ".tar.gz"))
7474        (sha256
7475         (base32
7476          "163hb07p2nxz126rpq3cj5dyala24n0by5i5786n2qcr1w0bak4i"))))
7477     (build-system asdf-build-system/sbcl)
7478     (native-inputs
7479      `(("xlunit" ,sbcl-xlunit)))
7480     (arguments
7481      `(#:test-asd-file "cl-heap-tests.asd"))
7482     (synopsis "Heap and priority queue data structures for Common Lisp")
7483     (description
7484      "CL-HEAP provides various implementations of heap data structures (a
7485 binary heap and a Fibonacci heap) as well as an efficient priority queue.")
7486     (home-page "https://common-lisp.net/project/cl-heap/")
7487     (license license:gpl3+)))
7488
7489 (define-public cl-heap
7490   (sbcl-package->cl-source-package sbcl-cl-heap))
7491
7492 (define-public ecl-cl-heap
7493   (sbcl-package->ecl-package sbcl-cl-heap))
7494
7495 (define-public sbcl-curry-compose-reader-macros
7496   (let ((commit "beaa92dedf392726c042184bfd6149fa8d9e6ac2")
7497         (revision "0"))
7498     (package
7499       (name "sbcl-curry-compose-reader-macros")
7500       (version (git-version "1.0.0" revision commit))
7501       (source
7502        (origin
7503          (method git-fetch)
7504          (uri
7505           (git-reference
7506            (url "https://github.com/eschulte/curry-compose-reader-macros.git")
7507            (commit commit)))
7508          (file-name (git-file-name name version))
7509          (sha256
7510           (base32
7511            "0rv9bl8xrad5wfcg5zs1dazvnpmvqz6297lbn8bywsrcfnlf7h98"))))
7512       (build-system asdf-build-system/sbcl)
7513       (inputs
7514        `(("alexandria" ,sbcl-alexandria)
7515          ("named-readtables" ,sbcl-named-readtables)))
7516       (synopsis "Reader macros for partial application and composition")
7517       (description
7518        "This Common Lisp library provides reader macros for concise expression
7519 of function partial application and composition.")
7520       (home-page "https://eschulte.github.io/curry-compose-reader-macros/")
7521       (license license:public-domain))))
7522
7523 (define-public cl-curry-compose-reader-macros
7524   (sbcl-package->cl-source-package sbcl-curry-compose-reader-macros))
7525
7526 (define-public ecl-curry-compose-reader-macros
7527   (sbcl-package->ecl-package sbcl-curry-compose-reader-macros))
7528
7529 (define-public sbcl-yason
7530   (package
7531     (name "sbcl-yason")
7532     (version "0.7.7")
7533     (source
7534      (origin
7535        (method git-fetch)
7536        (uri (git-reference
7537              (url "https://github.com/phmarek/yason.git")
7538              (commit (string-append "v" version))))
7539        (file-name (git-file-name name version))
7540        (sha256
7541         (base32
7542          "0479rbjgbj80jpk5bby18inlv1kfp771a82rlcq5psrz65qqa9bj"))))
7543     (build-system asdf-build-system/sbcl)
7544     (inputs
7545      `(("alexandria" ,sbcl-alexandria)
7546        ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
7547     (synopsis "Common Lisp JSON parser/encoder")
7548     (description
7549      "YASON is a Common Lisp library for encoding and decoding data in the
7550 JSON interchange format.")
7551     (home-page "https://github.com/phmarek/yason")
7552     (license license:bsd-3)))
7553
7554 (define-public cl-yason
7555   (sbcl-package->cl-source-package sbcl-yason))
7556
7557 (define-public ecl-yason
7558   (sbcl-package->ecl-package sbcl-yason))
7559
7560 (define-public sbcl-stefil
7561   (let ((commit "0398548ec95dceb50fc2c2c03e5fb0ce49b86c7a")
7562         (revision "0"))
7563     (package
7564       (name "sbcl-stefil")
7565       (version (git-version "0.1" revision commit))
7566       (source
7567        (origin
7568          (method git-fetch)
7569          (uri (git-reference
7570                (url "https://gitlab.common-lisp.net/stefil/stefil.git")
7571                (commit commit)))
7572          (file-name (git-file-name name version))
7573          (sha256
7574           (base32
7575            "0bqz64q2szzhf91zyqyssmvrz7da6442rs01808pf3wrdq28bclh"))))
7576       (build-system asdf-build-system/sbcl)
7577       (inputs
7578        `(("alexandria" ,sbcl-alexandria)
7579          ("iterate" ,sbcl-iterate)
7580          ("metabang-bind" ,sbcl-metabang-bind)))
7581       (propagated-inputs
7582        ;; Swank doesn't have a pre-compiled package, therefore we must
7583        ;; propagate its sources.
7584        `(("swank" ,cl-slime-swank)))
7585       (arguments
7586        '(#:phases
7587          (modify-phases %standard-phases
7588            (add-after 'unpack 'drop-unnecessary-dependency
7589              (lambda _
7590                (substitute* "package.lisp"
7591                  ((":stefil-system") ""))
7592                #t)))))
7593       (home-page "https://common-lisp.net/project/stefil/index-old.shtml")
7594       (synopsis "Simple test framework")
7595       (description
7596        "Stefil is a simple test framework for Common Lisp, with a focus on
7597 interactive development.")
7598       (license license:public-domain))))
7599
7600 (define-public cl-stefil
7601   (sbcl-package->cl-source-package sbcl-stefil))
7602
7603 (define-public sbcl-graph
7604   (let ((commit "78bf9ec930d8eae4f0861b5be76765fb1e45e24f")
7605         (revision "0"))
7606     (package
7607       (name "sbcl-graph")
7608       (version (git-version "0.0.0" revision commit))
7609       (source
7610        (origin
7611          (method git-fetch)
7612          (uri
7613           (git-reference
7614            (url "https://github.com/eschulte/graph.git")
7615            (commit commit)))
7616          (file-name (git-file-name name version))
7617          (sha256
7618           (base32
7619            "1qpij4xh8bqwc2myahpilcbh916v7vg0acz2fij14d3y0jm02h0g"))
7620          (patches (search-patches "sbcl-graph-asdf-definitions.patch"))))
7621       (build-system asdf-build-system/sbcl)
7622       (native-inputs
7623        `(("stefil" ,sbcl-stefil)))
7624       (inputs
7625        `(("alexandria" ,sbcl-alexandria)
7626          ("cl-heap" ,sbcl-cl-heap)
7627          ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
7628          ("metabang-bind" ,sbcl-metabang-bind)
7629          ("named-readtables" ,sbcl-named-readtables)))
7630       (arguments
7631        '(#:test-asd-file "graph-test.asd"))
7632       (synopsis "Graph data structure and algorithms for Common Lisp")
7633       (description
7634        "The GRAPH Common Lisp library provides a data structures to represent
7635 graphs, as well as some graph manipulation and analysis algorithms (shortest
7636 path, maximum flow, minimum spanning tree, etc.).")
7637       (home-page "https://eschulte.github.io/graph/")
7638       (license license:gpl3+))))
7639
7640 (define-public cl-graph
7641   (sbcl-package->cl-source-package sbcl-graph))
7642
7643 (define-public sbcl-graph-dot
7644   (package
7645     (inherit sbcl-graph)
7646     (name "sbcl-graph-dot")
7647     (inputs
7648      `(("alexandria" ,sbcl-alexandria)
7649        ("cl-ppcre" ,sbcl-cl-ppcre)
7650        ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
7651        ("graph" ,sbcl-graph)
7652        ("metabang-bind" ,sbcl-metabang-bind)
7653        ("named-readtables" ,sbcl-named-readtables)))
7654     (arguments
7655      (substitute-keyword-arguments (package-arguments sbcl-graph)
7656        ((#:asd-file _ "") "graph-dot.asd")
7657        ((#:asd-system-name _ #f) "graph-dot")))
7658     (synopsis "Serialize graphs to and from DOT format")))
7659
7660 (define-public sbcl-graph-json
7661   (package
7662     (inherit sbcl-graph)
7663     (name "sbcl-graph-json")
7664     (inputs
7665      `(("alexandria" ,sbcl-alexandria)
7666        ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
7667        ("graph" ,sbcl-graph)
7668        ("metabang-bind" ,sbcl-metabang-bind)
7669        ("named-readtables" ,sbcl-named-readtables)
7670        ("yason" ,sbcl-yason)))
7671     (arguments
7672      (substitute-keyword-arguments (package-arguments sbcl-graph)
7673        ((#:asd-file _ "") "graph-json.asd")
7674        ((#:asd-system-name _ #f) "graph-json")))
7675     (synopsis "Serialize graphs to and from JSON format")))
7676
7677 (define-public sbcl-trivial-indent
7678   (let ((commit "2d016941751647c6cc5bd471751c2cf68861c94a")
7679         (revision "0"))
7680     (package
7681       (name "sbcl-trivial-indent")
7682       (version (git-version "1.0.0" revision commit))
7683       (source
7684        (origin
7685          (method git-fetch)
7686          (uri
7687           (git-reference
7688            (url "https://github.com/Shinmera/trivial-indent")
7689            (commit commit)))
7690          (file-name (git-file-name name version))
7691          (sha256
7692           (base32
7693            "1sj90nqz17w4jq0ixz00gb9g5g6d2s7l8r17zdby27gxxh51w266"))))
7694       (build-system asdf-build-system/sbcl)
7695       (synopsis "Simple Common Lisp library to allow indentation hints for SWANK")
7696       (description
7697        "This library allows you to define custom indentation hints for your
7698 macros if the one recognised by SLIME automatically produces unwanted
7699 results.")
7700       (home-page "https://shinmera.github.io/trivial-indent/")
7701       (license license:zlib))))
7702
7703 (define-public cl-trivial-indent
7704   (sbcl-package->cl-source-package sbcl-trivial-indent))
7705
7706 (define-public sbcl-documentation-utils
7707   (let ((commit "98630dd5f7e36ae057fa09da3523f42ccb5d1f55")
7708         (revision "0"))
7709     (package
7710       (name "sbcl-documentation-utils")
7711       (version (git-version "1.2.0" revision commit))
7712       (source
7713        (origin
7714          (method git-fetch)
7715          (uri
7716           (git-reference
7717            (url "https://github.com/Shinmera/documentation-utils.git")
7718            (commit commit)))
7719          (file-name (git-file-name name version))
7720          (sha256
7721           (base32
7722            "098qhkqskmmrh4wix34mawf7p5c87yql28r51r75yjxj577k5idq"))))
7723       (build-system asdf-build-system/sbcl)
7724       (inputs
7725        `(("trivial-indent" ,sbcl-trivial-indent)))
7726       (synopsis "Few simple tools to document Common Lisp libraries")
7727       (description
7728        "This is a small library to help you with managing the Common Lisp
7729 docstrings for your library.")
7730       (home-page "https://shinmera.github.io/documentation-utils/")
7731       (license license:zlib))))
7732
7733 (define-public cl-documentation-utils
7734   (sbcl-package->cl-source-package sbcl-documentation-utils))
7735
7736 (define-public ecl-documentation-utils
7737   (sbcl-package->ecl-package sbcl-documentation-utils))
7738
7739 (define-public sbcl-form-fiddle
7740   (let ((commit "e0c23599dbb8cff3e83e012f3d86d0764188ad18")
7741         (revision "0"))
7742     (package
7743       (name "sbcl-form-fiddle")
7744       (version (git-version "1.1.0" revision commit))
7745       (source
7746        (origin
7747          (method git-fetch)
7748          (uri
7749           (git-reference
7750            (url "https://github.com/Shinmera/form-fiddle")
7751            (commit commit)))
7752          (file-name (git-file-name name version))
7753          (sha256
7754           (base32
7755            "041iznc9mpfyrl0sv5893ys9pbb2pvbn9g3clarqi7gsfj483jln"))))
7756       (build-system asdf-build-system/sbcl)
7757       (inputs
7758        `(("documentation-utils" ,sbcl-documentation-utils)))
7759       (synopsis "Utilities to destructure Common Lisp lambda forms")
7760       (description
7761        "Often times we need to destructure a form definition in a Common Lisp
7762 macro.  This library provides a set of simple utilities to help with that.")
7763       (home-page "https://shinmera.github.io/form-fiddle/")
7764       (license license:zlib))))
7765
7766 (define-public cl-form-fiddle
7767   (sbcl-package->cl-source-package sbcl-form-fiddle))
7768
7769 (define-public sbcl-parachute
7770   (let ((commit "ca04dd8e43010a6dfffa26dbe1d62af86008d666")
7771         (revision "0"))
7772     (package
7773       (name "sbcl-parachute")
7774       (version (git-version "1.1.1" revision commit))
7775       (source
7776        (origin
7777          (method git-fetch)
7778          (uri
7779           (git-reference
7780            (url "https://github.com/Shinmera/parachute")
7781            (commit commit)))
7782          (file-name (git-file-name name version))
7783          (sha256
7784           (base32
7785            "1mvsm3r0r6a2bg75nw0q7n9vlby3ch45qjl7hnb5k1z2n5x5lh60"))))
7786       (build-system asdf-build-system/sbcl)
7787       (inputs
7788        `(("documentation-utils" ,sbcl-documentation-utils)
7789          ("form-fiddle" ,sbcl-form-fiddle)))
7790       (synopsis "Extensible and cross-compatible testing framework for Common Lisp")
7791       (description
7792        "Parachute is a simple-to-use and extensible testing framework.
7793 In Parachute, things are organised as a bunch of named tests within a package.
7794 Each test can contain a bunch of test forms that make up its body.")
7795       (home-page "https://shinmera.github.io/parachute/")
7796       (license license:zlib))))
7797
7798 (define-public cl-parachute
7799   (sbcl-package->cl-source-package sbcl-parachute))
7800
7801 (define-public sbcl-array-utils
7802   (let ((commit "f90eb9070d0b2205af51126a35033574725e5c56")
7803         (revision "0"))
7804     (package
7805       (name "sbcl-array-utils")
7806       (version (git-version "1.1.1" revision commit))
7807       (source
7808        (origin
7809          (method git-fetch)
7810          (uri
7811           (git-reference
7812            (url "https://github.com/Shinmera/array-utils")
7813            (commit commit)))
7814          (file-name (git-file-name name version))
7815          (sha256
7816           (base32
7817            "0zhwfbpr53vs1ii4sx75dz2k9yhh1xpwdqqpg8nmfndxkmhpbi3x"))))
7818       (build-system asdf-build-system/sbcl)
7819       (native-inputs
7820        `(("parachute" ,sbcl-parachute)))
7821       (inputs
7822        `(("documentation-utils" ,sbcl-documentation-utils)))
7823       (synopsis "Tiny collection of array and vector utilities for Common Lisp")
7824       (description
7825        "A miniature toolkit that contains some useful shifting/popping/pushing
7826 functions for arrays and vectors.  Originally from Plump.")
7827       (home-page "https://shinmera.github.io/array-utils/")
7828       (license license:zlib))))
7829
7830 (define-public cl-array-utils
7831   (sbcl-package->cl-source-package sbcl-array-utils))
7832
7833 (define-public sbcl-plump
7834   (let ((commit "16f1231bf706cfbc54d9e55a853ca945e4452a08")
7835         (revision "0"))
7836     (package
7837       (name "sbcl-plump")
7838       (version (git-version "2.0.0" revision commit))
7839       (source
7840        (origin
7841          (method git-fetch)
7842          (uri
7843           (git-reference
7844            (url "https://github.com/Shinmera/plump")
7845            (commit commit)))
7846          (file-name (git-file-name name version))
7847          (sha256
7848           (base32
7849            "0705k8pbip51v74rccgwscwph439f2pma9f915qf1h4bhjx999ip"))))
7850       (build-system asdf-build-system/sbcl)
7851       (inputs
7852        `(("array-utils" ,sbcl-array-utils)
7853          ("documentation-utils" ,sbcl-documentation-utils)))
7854       (synopsis "Lenient XML / XHTML / HTML parser for Common Lisp")
7855       (description
7856        "Plump is a parser for HTML/XML-like documents, focusing on being
7857 lenient towards invalid markup.  It can handle things like invalid attributes,
7858 bad closing tag order, unencoded entities, inexistent tag types, self-closing
7859 tags and so on.  It parses documents to a class representation and offers a
7860 small set of DOM functions to manipulate it.  It can be extended to parse to
7861 your own classes.")
7862       (home-page "https://shinmera.github.io/plump/")
7863       (license license:zlib))))
7864
7865 (define-public cl-plump
7866   (sbcl-package->cl-source-package sbcl-plump))
7867
7868 (define-public sbcl-antik-base
7869   (let ((commit "e4711a69b3d6bf37b5727af05c3cfd03e8428ba3")
7870         (revision "1"))
7871     (package
7872       (name "sbcl-antik-base")
7873       (version (git-version "0.0.0" revision commit))
7874       (source
7875        (origin
7876          (method git-fetch)
7877          (uri (git-reference
7878                (url "https://gitlab.common-lisp.net/antik/antik.git")
7879                (commit commit)))
7880          (file-name (git-file-name name version))
7881          (sha256
7882           (base32
7883            "047ga2c38par2xbgg4qx6hwv06qhf1c1f67as8xvir6s80lip1km"))))
7884       (build-system asdf-build-system/sbcl)
7885       (inputs
7886        `(("alexandria" ,sbcl-alexandria)
7887          ("cl-ppcre" ,sbcl-cl-ppcre)
7888          ("iterate" ,sbcl-iterate)
7889          ("metabang-bind" ,sbcl-metabang-bind)
7890          ("named-readtables" ,sbcl-named-readtables)
7891          ("split-sequence" ,sbcl-split-sequence)))
7892       (native-inputs
7893        `(("lisp-unit" ,sbcl-lisp-unit)))
7894       (synopsis "Scientific and engineering computation in Common Lisp")
7895       (description
7896        "Antik provides a foundation for scientific and engineering
7897 computation in Common Lisp.  It is designed not only to facilitate
7898 numerical computations, but to permit the use of numerical computation
7899 libraries and the interchange of data and procedures, whether
7900 foreign (non-Lisp) or Lisp libraries.  It is named after the
7901 Antikythera mechanism, one of the oldest examples of a scientific
7902 computer known.")
7903       (home-page "https://common-lisp.net/project/antik/")
7904       (license license:gpl3))))
7905
7906 (define-public cl-antik-base
7907   (sbcl-package->cl-source-package sbcl-antik-base))
7908
7909 (define-public ecl-antik-base
7910   (sbcl-package->ecl-package sbcl-antik-base))
7911
7912 (define-public sbcl-foreign-array
7913   (package
7914     (inherit sbcl-antik-base)
7915     (name "sbcl-foreign-array")
7916     (arguments
7917      (substitute-keyword-arguments (package-arguments sbcl-antik-base)
7918        ((#:asd-file _ "") "foreign-array.asd")
7919        ((#:asd-system-name _ #f) "foreign-array")))
7920     (inputs
7921      `(("antik-base" ,sbcl-antik-base)
7922        ("cffi" ,sbcl-cffi)
7923        ("trivial-garbage" ,sbcl-trivial-garbage)
7924        ("static-vectors" ,sbcl-static-vectors)))
7925     (synopsis "Common Lisp library providing access to foreign arrays")))
7926
7927 (define-public cl-foreign-array
7928   (sbcl-package->cl-source-package sbcl-foreign-array))
7929
7930 (define-public ecl-foreign-array
7931   (sbcl-package->ecl-package sbcl-foreign-array))
7932
7933 (define-public sbcl-physical-dimension
7934   (package
7935     (inherit sbcl-antik-base)
7936     (name "sbcl-physical-dimension")
7937     (inputs
7938      `(("fare-utils" ,sbcl-fare-utils)
7939        ("foreign-array" ,sbcl-foreign-array)
7940        ("trivial-utf-8" ,sbcl-trivial-utf-8)))
7941     (arguments
7942      (substitute-keyword-arguments (package-arguments sbcl-antik-base)
7943        ((#:asd-file _ "") "physical-dimension.asd")
7944        ((#:asd-system-name _ #f) "physical-dimension")))
7945     (synopsis
7946      "Common Lisp library providing computations with physical units")))
7947
7948 (define-public cl-physical-dimension
7949   (sbcl-package->cl-source-package sbcl-physical-dimension))
7950
7951 (define-public sbcl-science-data
7952   (package
7953     (inherit sbcl-antik-base)
7954     (name "sbcl-science-data")
7955     (inputs
7956      `(("physical-dimension" ,sbcl-physical-dimension)
7957        ("drakma" ,sbcl-drakma)))
7958     (arguments
7959      (substitute-keyword-arguments (package-arguments sbcl-antik-base)
7960        ((#:asd-file _ "") "science-data.asd")
7961        ((#:asd-system-name _ #f) "science-data")))
7962     (synopsis
7963      "Common Lisp library for scientific and engineering numerical data")))
7964
7965 (define-public cl-science-data
7966   (sbcl-package->cl-source-package sbcl-science-data))
7967
7968 (define-public sbcl-gsll
7969   (let ((commit "1a8ada22f9cf5ed7372d352b2317f4ccdb6ab308")
7970         (revision "1"))
7971     (package
7972       (name "sbcl-gsll")
7973       (version (git-version "0.0.0" revision commit))
7974       (source
7975        (origin
7976          (method git-fetch)
7977          (uri (git-reference
7978                (url "https://gitlab.common-lisp.net/antik/gsll.git")
7979                (commit commit)))
7980          (file-name (git-file-name name version))
7981          (sha256
7982           (base32
7983            "0z5nypfk26hxihb08p085644afawicrgb4xvadh3lmrn46qbjfn4"))))
7984       (build-system asdf-build-system/sbcl)
7985       (native-inputs
7986        `(("lisp-unit" ,sbcl-lisp-unit)))
7987       (inputs
7988        `(("alexandria" ,sbcl-alexandria)
7989          ("cffi-grovel" ,sbcl-cffi-grovel)
7990          ("cffi-libffi" ,sbcl-cffi-libffi)
7991          ("foreign-array" ,sbcl-foreign-array)
7992          ("gsl" ,gsl)
7993          ("metabang-bind" ,sbcl-metabang-bind)
7994          ("trivial-features" ,sbcl-trivial-features)
7995          ("trivial-garbage" ,sbcl-trivial-garbage)))
7996       (arguments
7997        `(#:tests? #f
7998          #:phases
7999          (modify-phases %standard-phases
8000            (add-after 'unpack 'fix-cffi-paths
8001              (lambda* (#:key inputs #:allow-other-keys)
8002                (substitute* "gsll.asd"
8003                  ((":depends-on \\(#:foreign-array")
8004                   ":depends-on (#:foreign-array #:cffi-libffi"))
8005                (substitute* "init/init.lisp"
8006                  (("libgslcblas.so" all)
8007                   (string-append
8008                    (assoc-ref inputs "gsl") "/lib/" all)))
8009                (substitute* "init/init.lisp"
8010                  (("libgsl.so" all)
8011                   (string-append
8012                    (assoc-ref inputs "gsl") "/lib/" all))))))))
8013       (synopsis "GNU Scientific Library for Lisp")
8014       (description
8015        "The GNU Scientific Library for Lisp (GSLL) allows the use of the
8016 GNU Scientific Library (GSL) from Common Lisp.  This library provides a
8017 full range of common mathematical operations useful to scientific and
8018 engineering applications.  The design of the GSLL interface is such
8019 that access to most of the GSL library is possible in a Lisp-natural
8020 way; the intent is that the user not be hampered by the restrictions
8021 of the C language in which GSL has been written.  GSLL thus provides
8022 interactive use of GSL for getting quick answers, even for someone not
8023 intending to program in Lisp.")
8024       (home-page "https://common-lisp.net/project/gsll/")
8025       (license license:gpl3))))
8026
8027 (define-public cl-gsll
8028   (sbcl-package->cl-source-package sbcl-gsll))
8029
8030 (define-public sbcl-antik
8031   (package
8032     (inherit sbcl-antik-base)
8033     (name "sbcl-antik")
8034     (inputs
8035      `(("gsll" ,sbcl-gsll)
8036        ("physical-dimension" ,sbcl-physical-dimension)))
8037     (arguments
8038      (substitute-keyword-arguments (package-arguments sbcl-antik-base)
8039        ((#:asd-file _ "") "antik.asd")
8040        ((#:asd-system-name _ #f) "antik")))))
8041
8042 (define-public cl-antik
8043   (sbcl-package->cl-source-package sbcl-antik))
8044
8045 (define-public sbcl-cl-interpol
8046   (let ((commit "1fd288d861db85bc4677cff3cdd6af75fda1afb4")
8047         (revision "1"))
8048     (package
8049       (name "sbcl-cl-interpol")
8050       (version (git-version "0.2.6" revision commit))
8051       (source
8052        (origin
8053          (method git-fetch)
8054          (uri (git-reference
8055                (url "https://github.com/edicl/cl-interpol.git")
8056                (commit commit)))
8057          (file-name (git-file-name name version))
8058          (sha256
8059           (base32
8060            "1hnikak52hmcq1r5f616m6qq1108qnkw80pja950nv1fq5p0ppjn"))))
8061       (build-system asdf-build-system/sbcl)
8062       (inputs
8063        `(("cl-unicode" ,sbcl-cl-unicode)
8064          ("named-readtables" ,sbcl-named-readtables)))
8065       (native-inputs
8066        `(("flexi-streams" ,sbcl-flexi-streams)))
8067       (synopsis "String interpolation for Common Lisp")
8068       (description
8069        "CL-INTERPOL is a library for Common Lisp which modifies the
8070 reader so that you can have interpolation within strings similar to
8071 Perl or Unix Shell scripts.  It also provides various ways to insert
8072 arbitrary characters into literal strings even if your editor/IDE
8073 doesn't support them.")
8074       (home-page "https://edicl.github.io/cl-interpol/")
8075       (license license:bsd-3))))
8076
8077 (define-public cl-interpol
8078   (sbcl-package->cl-source-package sbcl-cl-interpol))
8079
8080 (define-public ecl-cl-interpol
8081   (sbcl-package->ecl-package sbcl-cl-interpol))
8082
8083 (define sbcl-symbol-munger-boot0
8084   ;; There is a cyclical dependency between symbol-munger and lisp-unit2.
8085   ;; See https://github.com/AccelerationNet/symbol-munger/issues/4
8086   (let ((commit "cc2bb4b7acd454d756484aec81ba487648385fc3")
8087         (revision "1"))
8088     (package
8089       (name "sbcl-symbol-munger-boot0")
8090       (version (git-version "0.0.1" revision commit))
8091       (source
8092        (origin
8093          (method git-fetch)
8094          (uri (git-reference
8095                (url "https://github.com/AccelerationNet/symbol-munger.git")
8096                (commit commit)))
8097          (file-name (git-file-name name version))
8098          (sha256
8099           (base32
8100            "0diav5ricqsybqvbp4bkxyj3bn3v9n7xb2pqqc4vg1algsw2pyjl"))))
8101       (build-system asdf-build-system/sbcl)
8102       (arguments
8103        `(#:asd-file "symbol-munger.asd"
8104          #:asd-system-name "symbol-munger"))
8105       (inputs
8106        `(("iterate" ,sbcl-iterate)
8107          ("alexandria" ,sbcl-alexandria)))
8108       (native-inputs
8109        `(("lisp-unit" ,sbcl-lisp-unit)))
8110       (synopsis
8111        "Capitalization and spacing conversion functions for Common Lisp")
8112       (description
8113        "This is a Common Lisp library to change the capitalization and spacing
8114 of a string or a symbol.  It can convert to and from Lisp, english, underscore
8115 and camel-case rules.")
8116       (home-page "https://github.com/AccelerationNet/symbol-munger")
8117       ;; The package declares a BSD license, but all of the license
8118       ;; text is MIT.
8119       ;; See https://github.com/AccelerationNet/symbol-munger/issues/5
8120       (license license:expat))))
8121
8122 (define sbcl-lisp-unit2-boot0
8123   ;; There is a cyclical dependency between symbol-munger and lisp-unit2.
8124   ;; See https://github.com/AccelerationNet/symbol-munger/issues/4
8125   (let ((commit "fb9721524d1e4e73abb223ee036d74ce14a5505c")
8126         (revision "1"))
8127     (package
8128       (name "sbcl-lisp-unit2-boot0")
8129       (version (git-version "0.2.0" revision commit))
8130       (source
8131        (origin
8132          (method git-fetch)
8133          (uri (git-reference
8134                (url "https://github.com/AccelerationNet/lisp-unit2.git")
8135                (commit commit)))
8136          (file-name (git-file-name name version))
8137          (sha256
8138           (base32
8139            "1rsqy8y0jqll6xn9a593848f5wvd5ribv4csry1ly0hmdhfnqzlp"))))
8140       (build-system asdf-build-system/sbcl)
8141       (arguments
8142        `(#:asd-file "lisp-unit2.asd"
8143          #:asd-system-name "lisp-unit2"))
8144       (inputs
8145        `(("alexandria" ,sbcl-alexandria)
8146          ("cl-interpol" ,sbcl-cl-interpol)
8147          ("iterate" ,sbcl-iterate)
8148          ("symbol-munger-boot0" ,sbcl-symbol-munger-boot0)))
8149       (synopsis "Test Framework for Common Lisp")
8150       (description
8151        "LISP-UNIT2 is a Common Lisp library that supports unit testing in the
8152 style of JUnit for Java.  It is a new version of the lisp-unit library written
8153 by Chris Riesbeck.")
8154       (home-page "https://github.com/AccelerationNet/lisp-unit2")
8155       (license license:expat))))
8156
8157 (define-public sbcl-symbol-munger
8158   (let ((commit "97598d4c3c53fd5da72ab78908fbd5d8c7a13416")
8159         (revision "1"))
8160     (package
8161       (name "sbcl-symbol-munger")
8162       (version (git-version "0.0.1" revision commit))
8163       (source
8164        (origin
8165          (method git-fetch)
8166          (uri (git-reference
8167                (url "https://github.com/AccelerationNet/symbol-munger.git")
8168                (commit commit)))
8169          (file-name (git-file-name name version))
8170          (sha256
8171           (base32
8172            "0y8jywjy0ldyhp7bxf16fdvdd2qgqnd7nlhlqfpfnzxcqk4xy1km"))))
8173       (build-system asdf-build-system/sbcl)
8174       (inputs
8175        `(("alexandria" ,sbcl-alexandria)
8176          ("iterate" ,sbcl-iterate)))
8177       (native-inputs
8178        `(("lisp-unit2-boot0" ,sbcl-lisp-unit2-boot0)))
8179       (synopsis
8180        "Capitalization and spacing conversion functions for Common Lisp")
8181       (description
8182        "This is a Common Lisp library to change the capitalization and spacing
8183 of a string or a symbol.  It can convert to and from Lisp, english, underscore
8184 and camel-case rules.")
8185       (home-page "https://github.com/AccelerationNet/symbol-munger")
8186       ;; The package declares a BSD license, but all of the license
8187       ;; text is MIT.
8188       ;; See https://github.com/AccelerationNet/symbol-munger/issues/5
8189       (license license:expat))))
8190
8191 (define-public cl-symbol-munger
8192   (sbcl-package->cl-source-package sbcl-symbol-munger))
8193
8194 (define-public ecl-symbol-munger
8195   (sbcl-package->ecl-package sbcl-symbol-munger))
8196
8197 (define-public sbcl-lisp-unit2
8198   (package
8199     (inherit sbcl-lisp-unit2-boot0)
8200     (name "sbcl-lisp-unit2")
8201     (inputs
8202      `(("alexandria" ,sbcl-alexandria)
8203        ("cl-interpol" ,sbcl-cl-interpol)
8204        ("iterate" ,sbcl-iterate)
8205        ("symbol-munger" ,sbcl-symbol-munger)))))
8206
8207 (define-public cl-lisp-unit2
8208   (sbcl-package->cl-source-package sbcl-lisp-unit2))
8209
8210 (define-public ecl-lisp-unit2
8211   (sbcl-package->ecl-package sbcl-lisp-unit2))
8212
8213 (define-public sbcl-cl-csv
8214   (let ((commit "3eba29c8364b033fbe0d189c2500559278b6a362")
8215         (revision "1"))
8216     (package
8217       (name "sbcl-cl-csv")
8218       (version (git-version "1.0.6" revision commit))
8219       (source
8220        (origin
8221          (method git-fetch)
8222          (uri (git-reference
8223                (url "https://github.com/AccelerationNet/cl-csv.git")
8224                (commit commit)))
8225          (file-name (git-file-name name version))
8226          (sha256
8227           (base32
8228            "07h4ni89jzx93clx453hlnnb5g53hhlcmz5hghqv6ysam48lc8g6"))))
8229       (build-system asdf-build-system/sbcl)
8230       (arguments
8231        ;; See: https://github.com/AccelerationNet/cl-csv/pull/34
8232        `(#:tests? #f))
8233       (inputs
8234        `(("alexandria" ,sbcl-alexandria)
8235          ("cl-interpol" ,sbcl-cl-interpol)
8236          ("iterate" ,sbcl-iterate)))
8237       (native-inputs
8238        `(("lisp-unit2" ,sbcl-lisp-unit2)))
8239       (synopsis "Common lisp library for comma-separated values")
8240       (description
8241        "This is a Common Lisp library providing functions to read/write CSV
8242 from/to strings, streams and files.")
8243       (home-page "https://github.com/AccelerationNet/cl-csv")
8244       (license license:bsd-3))))
8245
8246 (define-public cl-csv
8247   (sbcl-package->cl-source-package sbcl-cl-csv))
8248
8249 (define-public ecl-cl-csv
8250   (sbcl-package->ecl-package sbcl-cl-csv))
8251
8252 (define-public sbcl-external-program
8253   (let ((commit "5888b8f1fd3953feeeacecbba4384ddda584a749")
8254         (revision "1"))
8255     (package
8256       (name "sbcl-external-program")
8257       (version (git-version "0.0.6" revision commit))
8258       (source
8259        (origin
8260          (method git-fetch)
8261          (uri (git-reference
8262                (url "https://github.com/sellout/external-program.git")
8263                (commit commit)))
8264          (file-name (git-file-name name version))
8265          (sha256
8266           (base32
8267            "0vww1x3yilb3bjwg6k184vaj4vxyxw4vralhnlm6lk4xac67kc9z"))))
8268       (build-system asdf-build-system/sbcl)
8269       (inputs
8270        `(("trivial-features" ,sbcl-trivial-features)))
8271       (native-inputs
8272        `(("fiveam" ,sbcl-fiveam)))
8273       (synopsis "Common Lisp library for running external programs")
8274       (description
8275        "EXTERNAL-PROGRAM enables running programs outside the Lisp
8276 process.  It is an attempt to make the RUN-PROGRAM functionality in
8277 implementations like SBCL and CCL as portable as possible without
8278 sacrificing much in the way of power.")
8279       (home-page "https://github.com/sellout/external-program")
8280       (license license:llgpl))))
8281
8282 (define-public cl-external-program
8283   (sbcl-package->cl-source-package sbcl-external-program))
8284
8285 (define-public ecl-external-program
8286   (sbcl-package->ecl-package sbcl-external-program))
8287
8288 (define sbcl-cl-ana-boot0
8289   (let ((commit "fa7cee4c50aa1c859652813049ba0da7c18a0df9")
8290         (revision "1"))
8291     (package
8292      (name "sbcl-cl-ana-boot0")
8293      (version (git-version "0.0.0" revision commit))
8294      (source
8295       (origin
8296        (method git-fetch)
8297        (uri (git-reference
8298              (url "https://github.com/ghollisjr/cl-ana.git")
8299              (commit commit)))
8300        (file-name (git-file-name name version))
8301        (sha256
8302         (base32
8303          "0mr47l57m276dbpap7irr4fcnk5fgknhf6mgv4043s8h73amk5qh"))))
8304      (build-system asdf-build-system/sbcl)
8305      (synopsis "Common Lisp data analysis library")
8306      (description
8307       "CL-ANA is a data analysis library in Common Lisp providing tabular and
8308 binned data analysis along with nonlinear least squares fitting and
8309 visualization.")
8310      (home-page "https://github.com/ghollisjr/cl-ana")
8311      (license license:gpl3))))
8312
8313 (define-public sbcl-cl-ana.pathname-utils
8314   (package
8315     (inherit sbcl-cl-ana-boot0)
8316     (name "sbcl-cl-ana.pathname-utils")
8317     (arguments
8318      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8319        ((#:asd-file _ "") "pathname-utils/cl-ana.pathname-utils.asd")
8320        ((#:asd-system-name _ #f) "cl-ana.pathname-utils")))))
8321
8322 (define-public cl-ana.pathname-utils
8323   (sbcl-package->cl-source-package sbcl-cl-ana.pathname-utils))
8324
8325 (define-public ecl-cl-ana.pathname-utils
8326   (sbcl-package->ecl-package sbcl-cl-ana.pathname-utils))
8327
8328 (define-public sbcl-cl-ana.package-utils
8329   (package
8330     (inherit sbcl-cl-ana-boot0)
8331     (name "sbcl-cl-ana.package-utils")
8332     (inputs
8333      `(("alexandria" ,sbcl-alexandria)))
8334     (arguments
8335      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8336        ((#:asd-file _ "") "package-utils/cl-ana.package-utils.asd")
8337        ((#:asd-system-name _ #f) "cl-ana.package-utils")))))
8338
8339 (define-public cl-ana.package-utils
8340   (sbcl-package->cl-source-package sbcl-cl-ana.package-utils))
8341
8342 (define-public ecl-cl-ana.package-utils
8343   (sbcl-package->ecl-package sbcl-cl-ana.package-utils))
8344
8345 (define-public sbcl-cl-ana.string-utils
8346   (package
8347     (inherit sbcl-cl-ana-boot0)
8348     (name "sbcl-cl-ana.string-utils")
8349     (inputs
8350      `(("split-sequence" ,sbcl-split-sequence)))
8351     (arguments
8352      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8353        ((#:asd-file _ "") "string-utils/cl-ana.string-utils.asd")
8354        ((#:asd-system-name _ #f) "cl-ana.string-utils")))))
8355
8356 (define-public cl-ana.string-utils
8357   (sbcl-package->cl-source-package sbcl-cl-ana.string-utils))
8358
8359 (define-public ecl-cl-ana.string-utils
8360   (sbcl-package->ecl-package sbcl-cl-ana.string-utils))
8361
8362 (define-public sbcl-cl-ana.functional-utils
8363   (package
8364     (inherit sbcl-cl-ana-boot0)
8365     (name "sbcl-cl-ana.functional-utils")
8366     (arguments
8367      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8368        ((#:asd-file _ "") "functional-utils/cl-ana.functional-utils.asd")
8369        ((#:asd-system-name _ #f) "cl-ana.functional-utils")))))
8370
8371 (define-public cl-ana.functional-utils
8372   (sbcl-package->cl-source-package sbcl-cl-ana.functional-utils))
8373
8374 (define-public ecl-cl-ana.functional-utils
8375   (sbcl-package->ecl-package sbcl-cl-ana.functional-utils))
8376
8377 (define-public sbcl-cl-ana.list-utils
8378   (package
8379     (inherit sbcl-cl-ana-boot0)
8380     (name "sbcl-cl-ana.list-utils")
8381     (inputs
8382      `(("alexandria" ,sbcl-alexandria)
8383        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
8384        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)))
8385     (arguments
8386      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8387        ((#:asd-file _ "") "list-utils/cl-ana.list-utils.asd")
8388        ((#:asd-system-name _ #f) "cl-ana.list-utils")))))
8389
8390 (define-public cl-ana.list-utils
8391   (sbcl-package->cl-source-package sbcl-cl-ana.list-utils))
8392
8393 (define-public ecl-cl-ana.list-utils
8394   (sbcl-package->ecl-package sbcl-cl-ana.list-utils))
8395
8396 (define-public sbcl-cl-ana.generic-math
8397   (package
8398     (inherit sbcl-cl-ana-boot0)
8399     (name "sbcl-cl-ana.generic-math")
8400     (inputs
8401      `(("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8402        ("cl-ana.package-utils" ,sbcl-cl-ana.package-utils)))
8403     (arguments
8404      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8405        ((#:asd-file _ "") "generic-math/cl-ana.generic-math.asd")
8406        ((#:asd-system-name _ #f) "cl-ana.generic-math")))))
8407
8408 (define-public cl-ana.generic-math
8409   (sbcl-package->cl-source-package sbcl-cl-ana.generic-math))
8410
8411 (define-public ecl-cl-ana.generic-math
8412   (sbcl-package->ecl-package sbcl-cl-ana.generic-math))
8413
8414 (define-public sbcl-cl-ana.math-functions
8415   (package
8416     (inherit sbcl-cl-ana-boot0)
8417     (name "sbcl-cl-ana.math-functions")
8418     (inputs
8419      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8420        ("gsll" ,sbcl-gsll)))
8421     (arguments
8422      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8423        ((#:asd-file _ "") "math-functions/cl-ana.math-functions.asd")
8424        ((#:asd-system-name _ #f) "cl-ana.math-functions")))))
8425
8426 (define-public cl-ana.math-functions
8427   (sbcl-package->cl-source-package sbcl-cl-ana.math-functions))
8428
8429 (define-public sbcl-cl-ana.calculus
8430   (package
8431     (inherit sbcl-cl-ana-boot0)
8432     (name "sbcl-cl-ana.calculus")
8433     (inputs
8434      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)))
8435     (arguments
8436      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8437        ((#:asd-file _ "") "calculus/cl-ana.calculus.asd")
8438        ((#:asd-system-name _ #f) "cl-ana.calculus")))))
8439
8440 (define-public cl-ana.calculus
8441   (sbcl-package->cl-source-package sbcl-cl-ana.calculus))
8442
8443 (define-public ecl-cl-ana.calculus
8444   (sbcl-package->ecl-package sbcl-cl-ana.calculus))
8445
8446 (define-public sbcl-cl-ana.symbol-utils
8447   (package
8448     (inherit sbcl-cl-ana-boot0)
8449     (name "sbcl-cl-ana.symbol-utils")
8450     (inputs
8451      `(("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)))
8452     (arguments
8453      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8454        ((#:asd-file _ "") "symbol-utils/cl-ana.symbol-utils.asd")
8455        ((#:asd-system-name _ #f) "cl-ana.symbol-utils")))))
8456
8457 (define-public cl-ana.symbol-utils
8458   (sbcl-package->cl-source-package sbcl-cl-ana.symbol-utils))
8459
8460 (define-public ecl-cl-ana.symbol-utils
8461   (sbcl-package->ecl-package sbcl-cl-ana.symbol-utils))
8462
8463 (define-public sbcl-cl-ana.macro-utils
8464   (package
8465     (inherit sbcl-cl-ana-boot0)
8466     (name "sbcl-cl-ana.macro-utils")
8467     (inputs
8468      `(("alexandria" ,sbcl-alexandria)
8469        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8470        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8471        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8472        ("split-sequence" ,sbcl-split-sequence)))
8473     (arguments
8474      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8475        ((#:asd-file _ "") "macro-utils/cl-ana.macro-utils.asd")
8476        ((#:asd-system-name _ #f) "cl-ana.macro-utils")))))
8477
8478 (define-public cl-ana.macro-utils
8479   (sbcl-package->cl-source-package sbcl-cl-ana.macro-utils))
8480
8481 (define-public ecl-cl-ana.macro-utils
8482   (sbcl-package->ecl-package sbcl-cl-ana.macro-utils))
8483
8484 (define-public sbcl-cl-ana.binary-tree
8485   (package
8486     (inherit sbcl-cl-ana-boot0)
8487     (name "sbcl-cl-ana.binary-tree")
8488     (inputs
8489      `(("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
8490        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8491        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)))
8492     (arguments
8493      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8494        ((#:asd-file _ "") "binary-tree/cl-ana.binary-tree.asd")
8495        ((#:asd-system-name _ #f) "cl-ana.binary-tree")))))
8496
8497 (define-public cl-ana.binary-tree
8498   (sbcl-package->cl-source-package sbcl-cl-ana.binary-tree))
8499
8500 (define-public ecl-cl-ana.binary-tree
8501   (sbcl-package->ecl-package sbcl-cl-ana.binary-tree))
8502
8503 (define-public sbcl-cl-ana.tensor
8504   (package
8505     (inherit sbcl-cl-ana-boot0)
8506     (name "sbcl-cl-ana.tensor")
8507     (inputs
8508      `(("alexandria" ,sbcl-alexandria)
8509        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8510        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8511        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8512        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)))
8513     (arguments
8514      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8515        ((#:asd-file _ "") "tensor/cl-ana.tensor.asd")
8516        ((#:asd-system-name _ #f) "cl-ana.tensor")))))
8517
8518 (define-public cl-ana.tensor
8519   (sbcl-package->cl-source-package sbcl-cl-ana.tensor))
8520
8521 (define-public ecl-cl-ana.tensor
8522   (sbcl-package->ecl-package sbcl-cl-ana.tensor))
8523
8524 (define-public sbcl-cl-ana.error-propogation
8525   (package
8526     (inherit sbcl-cl-ana-boot0)
8527     (name "sbcl-cl-ana.error-propogation")
8528     (inputs
8529      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8530        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)))
8531     (arguments
8532      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8533        ((#:asd-file _ "") "error-propogation/cl-ana.error-propogation.asd")
8534        ((#:asd-system-name _ #f) "cl-ana.error-propogation")))))
8535
8536 (define-public cl-ana.error-propogation
8537   (sbcl-package->cl-source-package sbcl-cl-ana.error-propogation))
8538
8539 (define-public sbcl-cl-ana.quantity
8540   (package
8541     (inherit sbcl-cl-ana-boot0)
8542     (name "sbcl-cl-ana.quantity")
8543     (inputs
8544      `(("alexandria" ,sbcl-alexandria)
8545        ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
8546        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8547        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8548        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8549        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)))
8550     (arguments
8551      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8552        ((#:asd-file _ "") "quantity/cl-ana.quantity.asd")
8553        ((#:asd-system-name _ #f) "cl-ana.quantity")))))
8554
8555 (define-public cl-ana.quantity
8556   (sbcl-package->cl-source-package sbcl-cl-ana.quantity))
8557
8558 (define-public sbcl-cl-ana.table
8559   (package
8560     (inherit sbcl-cl-ana-boot0)
8561     (name "sbcl-cl-ana.table")
8562     (inputs
8563      `(("alexandria" ,sbcl-alexandria)
8564        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
8565        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8566        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8567        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8568        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)))
8569     (arguments
8570      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8571        ((#:asd-file _ "") "table/cl-ana.table.asd")
8572        ((#:asd-system-name _ #f) "cl-ana.table")))))
8573
8574 (define-public cl-ana.table
8575   (sbcl-package->cl-source-package sbcl-cl-ana.table))
8576
8577 (define-public ecl-cl-ana.table
8578   (sbcl-package->ecl-package sbcl-cl-ana.table))
8579
8580 (define-public sbcl-cl-ana.table-utils
8581   (package
8582     (inherit sbcl-cl-ana-boot0)
8583     (name "sbcl-cl-ana.table-utils")
8584     (inputs
8585      `(("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8586        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8587        ("cl-ana.table" ,sbcl-cl-ana.table)))
8588     (arguments
8589      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8590        ((#:asd-file _ "") "table-utils/cl-ana.table-utils.asd")
8591        ((#:asd-system-name _ #f) "cl-ana.table-utils")))))
8592
8593 (define-public cl-ana.table-utils
8594   (sbcl-package->cl-source-package sbcl-cl-ana.table-utils))
8595
8596 (define-public ecl-cl-ana.table-utils
8597   (sbcl-package->ecl-package sbcl-cl-ana.table-utils))
8598
8599 (define-public sbcl-cl-ana.hdf-cffi
8600   (package
8601     (inherit sbcl-cl-ana-boot0)
8602     (name "sbcl-cl-ana.hdf-cffi")
8603     (inputs
8604      `(("cffi" ,sbcl-cffi)
8605        ("hdf5" ,hdf5-parallel-openmpi)))
8606     (arguments
8607      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8608        ((#:asd-file _ "") "hdf-cffi/cl-ana.hdf-cffi.asd")
8609        ((#:asd-system-name _ #f) "cl-ana.hdf-cffi")
8610        ((#:phases phases '%standard-phases)
8611         `(modify-phases ,phases
8612            (add-after 'unpack 'fix-paths
8613              (lambda* (#:key inputs #:allow-other-keys)
8614                (substitute* "hdf-cffi/hdf-cffi.lisp"
8615                  (("/usr/lib/i386-linux-gnu/hdf5/serial/libhdf5.so")
8616                   (string-append
8617                    (assoc-ref inputs "hdf5")
8618                    "/lib/libhdf5.so")))))))))))
8619
8620 (define-public cl-ana.hdf-cffi
8621   (sbcl-package->cl-source-package sbcl-cl-ana.hdf-cffi))
8622
8623 (define-public ecl-cl-ana.hdf-cffi
8624   (sbcl-package->ecl-package sbcl-cl-ana.hdf-cffi))
8625
8626 (define-public sbcl-cl-ana.int-char
8627   (package
8628     (inherit sbcl-cl-ana-boot0)
8629     (name "sbcl-cl-ana.int-char")
8630     (arguments
8631      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8632        ((#:asd-file _ "") "int-char/cl-ana.int-char.asd")
8633        ((#:asd-system-name _ #f) "cl-ana.int-char")))))
8634
8635 (define-public cl-ana.int-char
8636   (sbcl-package->cl-source-package sbcl-cl-ana.int-char))
8637
8638 (define-public ecl-cl-ana.int-char
8639   (sbcl-package->ecl-package sbcl-cl-ana.int-char))
8640
8641 (define-public sbcl-cl-ana.memoization
8642   (package
8643     (inherit sbcl-cl-ana-boot0)
8644     (name "sbcl-cl-ana.memoization")
8645     (inputs
8646      `(("alexandria" ,sbcl-alexandria)))
8647     (arguments
8648      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8649        ((#:asd-file _ "") "memoization/cl-ana.memoization.asd")
8650        ((#:asd-system-name _ #f) "cl-ana.memoization")))))
8651
8652 (define-public cl-ana.memoization
8653   (sbcl-package->cl-source-package sbcl-cl-ana.memoization))
8654
8655 (define-public ecl-cl-ana.memoization
8656   (sbcl-package->ecl-package sbcl-cl-ana.memoization))
8657
8658 (define-public sbcl-cl-ana.typespec
8659   (package
8660     (inherit sbcl-cl-ana-boot0)
8661     (name "sbcl-cl-ana.typespec")
8662     (inputs
8663      `(("alexandria" ,sbcl-alexandria)
8664        ("cffi" ,sbcl-cffi)
8665        ("cl-ana.int-char" ,sbcl-cl-ana.int-char)
8666        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8667        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
8668        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8669        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8670        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)))
8671     (arguments
8672      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8673        ((#:asd-file _ "") "typespec/cl-ana.typespec.asd")
8674        ((#:asd-system-name _ #f) "cl-ana.typespec")))))
8675
8676 (define-public cl-ana.typespec
8677   (sbcl-package->cl-source-package sbcl-cl-ana.typespec))
8678
8679 (define-public ecl-cl-ana.typespec
8680   (sbcl-package->ecl-package sbcl-cl-ana.typespec))
8681
8682 (define-public sbcl-cl-ana.hdf-typespec
8683   (package
8684     (inherit sbcl-cl-ana-boot0)
8685     (name "sbcl-cl-ana.hdf-typespec")
8686     (inputs
8687      `(("alexandria" ,sbcl-alexandria)
8688        ("cffi" ,sbcl-cffi)
8689        ("cl-ana.hdf-cffi" ,sbcl-cl-ana.hdf-cffi)
8690        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8691        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
8692        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8693        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8694        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
8695     (arguments
8696      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8697        ((#:asd-file _ "") "hdf-typespec/cl-ana.hdf-typespec.asd")
8698        ((#:asd-system-name _ #f) "cl-ana.hdf-typespec")))))
8699
8700 (define-public cl-ana.hdf-typespec
8701   (sbcl-package->cl-source-package sbcl-cl-ana.hdf-typespec))
8702
8703 (define-public ecl-cl-ana.hdf-typespec
8704   (sbcl-package->ecl-package sbcl-cl-ana.hdf-typespec))
8705
8706 (define-public sbcl-cl-ana.hdf-utils
8707   (package
8708     (inherit sbcl-cl-ana-boot0)
8709     (name "sbcl-cl-ana.hdf-utils")
8710     (inputs
8711      `(("alexandria" ,sbcl-alexandria)
8712        ("cffi" ,sbcl-cffi)
8713        ("cl-ana.hdf-cffi" ,sbcl-cl-ana.hdf-cffi)
8714        ("cl-ana.hdf-typespec" ,sbcl-cl-ana.hdf-typespec)
8715        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8716        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
8717        ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
8718        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8719        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
8720     (arguments
8721      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8722        ((#:asd-file _ "") "hdf-utils/cl-ana.hdf-utils.asd")
8723        ((#:asd-system-name _ #f) "cl-ana.hdf-utils")))))
8724
8725 (define-public cl-ana.hdf-utils
8726   (sbcl-package->cl-source-package sbcl-cl-ana.hdf-utils))
8727
8728 (define-public ecl-cl-ana.hdf-utils
8729   (sbcl-package->ecl-package sbcl-cl-ana.hdf-utils))
8730
8731 (define-public sbcl-cl-ana.typed-table
8732   (package
8733     (inherit sbcl-cl-ana-boot0)
8734     (name "sbcl-cl-ana.typed-table")
8735     (inputs
8736      `(("alexandria" ,sbcl-alexandria)
8737        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8738        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8739        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8740        ("cl-ana.table" ,sbcl-cl-ana.table)
8741        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
8742     (arguments
8743      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8744        ((#:asd-file _ "") "typed-table/cl-ana.typed-table.asd")
8745        ((#:asd-system-name _ #f) "cl-ana.typed-table")))))
8746
8747 (define-public cl-ana.typed-table
8748   (sbcl-package->cl-source-package sbcl-cl-ana.typed-table))
8749
8750 (define-public ecl-cl-ana.typed-table
8751   (sbcl-package->ecl-package sbcl-cl-ana.typed-table))
8752
8753 (define-public sbcl-cl-ana.hdf-table
8754   (package
8755     (inherit sbcl-cl-ana-boot0)
8756     (name "sbcl-cl-ana.hdf-table")
8757     (inputs
8758      `(("alexandria" ,sbcl-alexandria)
8759        ("cl-ana.binary-tree" ,sbcl-cl-ana.binary-tree)
8760        ("cl-ana.hdf-cffi" ,sbcl-cl-ana.hdf-cffi)
8761        ("cl-ana.hdf-typespec" ,sbcl-cl-ana.hdf-typespec)
8762        ("cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
8763        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8764        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
8765        ("cl-ana.table" ,sbcl-cl-ana.table)
8766        ("cl-ana.typed-table" ,sbcl-cl-ana.typed-table)
8767        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
8768     (arguments
8769      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8770        ((#:asd-file _ "") "hdf-table/cl-ana.hdf-table.asd")
8771        ((#:asd-system-name _ #f) "cl-ana.hdf-table")))))
8772
8773 (define-public cl-ana.hdf-table
8774   (sbcl-package->cl-source-package sbcl-cl-ana.hdf-table))
8775
8776 (define-public ecl-cl-ana.hdf-table
8777   (sbcl-package->ecl-package sbcl-cl-ana.hdf-table))
8778
8779 (define-public sbcl-cl-ana.gsl-cffi
8780   (package
8781     (inherit sbcl-cl-ana-boot0)
8782     (name "sbcl-cl-ana.gsl-cffi")
8783     (inputs
8784      `(("cffi" ,sbcl-cffi)
8785        ("gsl" ,gsl)))
8786     (arguments
8787      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8788        ((#:asd-file _ "") "gsl-cffi/cl-ana.gsl-cffi.asd")
8789        ((#:asd-system-name _ #f) "cl-ana.gsl-cffi")
8790        ((#:phases phases '%standard-phases)
8791         `(modify-phases ,phases
8792            (add-after 'unpack 'fix-paths
8793              (lambda* (#:key inputs #:allow-other-keys)
8794                (substitute* "gsl-cffi/gsl-cffi.lisp"
8795                  (("define-foreign-library gsl-cffi" all)
8796                   (string-append all " (:unix "
8797                                  (assoc-ref inputs "gsl")
8798                                  "/lib/libgsl.so)")))))))))))
8799
8800 (define-public cl-ana.gsl-cffi
8801   (sbcl-package->cl-source-package sbcl-cl-ana.gsl-cffi))
8802
8803 (define-public ecl-cl-ana.gsl-cffi
8804   (sbcl-package->ecl-package sbcl-cl-ana.gsl-cffi))
8805
8806 (define-public sbcl-cl-ana.ntuple-table
8807   (package
8808     (inherit sbcl-cl-ana-boot0)
8809     (name "sbcl-cl-ana.ntuple-table")
8810     (inputs
8811      `(("alexandria" ,sbcl-alexandria)
8812        ("cffi" ,sbcl-cffi)
8813        ("cl-ana.gsl-cffi" ,sbcl-cl-ana.gsl-cffi)
8814        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8815        ("cl-ana.table" ,sbcl-cl-ana.table)
8816        ("cl-ana.typed-table" ,sbcl-cl-ana.typed-table)
8817        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)
8818        ("gsll" ,sbcl-gsll)))
8819     (arguments
8820      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8821        ((#:asd-file _ "") "ntuple-table/cl-ana.ntuple-table.asd")
8822        ((#:asd-system-name _ #f) "cl-ana.ntuple-table")))))
8823
8824 (define-public cl-ana.ntuple-table
8825   (sbcl-package->cl-source-package sbcl-cl-ana.ntuple-table))
8826
8827 (define-public sbcl-cl-ana.csv-table
8828   (package
8829     (inherit sbcl-cl-ana-boot0)
8830     (name "sbcl-cl-ana.csv-table")
8831     (inputs
8832      `(("alexandria" ,sbcl-alexandria)
8833        ("antik" ,sbcl-antik)
8834        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8835        ("cl-ana.table" ,sbcl-cl-ana.table)
8836        ("cl-csv" ,sbcl-cl-csv)
8837        ("iterate" ,sbcl-iterate)))
8838     (arguments
8839      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8840        ((#:asd-file _ "") "csv-table/cl-ana.csv-table.asd")
8841        ((#:asd-system-name _ #f) "cl-ana.csv-table")))))
8842
8843 (define-public cl-ana.csv-table
8844   (sbcl-package->cl-source-package sbcl-cl-ana.csv-table))
8845
8846 (define-public sbcl-cl-ana.reusable-table
8847   (package
8848     (inherit sbcl-cl-ana-boot0)
8849     (name "sbcl-cl-ana.reusable-table")
8850     (inputs
8851      `(("alexandria" ,sbcl-alexandria)
8852        ("cl-ana.table" ,sbcl-cl-ana.table)))
8853     (arguments
8854      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8855        ((#:asd-file _ "") "reusable-table/cl-ana.reusable-table.asd")
8856        ((#:asd-system-name _ #f) "cl-ana.reusable-table")))))
8857
8858 (define-public cl-ana.reusable-table
8859   (sbcl-package->cl-source-package sbcl-cl-ana.reusable-table))
8860
8861 (define-public ecl-cl-ana.reusable-table
8862   (sbcl-package->ecl-package sbcl-cl-ana.reusable-table))
8863
8864 (define-public sbcl-cl-ana.linear-algebra
8865   (package
8866     (inherit sbcl-cl-ana-boot0)
8867     (name "sbcl-cl-ana.linear-algebra")
8868     (inputs
8869      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8870        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8871        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
8872        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
8873        ("gsll" ,sbcl-gsll)))
8874     (arguments
8875      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8876        ((#:asd-file _ "") "linear-algebra/cl-ana.linear-algebra.asd")
8877        ((#:asd-system-name _ #f) "cl-ana.linear-algebra")))))
8878
8879 (define-public cl-ana.linear-algebra
8880   (sbcl-package->cl-source-package sbcl-cl-ana.linear-algebra))
8881
8882 (define-public sbcl-cl-ana.lorentz
8883   (package
8884     (inherit sbcl-cl-ana-boot0)
8885     (name "sbcl-cl-ana.lorentz")
8886     (inputs
8887      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8888        ("cl-ana.linear-algebra" ,sbcl-cl-ana.linear-algebra)
8889        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
8890        ("iterate" ,sbcl-iterate)))
8891     (arguments
8892      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8893        ((#:asd-file _ "") "lorentz/cl-ana.lorentz.asd")
8894        ((#:asd-system-name _ #f) "cl-ana.lorentz")))))
8895
8896 (define-public cl-ana.lorentz
8897   (sbcl-package->cl-source-package sbcl-cl-ana.lorentz))
8898
8899 (define-public sbcl-cl-ana.clos-utils
8900   (package
8901     (inherit sbcl-cl-ana-boot0)
8902     (name "sbcl-cl-ana.clos-utils")
8903     (inputs
8904      `(("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8905        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8906        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
8907        ("closer-mop" ,sbcl-closer-mop)))
8908     (arguments
8909      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8910        ((#:asd-file _ "") "clos-utils/cl-ana.clos-utils.asd")
8911        ((#:asd-system-name _ #f) "cl-ana.clos-utils")))))
8912
8913 (define-public cl-ana.clos-utils
8914   (sbcl-package->cl-source-package sbcl-cl-ana.clos-utils))
8915
8916 (define-public ecl-cl-ana.clos-utils
8917   (sbcl-package->ecl-package sbcl-cl-ana.clos-utils))
8918
8919 (define-public sbcl-cl-ana.hash-table-utils
8920   (package
8921     (inherit sbcl-cl-ana-boot0)
8922     (name "sbcl-cl-ana.hash-table-utils")
8923     (arguments
8924      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8925        ((#:asd-file _ "") "hash-table-utils/cl-ana.hash-table-utils.asd")
8926        ((#:asd-system-name _ #f) "cl-ana.hash-table-utils")))))
8927
8928 (define-public cl-ana.hash-table-utils
8929   (sbcl-package->cl-source-package sbcl-cl-ana.hash-table-utils))
8930
8931 (define-public ecl-cl-ana.hash-table-utils
8932   (sbcl-package->ecl-package sbcl-cl-ana.hash-table-utils))
8933
8934 (define-public sbcl-cl-ana.map
8935   (package
8936     (inherit sbcl-cl-ana-boot0)
8937     (name "sbcl-cl-ana.map")
8938     (inputs
8939      `(("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)))
8940     (arguments
8941      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8942        ((#:asd-file _ "") "map/cl-ana.map.asd")
8943        ((#:asd-system-name _ #f) "cl-ana.map")))))
8944
8945 (define-public cl-ana.map
8946   (sbcl-package->cl-source-package sbcl-cl-ana.map))
8947
8948 (define-public ecl-cl-ana.map
8949   (sbcl-package->ecl-package sbcl-cl-ana.map))
8950
8951 (define-public sbcl-cl-ana.fitting
8952   (package
8953     (inherit sbcl-cl-ana-boot0)
8954     (name "sbcl-cl-ana.fitting")
8955     (inputs
8956      `(("alexandria" ,sbcl-alexandria)
8957        ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
8958        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8959        ("cl-ana.map" ,sbcl-cl-ana.map)
8960        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
8961        ("gsll" ,sbcl-gsll)))
8962     (arguments
8963      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8964        ((#:asd-file _ "") "fitting/cl-ana.fitting.asd")
8965        ((#:asd-system-name _ #f) "cl-ana.fitting")))))
8966
8967 (define-public cl-ana.fitting
8968   (sbcl-package->cl-source-package sbcl-cl-ana.fitting))
8969
8970 (define-public sbcl-cl-ana.histogram
8971   (package
8972     (inherit sbcl-cl-ana-boot0)
8973     (name "sbcl-cl-ana.histogram")
8974     (inputs
8975      `(("alexandria" ,sbcl-alexandria)
8976        ("iterate" ,sbcl-iterate)
8977        ("cl-ana.binary-tree" ,sbcl-cl-ana.binary-tree)
8978        ("cl-ana.clos-utils" ,sbcl-cl-ana.clos-utils)
8979        ("cl-ana.fitting" ,sbcl-cl-ana.fitting)
8980        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
8981        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8982        ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
8983        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8984        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8985        ("cl-ana.map" ,sbcl-cl-ana.map)
8986        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)))
8987     (arguments
8988      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8989        ((#:asd-file _ "") "histogram/cl-ana.histogram.asd")
8990        ((#:asd-system-name _ #f) "cl-ana.histogram")))))
8991
8992 (define-public cl-ana.histogram
8993   (sbcl-package->cl-source-package sbcl-cl-ana.histogram))
8994
8995 (define-public sbcl-cl-ana.file-utils
8996   (package
8997     (inherit sbcl-cl-ana-boot0)
8998     (name "sbcl-cl-ana.file-utils")
8999     (inputs
9000      `(("external-program" ,sbcl-external-program)
9001        ("split-sequence" ,sbcl-split-sequence)))
9002     (arguments
9003      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9004        ((#:asd-file _ "") "file-utils/cl-ana.file-utils.asd")
9005        ((#:asd-system-name _ #f) "cl-ana.file-utils")))))
9006
9007 (define-public cl-ana.file-utils
9008   (sbcl-package->cl-source-package sbcl-cl-ana.file-utils))
9009
9010 (define-public ecl-cl-ana.file-utils
9011   (sbcl-package->ecl-package sbcl-cl-ana.file-utils))
9012
9013 (define-public sbcl-cl-ana.statistics
9014   (package
9015     (inherit sbcl-cl-ana-boot0)
9016     (name "sbcl-cl-ana.statistics")
9017     (inputs
9018      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9019        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9020        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9021        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9022        ("cl-ana.map" ,sbcl-cl-ana.map)))
9023     (arguments
9024      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9025        ((#:asd-file _ "") "statistics/cl-ana.statistics.asd")
9026        ((#:asd-system-name _ #f) "cl-ana.statistics")))))
9027
9028 (define-public cl-ana.statistics
9029   (sbcl-package->cl-source-package sbcl-cl-ana.statistics))
9030
9031 (define-public sbcl-cl-ana.gnuplot-interface
9032   (package
9033     (inherit sbcl-cl-ana-boot0)
9034     (name "sbcl-cl-ana.gnuplot-interface")
9035     (inputs
9036      `(("external-program" ,sbcl-external-program)))
9037     (arguments
9038      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9039        ((#:asd-file _ "") "gnuplot-interface/cl-ana.gnuplot-interface.asd")
9040        ((#:asd-system-name _ #f) "cl-ana.gnuplot-interface")))))
9041
9042 (define-public cl-ana.gnuplot-interface
9043   (sbcl-package->cl-source-package sbcl-cl-ana.gnuplot-interface))
9044
9045 (define-public ecl-cl-ana.gnuplot-interface
9046   (sbcl-package->ecl-package sbcl-cl-ana.gnuplot-interface))
9047
9048 (define-public sbcl-cl-ana.plotting
9049   (package
9050     (inherit sbcl-cl-ana-boot0)
9051     (name "sbcl-cl-ana.plotting")
9052     (inputs
9053      `(("alexandria" ,sbcl-alexandria)
9054        ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
9055        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
9056        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9057        ("cl-ana.gnuplot-interface" ,sbcl-cl-ana.gnuplot-interface)
9058        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9059        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9060        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9061        ("cl-ana.map" ,sbcl-cl-ana.map)
9062        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
9063        ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
9064        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
9065        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
9066        ("external-program" ,sbcl-external-program)
9067        ("split-sequence" ,sbcl-split-sequence)))
9068     (arguments
9069      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9070        ((#:asd-file _ "") "plotting/cl-ana.plotting.asd")
9071        ((#:asd-system-name _ #f) "cl-ana.plotting")))))
9072
9073 (define-public cl-ana.plotting
9074   (sbcl-package->cl-source-package sbcl-cl-ana.plotting))
9075
9076 (define-public sbcl-cl-ana.table-viewing
9077   (package
9078     (inherit sbcl-cl-ana-boot0)
9079     (name "sbcl-cl-ana.table-viewing")
9080     (inputs
9081      `(("alexandria" ,sbcl-alexandria)
9082        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9083        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9084        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9085        ("cl-ana.plotting" ,sbcl-cl-ana.plotting)
9086        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
9087        ("cl-ana.table" ,sbcl-cl-ana.table)))
9088     (arguments
9089      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9090        ((#:asd-file _ "") "table-viewing/cl-ana.table-viewing.asd")
9091        ((#:asd-system-name _ #f) "cl-ana.table-viewing")))))
9092
9093 (define-public cl-ana.table-viewing
9094   (sbcl-package->cl-source-package sbcl-cl-ana.table-viewing))
9095
9096 (define-public sbcl-cl-ana.serialization
9097   (package
9098     (inherit sbcl-cl-ana-boot0)
9099     (name "sbcl-cl-ana.serialization")
9100     (inputs
9101      `(("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
9102        ("cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
9103        ("cl-ana.hdf-table" ,sbcl-cl-ana.hdf-table)
9104        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9105        ("cl-ana.int-char" ,sbcl-cl-ana.int-char)
9106        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9107        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
9108     (arguments
9109      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9110        ((#:asd-file _ "") "serialization/cl-ana.serialization.asd")
9111        ((#:asd-system-name _ #f) "cl-ana.serialization")))))
9112
9113 (define-public cl-ana.serialization
9114   (sbcl-package->cl-source-package sbcl-cl-ana.serialization))
9115
9116 (define-public sbcl-cl-ana.makeres
9117   (package
9118     (inherit sbcl-cl-ana-boot0)
9119     (name "sbcl-cl-ana.makeres")
9120     (inputs
9121      `(("alexandria" ,sbcl-alexandria)
9122        ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
9123        ("cl-ana.file-utils" ,sbcl-cl-ana.file-utils)
9124        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
9125        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9126        ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
9127        ("cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
9128        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9129        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9130        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9131        ("cl-ana.map" ,sbcl-cl-ana.map)
9132        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
9133        ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
9134        ("cl-ana.plotting" ,sbcl-cl-ana.plotting)
9135        ("cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
9136        ("cl-ana.serialization" ,sbcl-cl-ana.serialization)
9137        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
9138        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
9139        ("cl-ana.table" ,sbcl-cl-ana.table)
9140        ("external-program" ,sbcl-external-program)))
9141     (native-inputs
9142      `(("cl-fad" ,sbcl-cl-fad)))
9143     (arguments
9144      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9145        ((#:asd-file _ "") "makeres/cl-ana.makeres.asd")
9146        ((#:asd-system-name _ #f) "cl-ana.makeres")))))
9147
9148 (define-public cl-ana.makeres
9149   (sbcl-package->cl-source-package sbcl-cl-ana.makeres))
9150
9151 (define-public sbcl-cl-ana.makeres-macro
9152   (package
9153     (inherit sbcl-cl-ana-boot0)
9154     (name "sbcl-cl-ana.makeres-macro")
9155     (inputs
9156      `(("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9157        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)))
9158     (arguments
9159      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9160        ((#:asd-file _ "") "makeres-macro/cl-ana.makeres-macro.asd")
9161        ((#:asd-system-name _ #f) "cl-ana.makeres-macro")))))
9162
9163 (define-public cl-ana.makeres-macro
9164   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-macro))
9165
9166 (define-public sbcl-cl-ana.makeres-block
9167   (package
9168     (inherit sbcl-cl-ana-boot0)
9169     (name "sbcl-cl-ana.makeres-block")
9170     (inputs
9171      `(("alexandria" ,sbcl-alexandria)
9172        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9173        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9174        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)))
9175     (arguments
9176      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9177        ((#:asd-file _ "") "makeres-block/cl-ana.makeres-block.asd")
9178        ((#:asd-system-name _ #f) "cl-ana.makeres-block")))))
9179
9180 (define-public cl-ana.makeres-block
9181   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-block))
9182
9183 (define-public sbcl-cl-ana.makeres-progress
9184   (package
9185     (inherit sbcl-cl-ana-boot0)
9186     (name "sbcl-cl-ana.makeres-progress")
9187     (inputs
9188      `(("alexandria" ,sbcl-alexandria)
9189        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9190        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)))
9191     (arguments
9192      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9193        ((#:asd-file _ "") "makeres-progress/cl-ana.makeres-progress.asd")
9194        ((#:asd-system-name _ #f) "cl-ana.makeres-progress")))))
9195
9196 (define-public cl-ana.makeres-progress
9197   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-progress))
9198
9199 (define-public sbcl-cl-ana.makeres-table
9200   (package
9201     (inherit sbcl-cl-ana-boot0)
9202     (name "sbcl-cl-ana.makeres-table")
9203     (inputs
9204      `(("cl-ana.csv-table" ,sbcl-cl-ana.csv-table)
9205        ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
9206        ("cl-ana.hdf-table" ,sbcl-cl-ana.hdf-table)
9207        ("cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
9208        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9209        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9210        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)
9211        ("cl-ana.makeres-macro" ,sbcl-cl-ana.makeres-macro)
9212        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
9213        ("cl-ana.ntuple-table" ,sbcl-cl-ana.ntuple-table)
9214        ("cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
9215        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
9216        ("cl-ana.table" ,sbcl-cl-ana.table)))
9217     (native-inputs
9218      `(("cl-fad" ,sbcl-cl-fad)))
9219     (arguments
9220      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9221        ((#:asd-file _ "") "makeres-table/cl-ana.makeres-table.asd")
9222        ((#:asd-system-name _ #f) "cl-ana.makeres-table")))))
9223
9224 (define-public cl-ana.makeres-table
9225   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-table))
9226
9227 (define-public sbcl-cl-ana.makeres-graphviz
9228   (package
9229     (inherit sbcl-cl-ana-boot0)
9230     (name "sbcl-cl-ana.makeres-graphviz")
9231     (inputs
9232      `(("cl-ana.makeres" ,sbcl-cl-ana.makeres)
9233        ("external-program" ,sbcl-external-program)))
9234     (arguments
9235      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9236        ((#:asd-file _ "") "makeres-graphviz/cl-ana.makeres-graphviz.asd")
9237        ((#:asd-system-name _ #f) "cl-ana.makeres-graphviz")))))
9238
9239 (define-public cl-ana.makeres-graphviz
9240   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-graphviz))
9241
9242 (define-public sbcl-cl-ana.makeres-branch
9243   (package
9244     (inherit sbcl-cl-ana-boot0)
9245     (name "sbcl-cl-ana.makeres-branch")
9246     (inputs
9247      `(("alexandria" ,sbcl-alexandria)
9248        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9249        ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
9250        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9251        ("cl-ana.map" ,sbcl-cl-ana.map)
9252        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)))
9253     (arguments
9254      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9255        ((#:asd-file _ "") "makeres-branch/cl-ana.makeres-branch.asd")
9256        ((#:asd-system-name _ #f) "cl-ana.makeres-branch")))))
9257
9258 (define-public cl-ana.makeres-branch
9259   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-branch))
9260
9261 (define-public sbcl-cl-ana.makeres-utils
9262   (package
9263     (inherit sbcl-cl-ana-boot0)
9264     (name "sbcl-cl-ana.makeres-utils")
9265     (inputs
9266      `(("alexandria" ,sbcl-alexandria)
9267        ("cl-ana.file-utils" ,sbcl-cl-ana.file-utils)
9268        ("cl-ana.fitting" ,sbcl-cl-ana.fitting)
9269        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
9270        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9271        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9272        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9273        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9274        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)
9275        ("cl-ana.map" ,sbcl-cl-ana.map)
9276        ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
9277        ("cl-ana.plotting" ,sbcl-cl-ana.plotting)
9278        ("cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
9279        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
9280        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
9281        ("cl-ana.table" ,sbcl-cl-ana.table)))
9282     (native-inputs
9283      `(("cl-fad" ,sbcl-cl-fad)))
9284     (arguments
9285      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9286        ((#:asd-file _ "") "makeres-utils/cl-ana.makeres-utils.asd")
9287        ((#:asd-system-name _ #f) "cl-ana.makeres-utils")))))
9288
9289 (define-public cl-ana.makeres-utils
9290   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-utils))
9291
9292 (define-public sbcl-cl-ana.statistical-learning
9293   (package
9294     (inherit sbcl-cl-ana-boot0)
9295     (name "sbcl-cl-ana.statistical-learning")
9296     (inputs
9297      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9298        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
9299        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9300        ("cl-ana.linear-algebra" ,sbcl-cl-ana.linear-algebra)
9301        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9302        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9303        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
9304        ("cl-ana.map" ,sbcl-cl-ana.map)
9305        ("cl-ana.statistics" ,sbcl-cl-ana.statistics)))
9306     (native-inputs
9307      `(("cl-fad" ,sbcl-cl-fad)))
9308     (arguments
9309      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9310        ((#:asd-file _ "")
9311         "statistical-learning/cl-ana.statistical-learning.asd")
9312        ((#:asd-system-name _ #f) "cl-ana.statistical-learning")))))
9313
9314 (define-public cl-ana.statistical-learning
9315   (sbcl-package->cl-source-package sbcl-cl-ana.statistical-learning))
9316
9317 (define-public sbcl-cl-ana
9318   (package
9319     (inherit sbcl-cl-ana-boot0)
9320     (name "sbcl-cl-ana")
9321     (inputs
9322      `(("cl-ana.binary-tree" ,sbcl-cl-ana.binary-tree)
9323        ("cl-ana.calculus" ,sbcl-cl-ana.calculus)
9324        ("cl-ana.clos-utils" ,sbcl-cl-ana.clos-utils)
9325        ("cl-ana.csv-table" ,sbcl-cl-ana.csv-table)
9326        ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
9327        ("cl-ana.file-utils" ,sbcl-cl-ana.file-utils)
9328        ("cl-ana.fitting" ,sbcl-cl-ana.fitting)
9329        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9330        ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
9331        ("cl-ana.hdf-table" ,sbcl-cl-ana.hdf-table)
9332        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9333        ("cl-ana.int-char" ,sbcl-cl-ana.int-char)
9334        ("cl-ana.linear-algebra" ,sbcl-cl-ana.linear-algebra)
9335        ("cl-ana.lorentz" ,sbcl-cl-ana.lorentz)
9336        ("cl-ana.map" ,sbcl-cl-ana.map)
9337        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)
9338        ("cl-ana.makeres-block" ,sbcl-cl-ana.makeres-block)
9339        ("cl-ana.makeres-branch" ,sbcl-cl-ana.makeres-branch)
9340        ("cl-ana.makeres-graphviz" ,sbcl-cl-ana.makeres-graphviz)
9341        ("cl-ana.makeres-macro" ,sbcl-cl-ana.makeres-macro)
9342        ("cl-ana.makeres-progress" ,sbcl-cl-ana.makeres-progress)
9343        ("cl-ana.makeres-table" ,sbcl-cl-ana.makeres-table)
9344        ("cl-ana.makeres-utils" ,sbcl-cl-ana.makeres-utils)
9345        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
9346        ("cl-ana.ntuple-table" ,sbcl-cl-ana.ntuple-table)
9347        ("cl-ana.package-utils" ,sbcl-cl-ana.package-utils)
9348        ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
9349        ("cl-ana.plotting" ,sbcl-cl-ana.plotting)
9350        ("cl-ana.quantity" ,sbcl-cl-ana.quantity)
9351        ("cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
9352        ("cl-ana.serialization" ,sbcl-cl-ana.serialization)
9353        ("cl-ana.statistics" ,sbcl-cl-ana.statistics)
9354        ("cl-ana.statistical-learning" ,sbcl-cl-ana.statistical-learning)
9355        ("cl-ana.table" ,sbcl-cl-ana.table)
9356        ("cl-ana.table-utils" ,sbcl-cl-ana.table-utils)
9357        ("cl-ana.table-viewing" ,sbcl-cl-ana.table-viewing)
9358        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
9359        ("libffi" ,libffi)))
9360     (native-inputs
9361      `(("cl-fad" ,sbcl-cl-fad)))
9362     (arguments
9363      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9364        ((#:asd-file _ "") "cl-ana.asd")
9365        ((#:asd-system-name _ #f) "cl-ana")))))
9366
9367 (define-public cl-ana
9368   (sbcl-package->cl-source-package sbcl-cl-ana))
9369
9370 (define-public sbcl-archive
9371   (let ((commit "631271c091ed02994bec3980cb288a2cf32c7cdc")
9372         (revision "1"))
9373     (package
9374       (name "sbcl-archive")
9375       (version (git-version "0.9" revision commit))
9376       (source (origin
9377                 (method git-fetch)
9378                 (uri (git-reference
9379                       (url "https://github.com/sharplispers/archive.git")
9380                       (commit commit)))
9381                 (file-name (git-file-name name version))
9382                 (sha256
9383                  (base32
9384                   "0pvsc9fmybx7rxd0kmzq4shi6hszdpwdc1sfy7jwyfxf8n3hnv4p"))))
9385       (build-system asdf-build-system/sbcl)
9386       (inputs
9387        `(("cl-fad" ,sbcl-cl-fad)
9388          ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
9389       (synopsis "Common Lisp library for tar and cpio archives")
9390       (description
9391        "This is a Common Lisp library to read and write disk-based file
9392 archives such as those generated by the tar and cpio programs on Unix.")
9393       (home-page "https://github.com/sharplispers/archive")
9394       (license license:bsd-3))))
9395
9396 (define-public cl-archive
9397   (sbcl-package->cl-source-package sbcl-archive))
9398
9399 (define-public ecl-archive
9400   (sbcl-package->ecl-package sbcl-archive))
9401
9402 (define-public sbcl-misc-extensions
9403   (let ((commit "101c05112bf2f1e1bbf527396822d2f50ca6327a")
9404         (revision "1"))
9405     (package
9406       (name "sbcl-misc-extensions")
9407       (version (git-version "3.3" revision commit))
9408       (source
9409        (origin
9410          (method git-fetch)
9411          (uri (git-reference
9412                (url "https://gitlab.common-lisp.net/misc-extensions/devel.git")
9413                (commit commit)))
9414          (file-name (git-file-name name version))
9415          (sha256
9416           (base32
9417            "0gz5f4p70qzilnxsnf5lih2n9m4wjcw8hlw4w8mpn9jyhyppyyv0"))))
9418       (build-system asdf-build-system/sbcl)
9419       (synopsis "Collection of small macros and extensions for Common Lisp")
9420       (description
9421        "This project is intended as a catchall for small, general-purpose
9422 extensions to Common Lisp.  It contains:
9423
9424 @itemize
9425 @item @code{new-let}, a macro that combines and generalizes @code{let},
9426 @code{let*} and @code{multiple-value-bind},
9427 @item @code{gmap}, an iteration macro that generalizes @code{map}.
9428 @end itemize\n")
9429       (home-page "https://common-lisp.net/project/misc-extensions/")
9430       (license license:public-domain))))
9431
9432 (define-public cl-misc-extensions
9433   (sbcl-package->cl-source-package sbcl-misc-extensions))
9434
9435 (define-public ecl-misc-extensions
9436   (sbcl-package->ecl-package sbcl-misc-extensions))
9437
9438 (define-public sbcl-mt19937
9439   (package
9440     (name "sbcl-mt19937")
9441     (version "1.1")
9442     (source
9443      (origin
9444        (method url-fetch)
9445        (uri (string-append "https://common-lisp.net/project/asdf-packaging/"
9446                            "mt19937-latest.tar.gz"))
9447        (sha256
9448         (base32
9449          "1iw636b0iw5ygkv02y8i41lh7xj0acglv0hg5agryn0zzi2nf1xv"))))
9450     (build-system asdf-build-system/sbcl)
9451     (synopsis "Mersenne Twister pseudo-random number generator")
9452     (description
9453      "MT19937 is a portable Mersenne Twister pseudo-random number generator
9454 for Common Lisp.")
9455     (home-page "https://www.cliki.net/mt19937")
9456     (license license:public-domain)))
9457
9458 (define-public cl-mt19937
9459   (sbcl-package->cl-source-package sbcl-mt19937))
9460
9461 (define-public ecl-mt19937
9462   (sbcl-package->ecl-package sbcl-mt19937))
9463
9464 (define-public sbcl-fset
9465   (let ((commit "6d2f9ded8934d2b42f2571a0ba5bda091037d852")
9466         (revision "1"))
9467     (package
9468       (name "sbcl-fset")
9469       (version (git-version "1.3.2" revision commit))
9470       (source
9471        (origin
9472          (method git-fetch)
9473          (uri (git-reference
9474                (url "https://github.com/slburson/fset")
9475                (commit commit)))
9476          (file-name (git-file-name name version))
9477          (sha256
9478           (base32
9479            "127acblwrbqicx47h6sgvknz1cqyfn8p4xkhkn1m7hxh8w5gk1zy"))
9480          (snippet '(begin
9481                      ;; Remove obsolete copy of system definition.
9482                      (delete-file "Code/fset.asd")
9483                      #t))))
9484       (build-system asdf-build-system/sbcl)
9485       (inputs
9486        `(("misc-extensions" ,sbcl-misc-extensions)
9487          ("mt19937" ,sbcl-mt19937)
9488          ("named-readtables" ,sbcl-named-readtables)))
9489       (synopsis "Functional set-theoretic collections library")
9490       (description
9491        "FSet is a functional set-theoretic collections library for Common Lisp.
9492 Functional means that all update operations return a new collection rather than
9493 modifying an existing one in place.  Set-theoretic means that collections may
9494 be nested arbitrarily with no additional programmer effort; for instance, sets
9495 may contain sets, maps may be keyed by sets, etc.")
9496       (home-page "https://common-lisp.net/project/fset/Site/index.html")
9497       (license license:llgpl))))
9498
9499 (define-public cl-fset
9500   (sbcl-package->cl-source-package sbcl-fset))
9501
9502 (define-public sbcl-cl-cont
9503   (let ((commit "fc1fa7e6eb64894fdca13e688e6015fad5290d2a")
9504         (revision "1"))
9505     (package
9506       (name "sbcl-cl-cont")
9507       (version (git-version "0.3.8" revision commit))
9508       (source
9509        (origin
9510          (method git-fetch)
9511          (uri (git-reference
9512                (url "https://gitlab.common-lisp.net/cl-cont/cl-cont.git")
9513                (commit commit)))
9514          (file-name (git-file-name name version))
9515          (sha256
9516           (base32
9517            "1zf8zvb0i6jm3hhfks4w74hibm6avgc6f9s1qwgjrn2bcik8lrvz"))))
9518       (build-system asdf-build-system/sbcl)
9519       (inputs
9520        `(("alexandria" ,sbcl-alexandria)
9521          ("closer-mop" ,sbcl-closer-mop)))
9522       (native-inputs
9523        `(("rt" ,sbcl-rt)))
9524       (synopsis "Delimited continuations for Common Lisp")
9525       (description
9526        "This is a library that implements delimited continuations by
9527 transforming Common Lisp code to continuation passing style.")
9528       (home-page "https://common-lisp.net/project/cl-cont/")
9529       (license license:llgpl))))
9530
9531 (define-public cl-cont
9532   (sbcl-package->cl-source-package sbcl-cl-cont))
9533
9534 (define-public ecl-cl-cont
9535   (sbcl-package->ecl-package sbcl-cl-cont))
9536
9537 (define-public sbcl-cl-coroutine
9538   (let ((commit "de098f8d5debd8b14ef6864b5bdcbbf5ddbcfd72")
9539         (revision "1"))
9540     (package
9541       (name "sbcl-cl-coroutine")
9542       (version (git-version "0.1" revision commit))
9543       (source
9544        (origin
9545          (method git-fetch)
9546          (uri (git-reference
9547                (url "https://github.com/takagi/cl-coroutine.git")
9548                (commit commit)))
9549          (file-name (git-file-name name version))
9550          (sha256
9551           (base32
9552            "1cqdhdjxffgfs116l1swjlsmcbly0xgcgrckvaajd566idj9yj4l"))))
9553       (build-system asdf-build-system/sbcl)
9554       (inputs
9555        `(("alexandria" ,sbcl-alexandria)
9556          ("cl-cont" ,sbcl-cl-cont)))
9557       (native-inputs
9558        `(("prove" ,sbcl-prove)))
9559       (arguments
9560        `(;; TODO: Fix the tests. They fail with:
9561          ;; "Component CL-COROUTINE-ASD::CL-COROUTINE-TEST not found"
9562          #:tests? #f
9563          #:phases
9564          (modify-phases %standard-phases
9565            (add-after 'unpack 'fix-tests
9566              (lambda _
9567                (substitute* "cl-coroutine-test.asd"
9568                  (("cl-test-more")
9569                   "prove"))
9570                #t)))))
9571       (synopsis "Coroutine library for Common Lisp")
9572       (description
9573        "This is a coroutine library for Common Lisp implemented using the
9574 continuations of the @code{cl-cont} library.")
9575       (home-page "https://github.com/takagi/cl-coroutine")
9576       (license license:llgpl))))
9577
9578 (define-public cl-coroutine
9579   (sbcl-package->cl-source-package sbcl-cl-coroutine))
9580
9581 (define-public ecl-cl-coroutine
9582   (sbcl-package->ecl-package sbcl-cl-coroutine))
9583
9584 (define-public sbcl-vom
9585   (let ((commit "1aeafeb5b74c53741b79497e0ef4acf85c92ff24")
9586         (revision "1"))
9587     (package
9588       (name "sbcl-vom")
9589       (version (git-version "0.1.4" revision commit))
9590       (source
9591        (origin
9592          (method git-fetch)
9593          (uri (git-reference
9594                (url "https://github.com/orthecreedence/vom.git")
9595                (commit commit)))
9596          (file-name (git-file-name name version))
9597          (sha256
9598           (base32
9599            "0536kppj76ax4lrxhv42npkfjsmx45km2g439vf9jmw3apinz9cy"))))
9600       (build-system asdf-build-system/sbcl)
9601       (synopsis "Tiny logging utility for Common Lisp")
9602       (description
9603        "Vom is a logging library for Common Lisp.  It's goal is to be useful
9604 and small.  It does not provide a lot of features as other loggers do, but
9605 has a small codebase that's easy to understand and use.")
9606       (home-page "https://github.com/orthecreedence/vom")
9607       (license license:expat))))
9608
9609 (define-public cl-vom
9610   (sbcl-package->cl-source-package sbcl-vom))
9611
9612 (define-public ecl-vom
9613   (sbcl-package->ecl-package sbcl-vom))
9614
9615 (define-public sbcl-cl-libuv
9616   (let ((commit "32100c023c518038d0670a103eaa4d50dd785d29")
9617         (revision "1"))
9618     (package
9619       (name "sbcl-cl-libuv")
9620       (version (git-version "0.1.6" revision commit))
9621       (source
9622        (origin
9623          (method git-fetch)
9624          (uri (git-reference
9625                (url "https://github.com/orthecreedence/cl-libuv.git")
9626                (commit commit)))
9627          (file-name (git-file-name name version))
9628          (sha256
9629           (base32
9630            "1kwix4si8a8hza34ab2k7whrh7z0yrmx39v2wc3qblv9m244jkh1"))))
9631       (build-system asdf-build-system/sbcl)
9632       (inputs
9633        `(("alexandria" ,sbcl-alexandria)
9634          ("cffi" ,sbcl-cffi)
9635          ("cffi-grovel" ,sbcl-cffi-grovel)
9636          ("libuv" ,libuv)))
9637       (arguments
9638        `(#:phases
9639          (modify-phases %standard-phases
9640            (add-after 'unpack 'fix-paths
9641              (lambda* (#:key inputs #:allow-other-keys)
9642                (substitute* "lib.lisp"
9643                  (("/usr/lib/libuv.so")
9644                   (string-append (assoc-ref inputs "libuv")
9645                                  "/lib/libuv.so")))
9646                #t))
9647            (add-after 'fix-paths 'fix-system-definition
9648              (lambda _
9649                (substitute* "cl-libuv.asd"
9650                  (("#:cffi #:alexandria")
9651                   "#:cffi #:cffi-grovel #:alexandria"))
9652                #t)))))
9653       (synopsis "Common Lisp bindings to libuv")
9654       (description
9655        "This library provides low-level libuv bindings for Common Lisp.")
9656       (home-page "https://github.com/orthecreedence/cl-libuv")
9657       (license license:expat))))
9658
9659 (define-public cl-libuv
9660   (sbcl-package->cl-source-package sbcl-cl-libuv))
9661
9662 (define-public ecl-cl-libuv
9663   (sbcl-package->ecl-package sbcl-cl-libuv))
9664
9665 (define-public sbcl-cl-async-base
9666   (let ((commit "f6423e44404a44434d803605e0d2e17199158e28")
9667         (revision "1"))
9668     (package
9669       (name "sbcl-cl-async-base")
9670       (version (git-version "0.6.1" revision commit))
9671       (source
9672        (origin
9673          (method git-fetch)
9674          (uri (git-reference
9675                (url "https://github.com/orthecreedence/cl-async.git")
9676                (commit commit)))
9677          (file-name (git-file-name name version))
9678          (sha256
9679           (base32
9680            "11xi9dxb8mjgwzrkj88i0xkgk26z9w9ddxzbv6xsvfc1d4x5cf4x"))))
9681       (build-system asdf-build-system/sbcl)
9682       (inputs
9683        `(("bordeaux-threads" ,sbcl-bordeaux-threads)
9684          ("cffi" ,sbcl-cffi)
9685          ("cl-libuv" ,sbcl-cl-libuv)))
9686       (arguments
9687        `(#:asd-file "cl-async.asd"))
9688       (synopsis "Base system for cl-async")
9689       (description
9690        "Cl-async is a library for general purpose, non-blocking programming in
9691 Common Lisp.  It uses the libuv library as backend.")
9692       (home-page "https://orthecreedence.github.io/cl-async/")
9693       (license license:expat))))
9694
9695 (define-public cl-async-base
9696   (sbcl-package->cl-source-package sbcl-cl-async-base))
9697
9698 (define-public ecl-cl-async-base
9699   (sbcl-package->ecl-package sbcl-cl-async-base))
9700
9701 (define-public sbcl-cl-async-util
9702   (package
9703     (inherit sbcl-cl-async-base)
9704     (name "sbcl-cl-async-util")
9705     (inputs
9706      `(("bordeaux-threads" ,sbcl-bordeaux-threads)
9707        ("cffi" ,sbcl-cffi)
9708        ("cl-async-base" ,sbcl-cl-async-base)
9709        ("cl-libuv" ,sbcl-cl-libuv)
9710        ("cl-ppcre" ,sbcl-cl-ppcre)
9711        ("fast-io" ,sbcl-fast-io)
9712        ("vom" ,sbcl-vom)))
9713     (synopsis "Internal utilities for cl-async")))
9714
9715 (define-public cl-async-util
9716   (sbcl-package->cl-source-package sbcl-cl-async-util))
9717
9718 (define-public ecl-cl-async-util
9719   (sbcl-package->ecl-package sbcl-cl-async-util))
9720
9721 (define-public sbcl-cl-async
9722   (package
9723     (inherit sbcl-cl-async-base)
9724     (name "sbcl-cl-async")
9725     (inputs
9726      `(("babel" ,sbcl-babel)
9727        ("cffi" ,sbcl-cffi)
9728        ("cl-async-base" ,sbcl-cl-async-base)
9729        ("cl-async-util" ,sbcl-cl-async-util)
9730        ("cl-libuv" ,sbcl-cl-libuv)
9731        ("cl-ppcre" ,sbcl-cl-ppcre)
9732        ("static-vectors" ,sbcl-static-vectors)
9733        ("trivial-features" ,sbcl-trivial-features)
9734        ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
9735     (synopsis "Asynchronous operations for Common Lisp")))
9736
9737 (define-public cl-async
9738   (sbcl-package->cl-source-package sbcl-cl-async))
9739
9740 (define-public ecl-cl-async
9741   (sbcl-package->ecl-package sbcl-cl-async))
9742
9743 (define-public sbcl-cl-async-repl
9744   (package
9745     (inherit sbcl-cl-async-base)
9746     (name "sbcl-cl-async-repl")
9747     (inputs
9748      `(("bordeaux-threads" ,sbcl-bordeaux-threads)
9749        ("cl-async" ,sbcl-cl-async)))
9750     (arguments
9751      (substitute-keyword-arguments (package-arguments sbcl-cl-async-base)
9752        ((#:asd-file _ "") "cl-async-repl.asd")))
9753     (synopsis "REPL integration for cl-async")))
9754
9755 (define-public cl-async-repl
9756   (sbcl-package->cl-source-package sbcl-cl-async-repl))
9757
9758 (define-public ecl-cl-async-repl
9759   (sbcl-package->ecl-package sbcl-cl-async-repl))
9760
9761 (define-public sbcl-cl-async-ssl
9762   (package
9763     (inherit sbcl-cl-async-base)
9764     (name "sbcl-cl-async-ssl")
9765     (inputs
9766      `(("cffi" ,sbcl-cffi)
9767        ("cl-async" ,sbcl-cl-async)
9768        ("openssl" ,openssl)
9769        ("vom" ,sbcl-vom)))
9770     (arguments
9771      (substitute-keyword-arguments (package-arguments sbcl-cl-async-base)
9772        ((#:asd-file _ "") "cl-async-ssl.asd")
9773        ((#:phases phases '%standard-phases)
9774         `(modify-phases ,phases
9775            (add-after 'unpack 'fix-paths
9776              (lambda* (#:key inputs #:allow-other-keys)
9777                (substitute* "src/ssl/package.lisp"
9778                  (("libcrypto\\.so")
9779                   (string-append (assoc-ref inputs "openssl")
9780                                  "/lib/libcrypto.so"))
9781                  (("libssl\\.so")
9782                   (string-append (assoc-ref inputs "openssl")
9783                                  "/lib/libssl.so")))
9784                #t))))))
9785     (synopsis "SSL wrapper around cl-async socket implementation")))
9786
9787 (define-public cl-async-ssl
9788   (sbcl-package->cl-source-package sbcl-cl-async-ssl))
9789
9790 (define-public ecl-cl-async-ssl
9791   (sbcl-package->ecl-package sbcl-cl-async-ssl))
9792
9793 (define-public sbcl-blackbird
9794   (let ((commit "d361f81c1411dec07f6c2dcb11c78f7aea9aaca8")
9795         (revision "1"))
9796     (package
9797       (name "sbcl-blackbird")
9798       (version (git-version "0.5.2" revision commit))
9799       (source
9800        (origin
9801          (method git-fetch)
9802          (uri (git-reference
9803                (url "https://github.com/orthecreedence/blackbird.git")
9804                (commit commit)))
9805          (file-name (git-file-name name version))
9806          (sha256
9807           (base32
9808            "0xfds5yaya64arzr7w1x38karyz11swzbhxx1afldpradj9dh19c"))))
9809       (build-system asdf-build-system/sbcl)
9810       (inputs
9811        `(("vom" ,sbcl-vom)))
9812       (native-inputs
9813        `(("cl-async" ,sbcl-cl-async)
9814          ("fiveam" ,sbcl-fiveam)))
9815       (synopsis "Promise implementation for Common Lisp")
9816       (description
9817        "This is a standalone promise implementation for Common Lisp.  It is
9818 the successor to the now-deprecated cl-async-future project.")
9819       (home-page "https://orthecreedence.github.io/blackbird/")
9820       (license license:expat))))
9821
9822 (define-public cl-blackbird
9823   (sbcl-package->cl-source-package sbcl-blackbird))
9824
9825 (define-public ecl-blackbird
9826   (sbcl-package->ecl-package sbcl-blackbird))
9827
9828 (define-public sbcl-cl-async-future
9829   (let ((commit "ee36c22a69a9516407458d2ed8b475f1fc473959")
9830         (revision "1"))
9831     (package
9832       (name "sbcl-cl-async-future")
9833       (version (git-version "0.4.4.1" revision commit))
9834       (source
9835        (origin
9836          (method git-fetch)
9837          (uri (git-reference
9838                (url "https://github.com/orthecreedence/cl-async-future.git")
9839                (commit commit)))
9840          (file-name (git-file-name name version))
9841          (sha256
9842           (base32
9843            "0z0sc7qlzzxk99f4l26zp6rai9kv0kj0f599sxai5s44p17zbbvh"))))
9844       (build-system asdf-build-system/sbcl)
9845       (inputs
9846        `(("blackbird" ,sbcl-blackbird)))
9847       (native-inputs
9848        `(("cl-async" ,sbcl-cl-async)
9849          ("eos" ,sbcl-eos)))
9850       (synopsis "Futures implementation for Common Lisp")
9851       (description
9852        "This is futures implementation for Common Lisp.  It plugs in nicely
9853 to cl-async.")
9854       (home-page "https://orthecreedence.github.io/cl-async/future")
9855       (license license:expat))))
9856
9857 (define-public cl-async-future
9858   (sbcl-package->cl-source-package sbcl-cl-async-future))
9859
9860 (define-public ecl-cl-async-future
9861   (sbcl-package->ecl-package sbcl-cl-async-future))
9862
9863 (define-public sbcl-green-threads
9864   (let ((commit "fff5ebecb441a37e5c511773716aafd84a3c5840")
9865         (revision "1"))
9866     (package
9867       (name "sbcl-green-threads")
9868       (version (git-version "0.3" revision commit))
9869       (source
9870        (origin
9871          (method git-fetch)
9872          (uri (git-reference
9873                (url "https://github.com/thezerobit/green-threads.git")
9874                (commit commit)))
9875          (file-name (git-file-name name version))
9876          (sha256
9877           (base32
9878            "1czw7nr0dwfps76h8hjvglk1wdh53yqbfbvv30whwbgqx33iippz"))))
9879       (build-system asdf-build-system/sbcl)
9880       (inputs
9881        `(("cl-async-future" ,sbcl-cl-async-future)
9882          ("cl-cont" ,sbcl-cl-cont)))
9883       (native-inputs
9884        `(("prove" ,sbcl-prove)))
9885       (arguments
9886        `(;; TODO: Fix the tests. They fail with:
9887          ;; "The function BLACKBIRD::PROMISE-VALUES is undefined"
9888          #:tests? #f
9889          #:phases
9890          (modify-phases %standard-phases
9891            (add-after 'unpack 'fix-tests
9892              (lambda _
9893                (substitute* "green-threads-test.asd"
9894                  (("cl-test-more")
9895                   "prove"))
9896                #t)))))
9897       (synopsis "Cooperative multitasking library for Common Lisp")
9898       (description
9899        "This library allows for cooperative multitasking with help of cl-cont
9900 for continuations.  It tries to mimic the API of bordeaux-threads as much as
9901 possible.")
9902       (home-page "https://github.com/thezerobit/green-threads")
9903       (license license:bsd-3))))
9904
9905 (define-public cl-green-threads
9906   (sbcl-package->cl-source-package sbcl-green-threads))
9907
9908 (define-public ecl-green-threads
9909   (sbcl-package->ecl-package sbcl-green-threads))
9910
9911 (define-public sbcl-cl-base32
9912   (let ((commit "8cdee06fab397f7b0a19583b57e7f0c98405be85")
9913         (revision "1"))
9914     (package
9915       (name "sbcl-cl-base32")
9916       (version (git-version "0.1" revision commit))
9917       (source
9918        (origin
9919          (method git-fetch)
9920          (uri (git-reference
9921                (url "https://github.com/hargettp/cl-base32.git")
9922                (commit commit)))
9923          (file-name (git-file-name name version))
9924          (sha256
9925           (base32 "17jrng8jb05d64ggyd11hp308c2fl5drvf9g175blgrkkl8l4mf8"))))
9926       (build-system asdf-build-system/sbcl)
9927       (native-inputs
9928        `(("lisp-unit" ,sbcl-lisp-unit)))
9929       (synopsis "Common Lisp library for base32 encoding and decoding")
9930       (description
9931        "This package provides functions for base32 encoding and decoding as
9932 defined in RFC4648.")
9933       (home-page "https://github.com/hargettp/cl-base32")
9934       (license license:expat))))
9935
9936 (define-public cl-base32
9937   (sbcl-package->cl-source-package sbcl-cl-base32))
9938
9939 (define-public ecl-cl-base32
9940   (sbcl-package->ecl-package sbcl-cl-base32))
9941
9942 (define-public sbcl-cl-z85
9943   (let ((commit "85b3951a9cfa2603acb6aee15567684f9a108098")
9944         (revision "1"))
9945     (package
9946       (name "sbcl-cl-z85")
9947       (version (git-version "1.0" revision commit))
9948       (source
9949        (origin
9950          (method git-fetch)
9951          (uri (git-reference
9952                (url "https://github.com/glv2/cl-z85.git")
9953                (commit commit)))
9954          (file-name (git-file-name name version))
9955          (sha256
9956           (base32 "0r27pidjaxbm7k1rr90nnajwl5xm2kp65g1fv0fva17lzy45z1mp"))))
9957       (build-system asdf-build-system/sbcl)
9958       (native-inputs
9959        `(("cl-octet-streams" ,sbcl-cl-octet-streams)
9960          ("fiveam" ,sbcl-fiveam)))
9961       (synopsis "Common Lisp library for Z85 encoding and decoding")
9962       (description
9963        "This package provides functions to encode or decode byte vectors or
9964 byte streams using the Z85 format, which is a base-85 encoding used by
9965 ZeroMQ.")
9966       (home-page "https://github.com/glv2/cl-z85")
9967       (license license:gpl3+))))
9968
9969 (define-public cl-z85
9970   (sbcl-package->cl-source-package sbcl-cl-z85))
9971
9972 (define-public ecl-cl-z85
9973   (sbcl-package->ecl-package sbcl-cl-z85))
9974
9975 (define-public sbcl-ltk
9976   (package
9977     (name "sbcl-ltk")
9978     (version "0.992")
9979     (source
9980      (origin
9981        (method git-fetch)
9982        (uri (git-reference
9983              (url "https://github.com/herth/ltk.git")
9984              (commit version)))
9985        (file-name (git-file-name name version))
9986        (sha256
9987         (base32 "13l2q4mskzilya9xh5wy2xvy30lwn104bd8wrq6ifds56r82iy3x"))))
9988     (build-system asdf-build-system/sbcl)
9989     (inputs
9990      `(("imagemagick" ,imagemagick)
9991        ("tk" ,tk)))
9992     (arguments
9993      `(#:asd-file "ltk/ltk.asd"
9994        #:tests? #f
9995        #:phases (modify-phases %standard-phases
9996                   (add-after 'unpack 'fix-paths
9997                     (lambda* (#:key inputs #:allow-other-keys)
9998                       (substitute* "ltk/ltk.lisp"
9999                         (("#-freebsd \"wish\"")
10000                          (string-append "#-freebsd \""
10001                                         (assoc-ref inputs "tk")
10002                                         "/bin/wish\""))
10003                         (("do-execute \"convert\"")
10004                          (string-append "do-execute \""
10005                                         (assoc-ref inputs "imagemagick")
10006                                         "/bin/convert\"")))
10007                       #t)))))
10008     (synopsis "Common Lisp bindings for the Tk GUI toolkit")
10009     (description
10010      "LTK is a Common Lisp binding for the Tk graphics toolkit.  It is written
10011 in pure Common Lisp and does not require any Tk knowledge for its usage.")
10012     (home-page "http://www.peter-herth.de/ltk/")
10013     (license license:llgpl)))
10014
10015 (define-public cl-ltk
10016   (sbcl-package->cl-source-package sbcl-ltk))
10017
10018 (define-public ecl-ltk
10019   (sbcl-package->ecl-package sbcl-ltk))
10020
10021 (define-public sbcl-ltk-mw
10022   (package
10023     (inherit sbcl-ltk)
10024     (name "sbcl-ltk-mw")
10025     (inputs
10026      `(("ltk" ,sbcl-ltk)))
10027     (arguments
10028      (substitute-keyword-arguments (package-arguments sbcl-ltk)
10029        ((#:asd-file _) "ltk/ltk-mw.asd")
10030        ((#:phases _) '%standard-phases)))
10031     (synopsis "Extra widgets for LTK")
10032     (description
10033      "This is a collection of higher-level widgets built on top of LTK.")))
10034
10035 (define-public cl-ltk-mw
10036   (sbcl-package->cl-source-package sbcl-ltk-mw))
10037
10038 (define-public ecl-ltk-mw
10039   (sbcl-package->ecl-package sbcl-ltk-mw))
10040
10041 (define-public sbcl-ltk-remote
10042   (package
10043     (inherit sbcl-ltk)
10044     (name "sbcl-ltk-remote")
10045     (inputs
10046      `(("ltk" ,sbcl-ltk)))
10047     (arguments
10048      (substitute-keyword-arguments (package-arguments sbcl-ltk)
10049        ((#:asd-file _) "ltk/ltk-remote.asd")
10050        ((#:phases _) '%standard-phases)))
10051     (synopsis "Remote GUI support for LTK")
10052     (description
10053      "This LTK extension allows the GUI to be displayed on a computer different
10054 from the one running the Lisp program by using a TCP connection.")))
10055
10056 (define-public cl-ltk-remote
10057   (sbcl-package->cl-source-package sbcl-ltk-remote))
10058
10059 (define-public sbcl-cl-lex
10060   (let ((commit "f2dbbe25ef553005fb402d9a6203180c3fa1093b")
10061         (revision "1"))
10062     (package
10063       (name "sbcl-cl-lex")
10064       (version (git-version "1.1.3" revision commit))
10065       (source
10066        (origin
10067          (method git-fetch)
10068          (uri (git-reference
10069                (url "https://github.com/djr7C4/cl-lex.git")
10070                (commit commit)))
10071          (file-name (git-file-name name version))
10072          (sha256
10073           (base32 "1kg50f76bfpfxcv4dfivq1n9a0xlsra2ajb0vd68lxwgbidgyc2y"))))
10074       (build-system asdf-build-system/sbcl)
10075       (inputs
10076        `(("cl-ppcre" ,sbcl-cl-ppcre)))
10077       (synopsis "Common Lisp macros for generating lexical analyzers")
10078       (description
10079        "This is a Common Lisp library providing a set of macros for generating
10080 lexical analyzers automatically.  The lexers generated using @code{cl-lex} can
10081 be used with @code{cl-yacc}.")
10082       (home-page "https://github.com/djr7C4/cl-lex")
10083       (license license:gpl3))))
10084
10085 (define-public cl-lex
10086   (sbcl-package->cl-source-package sbcl-cl-lex))
10087
10088 (define-public ecl-cl-lex
10089   (sbcl-package->ecl-package sbcl-cl-lex))
10090
10091 (define-public sbcl-clunit2
10092   (let ((commit "5e28343734eb9b7aee39306a614af92c1062d50b")
10093         (revision "1"))
10094     (package
10095       (name "sbcl-clunit2")
10096       (version (git-version "0.2.4" revision commit))
10097       (source
10098        (origin
10099          (method git-fetch)
10100          (uri (git-reference
10101                (url "https://notabug.org/cage/clunit2.git")
10102                (commit commit)))
10103          (file-name (git-file-name name version))
10104          (sha256
10105           (base32 "1ngiapfki6nm8a555mzhb5p7ch79i3w665za5bmb5j7q34fy80vw"))))
10106       (build-system asdf-build-system/sbcl)
10107       (synopsis "Unit testing framework for Common Lisp")
10108       (description
10109        "CLUnit is a Common Lisp unit testing framework.  It is designed to be
10110 easy to use so that you can quickly start testing.")
10111       (home-page "https://notabug.org/cage/clunit2")
10112       (license license:expat))))
10113
10114 (define-public cl-clunit2
10115   (sbcl-package->cl-source-package sbcl-clunit2))
10116
10117 (define-public ecl-clunit2
10118   (sbcl-package->ecl-package sbcl-clunit2))
10119
10120 (define-public sbcl-cl-colors2
10121   (let ((commit "795aedee593b095fecde574bd999b520dd03ed24")
10122         (revision "1"))
10123     (package
10124       (name "sbcl-cl-colors2")
10125       (version (git-version "0.2.1" revision commit))
10126       (source
10127        (origin
10128          (method git-fetch)
10129          (uri (git-reference
10130                (url "https://notabug.org/cage/cl-colors2.git")
10131                (commit commit)))
10132          (file-name (git-file-name name version))
10133          (sha256
10134           (base32 "0hlyf4h5chkjdp9armla5w4kw5acikk159sym7y8c4jbjp9x47ih"))))
10135       (build-system asdf-build-system/sbcl)
10136       (native-inputs
10137        `(("clunit2" ,sbcl-clunit2)))
10138       (inputs
10139        `(("alexandria" ,sbcl-alexandria)
10140          ("cl-ppcre" ,sbcl-cl-ppcre)))
10141       (synopsis "Color library for Common Lisp")
10142       (description
10143        "This is a very simple color library for Common Lisp, providing:
10144
10145 @itemize
10146 @item Types for representing colors in HSV and RGB spaces.
10147 @item Simple conversion functions between the above types (and also
10148 hexadecimal representation for RGB).
10149 @item Some predefined colors (currently X11 color names -- of course
10150 the library does not depend on X11).
10151 @end itemize\n")
10152       (home-page "https://notabug.org/cage/cl-colors2")
10153       (license license:boost1.0))))
10154
10155 (define-public cl-colors2
10156   (sbcl-package->cl-source-package sbcl-cl-colors2))
10157
10158 (define-public ecl-cl-colors2
10159   (sbcl-package->ecl-package sbcl-cl-colors2))
10160
10161 (define-public sbcl-cl-jpeg
10162   (let ((commit "ec557038128df6895fbfb743bfe8faf8ec2534af")
10163         (revision "1"))
10164     (package
10165       (name "sbcl-cl-jpeg")
10166       (version (git-version "2.8" revision commit))
10167       (source
10168        (origin
10169          (method git-fetch)
10170          (uri (git-reference
10171                (url "https://github.com/sharplispers/cl-jpeg.git")
10172                (commit commit)))
10173          (file-name (git-file-name name version))
10174          (sha256
10175           (base32 "1bkkiqz8fqldlj1wbmrccjsvxcwj98h6s4b6gslr3cg2wmdv5xmy"))))
10176       (build-system asdf-build-system/sbcl)
10177       (synopsis "JPEG image library for Common Lisp")
10178       (description
10179        "This is a baseline JPEG codec written in Common Lisp.  It can be used
10180 for reading and writing JPEG image files.")
10181       (home-page "https://github.com/sharplispers/cl-jpeg")
10182       (license license:bsd-3))))
10183
10184 (define-public cl-jpeg
10185   (sbcl-package->cl-source-package sbcl-cl-jpeg))
10186
10187 (define-public ecl-cl-jpeg
10188   (sbcl-package->ecl-package sbcl-cl-jpeg))
10189
10190 (define-public sbcl-nodgui
10191   (let ((commit "bc59ed9b787dfc9e68ae3bd7f7e8507c5c619212")
10192         (revision "1"))
10193     (package
10194       (name "sbcl-nodgui")
10195       (version (git-version "0.0.5" revision commit))
10196       (source
10197        (origin
10198          (method git-fetch)
10199          (uri (git-reference
10200                (url "https://notabug.org/cage/nodgui.git")
10201                (commit commit)))
10202          (file-name (git-file-name name version))
10203          (sha256
10204           (base32 "0xx0dk54d882i598ydnwmy7mnfk0b7vib3ddsgpqxhjck1rwq8l8"))))
10205       (build-system asdf-build-system/sbcl)
10206       (inputs
10207        `(("alexandria" ,sbcl-alexandria)
10208          ("bordeaux-threads" ,sbcl-bordeaux-threads)
10209          ("cl-colors2" ,sbcl-cl-colors2)
10210          ("cl-jpeg" ,sbcl-cl-jpeg)
10211          ("cl-lex" ,sbcl-cl-lex)
10212          ("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)
10213          ("cl-unicode" ,sbcl-cl-unicode)
10214          ("cl-yacc" ,sbcl-cl-yacc)
10215          ("clunit2" ,sbcl-clunit2)
10216          ("named-readtables" ,sbcl-named-readtables)
10217          ("parse-number" ,sbcl-parse-number)
10218          ("tk" ,tk)))
10219       (arguments
10220        `(#:phases (modify-phases %standard-phases
10221                     (add-after 'unpack 'fix-paths
10222                       (lambda* (#:key inputs #:allow-other-keys)
10223                         (substitute* "src/wish-communication.lisp"
10224                           (("#-freebsd \"wish\"")
10225                            (string-append "#-freebsd \""
10226                                           (assoc-ref inputs "tk")
10227                                           "/bin/wish\"")))
10228                         #t)))))
10229       (synopsis "Common Lisp bindings for the Tk GUI toolkit")
10230       (description
10231        "Nodgui (@emph{No Drama GUI}) is a Common Lisp binding for the Tk GUI
10232 toolkit.  It also provides a few additional widgets more than the standard Tk
10233 ones.")
10234       (home-page "https://www.autistici.org/interzona/nodgui.html")
10235       (license license:llgpl))))
10236
10237 (define-public cl-nodgui
10238   (sbcl-package->cl-source-package sbcl-nodgui))
10239
10240 (define-public ecl-nodgui
10241   (sbcl-package->ecl-package sbcl-nodgui))
10242
10243 (define-public sbcl-salza2
10244   (package
10245     (name "sbcl-salza2")
10246     (version "2.0.9")
10247     (source
10248      (origin
10249        (method git-fetch)
10250        (uri (git-reference
10251              (url "https://github.com/xach/salza2.git")
10252              (commit (string-append "release-" version))))
10253        (file-name (git-file-name name version))
10254        (sha256
10255         (base32 "0p38rj4gq7j5k807php7hrz7l2zyyfshv8i9yms7i8lkgg3433ki"))))
10256     (build-system asdf-build-system/sbcl)
10257     (synopsis "Common Lisp library for zlib, deflate and gzip compression")
10258     (description
10259      "Salza2 is a Common Lisp library for creating compressed data in the zlib,
10260 deflate, or gzip data formats, described in RFC 1950, RFC 1951, and RFC 1952,
10261 respectively.")
10262     (home-page "https://www.xach.com/lisp/salza2/")
10263     (license license:bsd-2)))
10264
10265 (define-public cl-salza2
10266   (sbcl-package->cl-source-package sbcl-salza2))
10267
10268 (define-public ecl-salza2
10269   (sbcl-package->ecl-package sbcl-salza2))
10270
10271 (define-public sbcl-png-read
10272   (let ((commit "ec29f38a689972b9f1373f13bbbcd6b05deada88")
10273         (revision "1"))
10274     (package
10275       (name "sbcl-png-read")
10276       (version (git-version "0.3.1" revision commit))
10277       (source
10278        (origin
10279          (method git-fetch)
10280          (uri (git-reference
10281                (url "https://github.com/Ramarren/png-read.git")
10282                (commit commit)))
10283          (file-name (git-file-name name version))
10284          (sha256
10285           (base32 "0vyczbcwskrygrf1hgrsnk0jil8skmvf1kiaalw5jps4fjrfdkw0"))))
10286       (build-system asdf-build-system/sbcl)
10287       (inputs
10288        `(("babel" ,sbcl-babel)
10289          ("chipz" ,sbcl-chipz)
10290          ("iterate" ,sbcl-iterate)))
10291       (synopsis "PNG decoder for Common Lisp")
10292       (description "This is a Common Lisp library for reading PNG images.")
10293       (home-page "https://github.com/Ramarren/png-read")
10294       (license license:bsd-3))))
10295
10296 (define-public cl-png-read
10297   (sbcl-package->cl-source-package sbcl-png-read))
10298
10299 (define-public ecl-png-read
10300   (sbcl-package->ecl-package sbcl-png-read))
10301
10302 (define-public sbcl-zpng
10303   (package
10304     (name "sbcl-zpng")
10305     (version "1.2.2")
10306     (source
10307      (origin
10308        (method git-fetch)
10309        (uri (git-reference
10310              (url "https://github.com/xach/zpng.git")
10311              (commit (string-append "release-" version))))
10312        (file-name (git-file-name name version))
10313        (sha256
10314         (base32 "0b3ag3jhl3z7kdls3ahdsdxsfhhw5qrizk769984f4wkxhb69rcm"))))
10315     (build-system asdf-build-system/sbcl)
10316     (inputs
10317      `(("salza2" ,sbcl-salza2)))
10318     (synopsis "PNG encoder for Common Lisp")
10319     (description "This is a Common Lisp library for creating PNG images.")
10320     (home-page "https://www.xach.com/lisp/zpng/")
10321     (license license:bsd-2)))
10322
10323 (define-public cl-zpng
10324   (sbcl-package->cl-source-package sbcl-zpng))
10325
10326 (define-public ecl-zpng
10327   (sbcl-package->ecl-package sbcl-zpng))
10328
10329 (define-public sbcl-cl-qrencode
10330   (package
10331     (name "sbcl-cl-qrencode")
10332     (version "0.1.2")
10333     (source
10334      (origin
10335        (method git-fetch)
10336        (uri (git-reference
10337              (url "https://github.com/jnjcc/cl-qrencode.git")
10338              (commit (string-append "v" version))))
10339        (file-name (git-file-name name version))
10340        (sha256
10341         (base32 "1l5k131dchbf6cj8a8xqa731790p01p3qa1kdy2wa9dawy3ymkxr"))))
10342     (build-system asdf-build-system/sbcl)
10343     (native-inputs
10344      `(("lisp-unit" ,sbcl-lisp-unit)))
10345     (inputs
10346      `(("zpng" ,sbcl-zpng)))
10347     (synopsis "QR code encoder for Common Lisp")
10348     (description
10349      "This Common Lisp library provides function to make QR codes and to save
10350 them as PNG files.")
10351     (home-page "https://github.com/jnjcc/cl-qrencode")
10352     (license license:gpl2+)))
10353
10354 (define-public cl-qrencode
10355   (sbcl-package->cl-source-package sbcl-cl-qrencode))
10356
10357 (define-public ecl-cl-qrencode
10358   (sbcl-package->ecl-package sbcl-cl-qrencode))
10359
10360 (define-public sbcl-hdf5-cffi
10361   (let ((commit "5b5c88f191e470e4fe96b462334e3ce0806eed5c")
10362         (revision "1"))
10363     (package
10364       (name "sbcl-hdf5-cffi")
10365       (version (git-version "1.8.18" revision commit))
10366       (source
10367        (origin
10368          (method git-fetch)
10369          (uri (git-reference
10370                (url "https://github.com/hdfgroup/hdf5-cffi.git")
10371                (commit commit)))
10372          (file-name (git-file-name name version))
10373          (sha256
10374           (base32
10375            "0vda3075423xz83qky998lpac5b04dwfv7bwgh9jq8cs5v0zrxjf"))))
10376       (build-system asdf-build-system/sbcl)
10377       (synopsis "Common Lisp bindings for the HDF5 library")
10378       (description
10379        "@code{hdf5-cffi} is a CFFI wrapper for the HDF5 library.")
10380       (home-page "https://github.com/hdfgroup/hdf5-cffi")
10381       (license (license:non-copyleft
10382                 (string-append "https://github.com/HDFGroup/hdf5-cffi/raw/"
10383                                commit
10384                                "/LICENSE")))
10385       (inputs
10386        `(("cffi" ,sbcl-cffi)
10387          ("cffi-grovel" ,sbcl-cffi-grovel)
10388          ("hdf5" ,hdf5-1.10)))
10389       (native-inputs
10390        `(("fiveam" ,sbcl-fiveam)))
10391       (arguments
10392        `(#:asd-system-name "hdf5-cffi"
10393          #:asd-file "hdf5-cffi.asd"
10394          #:test-asd-file "hdf5-cffi.test.asd"
10395          ;; Tests depend on hdf5-cffi.examples.asd in addition to hdf5-cffi.asd,
10396          ;; I don't know if there is a way to tell asdf-build-system to load
10397          ;; an additional system first, so tests are disabled.
10398          #:tests? #f
10399          #:phases
10400          (modify-phases %standard-phases
10401            (add-after 'unpack 'fix-paths
10402              (lambda* (#:key inputs #:allow-other-keys)
10403                (substitute* "src/library.lisp"
10404                  (("libhdf5.so")
10405                   (string-append
10406                    (assoc-ref inputs "hdf5")
10407                    "/lib/libhdf5.so")))))
10408            (add-after 'unpack 'fix-dependencies
10409              (lambda* (#:key inputs #:allow-other-keys)
10410                (substitute* "hdf5-cffi.asd"
10411                  ((":depends-on \\(:cffi\\)")
10412                   ":depends-on (:cffi :cffi-grovel)"))
10413                (substitute* "hdf5-cffi.test.asd"
10414                  ((":depends-on \\(:cffi :hdf5-cffi")
10415                   ":depends-on (:cffi :cffi-grovel :hdf5-cffi"))))))))))
10416
10417 (define-public cl-hdf5-cffi
10418   (sbcl-package->cl-source-package sbcl-hdf5-cffi))
10419
10420 (define-public ecl-hdf5-cffi
10421   (sbcl-package->ecl-package sbcl-hdf5-cffi))
10422
10423 (define-public sbcl-cl-randist
10424   (package
10425     (name "sbcl-cl-randist")
10426     (version "0.4.2")
10427     (source
10428      (origin
10429        (method git-fetch)
10430        (uri (git-reference
10431              (url "https://github.com/lvaruzza/cl-randist.git")
10432              (commit "f088a54b540a7adefab7c04094a6103f9edda3d0")))
10433        (file-name (git-file-name name version))
10434        (sha256
10435         (base32
10436          "0l8hyd6nbxb7f50vyxz3rbbm7kgr1fnadc40jywy4xj5vi5kpj5g"))))
10437     (build-system asdf-build-system/sbcl)
10438     (synopsis "Random distributions for Common Lisp")
10439     (description
10440      "Manual translation from C to Common Lisp of some random number
10441 generation functions from the GSL library.")
10442     (home-page "https://github.com/lvaruzza/cl-randist")
10443     (license license:bsd-2)
10444     (arguments
10445      `(#:asd-system-name "cl-randist"
10446        #:asd-file "cl-randist.asd"
10447        #:tests? #f))))
10448
10449 (define-public cl-randist
10450   (sbcl-package->cl-source-package sbcl-cl-randist))
10451
10452 (define-public ecl-cl-randist
10453   (sbcl-package->ecl-package sbcl-cl-randist))
10454
10455 (define-public sbcl-float-features
10456   (package
10457     (name "sbcl-float-features")
10458     (version "1.0.0")
10459     (source
10460      (origin
10461        (method git-fetch)
10462        (uri (git-reference
10463              (url "https://github.com/Shinmera/float-features.git")
10464              (commit "d3ef60181635b0849aa28cfc238053b7ca4644b0")))
10465        (file-name (git-file-name name version))
10466        (sha256
10467         (base32
10468          "0yj419k7n59x6rh3grwr6frgwwyria2il6f7wxpfazm8cskv4lzr"))))
10469     (build-system asdf-build-system/sbcl)
10470     (synopsis "Common Lisp IEEE float portability library")
10471     (description
10472      "Portability library for IEEE float features that are not
10473 covered by the Common Lisp standard.")
10474     (home-page "https://github.com/Shinmera/float-features")
10475     (license license:zlib)
10476     (inputs
10477      `(("documentation-utils" ,sbcl-documentation-utils)))
10478     (arguments
10479      `(#:asd-system-name "float-features"
10480        #:asd-file "float-features.asd"
10481        #:tests? #f))))
10482
10483 (define-public cl-float-features
10484   (sbcl-package->cl-source-package sbcl-float-features))
10485
10486 (define-public ecl-float-features
10487   (sbcl-package->ecl-package sbcl-float-features))
10488
10489 (define-public sbcl-function-cache
10490   (package
10491     (name "sbcl-function-cache")
10492     (version "1.0.3")
10493     (source
10494      (origin
10495        (method git-fetch)
10496        (uri (git-reference
10497              (url "https://github.com/AccelerationNet/function-cache.git")
10498              (commit "6a5ada401e57da2c8abf046f582029926e61fce8")))
10499        (file-name (git-file-name name version))
10500        (sha256
10501         (base32
10502          "000vmd3f5rx5hs9nvphfric0gkzaadns31c6mxaslpv0k7pkrmc6"))))
10503     (build-system asdf-build-system/sbcl)
10504     (synopsis "Function caching / memoization library for Common Lisp")
10505     (description
10506      "A common lisp library that provides extensible function result
10507 caching based on arguments (an expanded form of memoization).")
10508     (home-page "https://github.com/AccelerationNet/function-cache")
10509     (license
10510      (license:non-copyleft
10511       "https://github.com/AccelerationNet/function-cache/blob/master/README.md"))
10512     (inputs
10513      `(("alexandria" ,sbcl-alexandria)
10514        ("cl-interpol" ,sbcl-cl-interpol)
10515        ("iterate" ,sbcl-iterate)
10516        ("symbol-munger" ,sbcl-symbol-munger)
10517        ("closer-mop" ,sbcl-closer-mop)))
10518     (arguments
10519      `(#:asd-system-name "function-cache"
10520        #:asd-file "function-cache.asd"
10521        #:tests? #f))))
10522
10523 (define-public cl-function-cache
10524   (sbcl-package->cl-source-package sbcl-function-cache))
10525
10526 (define-public ecl-function-cache
10527   (sbcl-package->ecl-package sbcl-function-cache))
10528
10529 (define-public sbcl-type-r
10530   (let ((commit "83c89e38f2f7a7b16f1012777ecaf878cfa6a267")
10531         (revision "1"))
10532     (package
10533       (name "sbcl-type-r")
10534       (version (git-version "0.0.0" revision commit))
10535       (source
10536        (origin
10537          (method git-fetch)
10538          (uri (git-reference
10539                (url "https://github.com/guicho271828/type-r.git")
10540                (commit commit)))
10541          (file-name (git-file-name name version))
10542          (sha256
10543           (base32
10544            "1arsxc2539rg8vbrdirz4xxj1b06mc6g6rqndz7a02g127qvk2sm"))))
10545       (build-system asdf-build-system/sbcl)
10546       (synopsis "Parser interface for Common Lisp built-in compound types")
10547       (description
10548        "Collections of accessor functions and patterns to access
10549 the elements in compound type specifier, e.g. @code{dimensions} in
10550 @code{(array element-type dimensions)}")
10551       (home-page "https://github.com/guicho271828/type-r")
10552       (license license:lgpl3+)
10553       (inputs
10554        `(("trivia" ,sbcl-trivia)
10555          ("alexandria" ,sbcl-alexandria)))
10556       (native-inputs
10557        `(("fiveam" ,sbcl-fiveam)))
10558       (arguments
10559        `(#:asd-system-name "type-r"
10560          #:asd-file "type-r.asd"
10561          #:test-asd-file "type-r.test.asd")))))
10562
10563 (define-public cl-type-r
10564   (sbcl-package->cl-source-package sbcl-type-r))
10565
10566 (define-public sbcl-trivialib-type-unify
10567   (let ((commit "62492ebf04db567dcf435ae84c50b7b8202ecf99")
10568         (revision "1"))
10569     (package
10570       (name "sbcl-trivialib-type-unify")
10571       (version (git-version "0.1" revision commit))
10572       (source
10573        (origin
10574          (method git-fetch)
10575          (uri (git-reference
10576                (url "https://github.com/guicho271828/trivialib.type-unify.git")
10577                (commit commit)))
10578          (file-name (git-file-name name version))
10579          (sha256
10580           (base32
10581            "1bkyfzbwv75p50zp8n1n9rh2r29pw3vgz91gmn2gzzkyq3khj1vh"))))
10582       (build-system asdf-build-system/sbcl)
10583       (synopsis "Common Lisp type unification")
10584       (description
10585        "Unifies a parametrized type specifier against an actual type specifier.
10586 Importantly, it handles complicated array-subtypes and number-related types
10587 correctly.")
10588       (home-page "https://github.com/guicho271828/trivialib.type-unify")
10589       (license license:lgpl3+)
10590       (inputs
10591        `(("alexandria" ,sbcl-alexandria)
10592          ("trivia" ,sbcl-trivia)
10593          ("introspect-environment" ,sbcl-introspect-environment)
10594          ("type-r" ,sbcl-type-r)))
10595       (native-inputs
10596        `(("fiveam" ,sbcl-fiveam)))
10597       (arguments
10598        `(#:asd-system-name "trivialib.type-unify"
10599          #:asd-file "trivialib.type-unify.asd"
10600          #:test-asd-file "trivialib.type-unify.test.asd")))))
10601
10602 (define-public cl-trivialib-type-unify
10603   (sbcl-package->cl-source-package sbcl-trivialib-type-unify))
10604
10605 (define-public sbcl-specialized-function
10606   (let ((commit "b96b6afaf8358bf91cc0703e62a5a4ee20d2b7bc")
10607         (revision "1"))
10608     (package
10609       (name "sbcl-specialized-function")
10610       (version (git-version "0.0.0" revision commit))
10611       (source
10612        (origin
10613          (method git-fetch)
10614          (uri (git-reference
10615                (url "https://github.com/numcl/specialized-function.git")
10616                (commit commit)))
10617          (file-name (git-file-name name version))
10618          (sha256
10619           (base32
10620            "12j45ff0n26578vmfbhb9mfbdchw4wy023k0m2ppgl9s0z4bhjaj"))))
10621       (build-system asdf-build-system/sbcl)
10622       (synopsis "Julia-like dispatch for Common Lisp")
10623       (description
10624        "This library is part of NUMCL.  It provides a macro
10625 @code{SPECIALIZED} that performs a Julia-like dispatch on the arguments,
10626 lazily compiling a type-specific version of the function from the same
10627 code.  The main target of this macro is speed.")
10628       (home-page "https://github.com/numcl/specialized-function")
10629       (license license:lgpl3+)
10630       (inputs
10631        `(("trivia" ,sbcl-trivia)
10632          ("alexandria" ,sbcl-alexandria)
10633          ("iterate" ,sbcl-iterate)
10634          ("lisp-namespace" ,sbcl-lisp-namespace)
10635          ("type-r" ,sbcl-type-r)
10636          ("trivial-cltl2" ,sbcl-trivial-cltl2)))
10637       (native-inputs
10638        `(("fiveam" ,sbcl-fiveam)))
10639       (arguments
10640        `(#:asd-system-name "specialized-function"
10641          #:asd-file "specialized-function.asd"
10642          #:test-asd-file "specialized-function.test.asd")))))
10643
10644 (define-public cl-specialized-function
10645   (sbcl-package->cl-source-package sbcl-specialized-function))
10646
10647 (define-public sbcl-constantfold
10648   (let ((commit "0ff1d97a3fbcb89264f6a2af6ce62b73e7b421f4")
10649         (revision "1"))
10650     (package
10651       (name "sbcl-constantfold")
10652       (version (git-version "0.1" revision commit))
10653       (source
10654        (origin
10655          (method git-fetch)
10656          (uri (git-reference
10657                (url "https://github.com/numcl/constantfold.git")
10658                (commit commit)))
10659          (file-name (git-file-name name version))
10660          (sha256
10661           (base32
10662            "153h0569z6bff1qbad0bdssplwwny75l7ilqwcfqfdvzsxf9jh06"))))
10663       (build-system asdf-build-system/sbcl)
10664       (synopsis "Support library for numcl")
10665       (description
10666        "Support library for numcl.  Registers a function as an
10667 additional form that is considered as a candidate for a constant.")
10668       (home-page "https://github.com/numcl/constantfold")
10669       (license license:lgpl3+)
10670       (inputs
10671        `(("trivia" ,sbcl-trivia)
10672          ("alexandria" ,sbcl-alexandria)
10673          ("iterate" ,sbcl-iterate)
10674          ("lisp-namespace" ,sbcl-lisp-namespace)))
10675       (native-inputs
10676        `(("fiveam" ,sbcl-fiveam)))
10677       (arguments
10678        `(#:asd-system-name "constantfold"
10679          #:asd-file "constantfold.asd"
10680          #:test-asd-file "constantfold.test.asd")))))
10681
10682 (define-public cl-constantfold
10683   (sbcl-package->cl-source-package sbcl-constantfold))
10684
10685 (define-public sbcl-gtype
10686   (let ((commit "42275e3606242ae91e9c8dfa30c18ced50a35b66")
10687         (revision "1"))
10688     (package
10689       (name "sbcl-gtype")
10690       (version (git-version "0.1" revision commit))
10691       (source
10692        (origin
10693          (method git-fetch)
10694          (uri (git-reference
10695                (url "https://github.com/numcl/gtype.git")
10696                (commit commit)))
10697          (file-name (git-file-name name version))
10698          (sha256
10699           (base32
10700            "1f56dba998v945jcxhha391557n6md1ql25b7icfwwfivhmlaa9b"))))
10701       (build-system asdf-build-system/sbcl)
10702       (synopsis "C++/Julia-like parametric types in Common Lisp")
10703       (description
10704        "Support library for numcl that provides Julia-like runtime parametric
10705 type correctness in Common Lisp.  It is based on CLtL2 extensions.")
10706       (home-page "https://github.com/numcl/gtype")
10707       (license license:lgpl3+)
10708       (inputs
10709        `(("trivialib.type-unify" ,sbcl-trivialib-type-unify)
10710          ("trivial-cltl2" ,sbcl-trivial-cltl2)
10711          ("trivia" ,sbcl-trivia)
10712          ("alexandria" ,sbcl-alexandria)
10713          ("iterate" ,sbcl-iterate)
10714          ("type-r" ,sbcl-type-r)))
10715       (native-inputs
10716        `(("fiveam" ,sbcl-fiveam)))
10717       (arguments
10718        `(#:asd-system-name "gtype"
10719          #:asd-file "gtype.asd"
10720          #:test-asd-file "gtype.test.asd")))))
10721
10722 (define-public cl-gtype
10723   (sbcl-package->cl-source-package sbcl-gtype))
10724
10725 (define-public sbcl-numcl
10726   (let ((commit "1cf7dfa59f763a24a501092870e9c5ee745d0c17")
10727         (revision "1"))
10728     (package
10729       (name "sbcl-numcl")
10730       (version (git-version "0.1.0" revision commit))
10731       (source
10732        (origin
10733          (method git-fetch)
10734          (uri (git-reference
10735                (url "https://github.com/numcl/numcl.git")
10736                (commit commit)))
10737          (file-name (git-file-name name version))
10738          (sha256
10739           (base32
10740            "0i3jby9hf4ii7blivgyza80g0vmjfhk8537i5i7kqqk0i5sdnym2"))))
10741       (build-system asdf-build-system/sbcl)
10742       (synopsis "Numpy clone in Common Lisp")
10743       (description
10744        "This is a Numpy clone in Common Lisp.  At the moment the
10745 library is written in pure Common Lisp, focusing more on correctness
10746 and usefulness, not speed.  Track the progress at
10747 @url{https://github.com/numcl/numcl/projects/1}.")
10748       (home-page "https://github.com/numcl/numcl")
10749       (license license:lgpl3+)
10750       (inputs
10751        `(("trivia" ,sbcl-trivia)
10752          ("alexandria" ,sbcl-alexandria)
10753          ("iterate" ,sbcl-iterate)
10754          ("lisp-namespace" ,sbcl-lisp-namespace)
10755          ("type-r" ,sbcl-type-r)
10756          ("constantfold" ,sbcl-constantfold)
10757          ("cl-randist" ,sbcl-cl-randist)
10758          ("float-features" ,sbcl-float-features)
10759          ("function-cache" ,sbcl-function-cache)
10760          ("specialized-function" ,sbcl-specialized-function)
10761          ("gtype" ,sbcl-gtype)))
10762       (native-inputs
10763        `(("fiveam" ,sbcl-fiveam)))
10764       (arguments
10765        `(#:asd-system-name "numcl"
10766          #:asd-file "numcl.asd"
10767          #:test-asd-file "numcl.test.asd")))))
10768
10769 (define-public cl-numcl
10770   (sbcl-package->cl-source-package sbcl-numcl))
10771
10772 (define-public sbcl-pzmq
10773   (let ((commit "7c7390eedc469d033c72dc497984d1536ee75826")
10774         (revision "1"))
10775     (package
10776       (name "sbcl-pzmq")
10777       (version (git-version "0.0.0" revision commit))
10778       (source
10779        (origin
10780          (method git-fetch)
10781          (uri (git-reference
10782                (url "https://github.com/orivej/pzmq.git")
10783                (commit commit)))
10784          (file-name (git-file-name name version))
10785          (sha256
10786           (base32 "0gmwzf7h90wa7v4wnk49g0hv2mdalljpwhyigxcb967wzv8lqci9"))))
10787       (build-system asdf-build-system/sbcl)
10788       (native-inputs
10789        `(("bordeaux-threads" ,sbcl-bordeaux-threads)
10790          ("fiveam" ,sbcl-fiveam)
10791          ("let-plus" ,sbcl-let-plus)))
10792       (inputs
10793        `(("cffi" ,sbcl-cffi)
10794          ("cffi-grovel" ,sbcl-cffi-grovel)
10795          ("zeromq" ,zeromq)))
10796       (arguments
10797        `(#:phases (modify-phases %standard-phases
10798                     (add-after 'unpack 'fix-paths
10799                       (lambda* (#:key inputs #:allow-other-keys)
10800                         (substitute* "c-api.lisp"
10801                           (("\"libzmq")
10802                            (string-append "\""
10803                                           (assoc-ref inputs "zeromq")
10804                                           "/lib/libzmq")))
10805                         #t)))))
10806       (synopsis "Common Lisp bindings for the ZeroMQ library")
10807       (description "This Common Lisp library provides bindings for the ZeroMQ
10808 lightweight messaging kernel.")
10809       (home-page "https://github.com/orivej/pzmq")
10810       (license license:unlicense))))
10811
10812 (define-public cl-pzmq
10813   (sbcl-package->cl-source-package sbcl-pzmq))
10814
10815 (define-public ecl-pzmq
10816   (sbcl-package->ecl-package sbcl-pzmq))
10817
10818 (define-public sbcl-clss
10819   (let ((revision "1")
10820         (commit "2a8e8615ab55870d4ca01928f3ed3bbeb4e75c8d"))
10821     (package
10822       (name "sbcl-clss")
10823       (version (git-version "0.3.1" revision commit))
10824       (source
10825        (origin
10826          (method git-fetch)
10827          (uri
10828           (git-reference
10829            (url "https://github.com/Shinmera/clss.git")
10830            (commit commit)))
10831          (sha256
10832           (base32 "0la4dbcda78x29szanylccrsljqrn9d1mhh569sqkyp44ni5fv91"))
10833          (file-name (git-file-name name version))))
10834       (inputs
10835        `(("array-utils" ,sbcl-array-utils)
10836          ("plump" ,sbcl-plump)))
10837       (build-system asdf-build-system/sbcl)
10838       (synopsis "DOM tree searching engine based on CSS selectors")
10839       (description "CLSS is a DOM traversal engine based on CSS
10840 selectors.  It makes use of the Plump-DOM and is used by lQuery.")
10841       (home-page "https://github.com/Shinmera/clss")
10842       (license license:zlib))))
10843
10844 (define-public cl-clss
10845   (sbcl-package->cl-source-package sbcl-clss))
10846
10847 (define-public ecl-clss
10848   (sbcl-package->ecl-package sbcl-clss))
10849
10850 (define-public sbcl-lquery
10851   (let ((revision "1")
10852         (commit "8048111c6b83956daa632e7a3ffbd8c9c203bd8d"))
10853     (package
10854       (name "sbcl-lquery")
10855       (version (git-version "3.2.1" revision commit))
10856       (source
10857        (origin
10858          (method git-fetch)
10859          (uri
10860           (git-reference
10861            (url "https://github.com/Shinmera/lquery.git")
10862            (commit commit)))
10863          (sha256
10864           (base32 "0520mcpxc2d6fdm8z61arpgd2z38kan7cf06qs373n5r64rakz6w"))
10865          (file-name (git-file-name name version))))
10866       (native-inputs
10867        `(("fiveam" ,sbcl-fiveam)))
10868       (inputs
10869        `(("array-utils" ,sbcl-array-utils)
10870          ("form-fiddle" ,sbcl-form-fiddle)
10871          ("plump" ,sbcl-plump)
10872          ("clss" ,sbcl-clss)))
10873       (build-system asdf-build-system/sbcl)
10874       (synopsis "Library to allow jQuery-like HTML/DOM manipulation")
10875       (description "@code{lQuery} is a DOM manipulation library written in
10876 Common Lisp, inspired by and based on the jQuery syntax and
10877 functions.  It uses Plump and CLSS as DOM and selector engines.  The
10878 main idea behind lQuery is to provide a simple interface for crawling
10879 and modifying HTML sites, as well as to allow for an alternative
10880 approach to templating.")
10881       (home-page "https://github.com/Shinmera/lquery")
10882       (license license:zlib))))
10883
10884 (define-public cl-lquery
10885   (sbcl-package->cl-source-package sbcl-lquery))
10886
10887 (define-public ecl-lquery
10888   (sbcl-package->ecl-package sbcl-lquery))
10889
10890 (define-public sbcl-cl-mysql
10891   (let ((commit "ab56c279c1815aec6ca0bfe85164ff7e85cfb6f9")
10892         (revision "1"))
10893     (package
10894       (name "sbcl-cl-mysql")
10895       (version (git-version "0.1" revision commit))
10896       (source
10897        (origin
10898          (method git-fetch)
10899          (uri (git-reference
10900                (url "https://github.com/hackinghat/cl-mysql.git")
10901                (commit commit)))
10902          (file-name (git-file-name name version))
10903          (sha256
10904           (base32 "0dg5ynx2ww94d0qfwrdrm7plkn43h64hs4iiq9mj2s1s4ixnp3lr"))))
10905       (build-system asdf-build-system/sbcl)
10906       (native-inputs
10907        `(("stefil" ,sbcl-stefil)))
10908       (inputs
10909        `(("cffi" ,sbcl-cffi)
10910          ("mariadb-lib" ,mariadb "lib")))
10911       (arguments
10912        `(#:tests? #f ; TODO: Tests require a running server
10913          #:phases
10914          (modify-phases %standard-phases
10915            (add-after 'unpack 'fix-paths
10916              (lambda* (#:key inputs #:allow-other-keys)
10917                (substitute* "system.lisp"
10918                  (("libmysqlclient_r" all)
10919                   (string-append (assoc-ref inputs "mariadb-lib")
10920                                  "/lib/"
10921                                  all)))
10922                #t)))))
10923       (synopsis "Common Lisp wrapper for MySQL")
10924       (description
10925        "@code{cl-mysql} is a Common Lisp implementation of a MySQL wrapper.")
10926       (home-page "http://www.hackinghat.com/index.php/cl-mysql")
10927       (license license:expat))))
10928
10929 (define-public cl-mysql
10930   (sbcl-package->cl-source-package sbcl-cl-mysql))
10931
10932 (define-public sbcl-simple-date
10933   (let ((commit "74469b25bbda990ec9b77e0d0eccdba0cd7e721a")
10934         (revision "1"))
10935     (package
10936       (name "sbcl-simple-date")
10937       (version (git-version "1.19" revision commit))
10938       (source
10939        (origin
10940          (method git-fetch)
10941          (uri (git-reference
10942                (url "https://github.com/marijnh/Postmodern.git")
10943                (commit commit)))
10944          (file-name (git-file-name name version))
10945          (sha256
10946           (base32 "0im7ymnyxjhn2w74jfg76k5gpr0gl33n31akx33hl28722ljd0hd"))))
10947       (build-system asdf-build-system/sbcl)
10948       (native-inputs
10949        `(("fiveam" ,sbcl-fiveam)))
10950       (synopsis "Basic date and time objects for Common Lisp")
10951       (description
10952        "@code{simple-date} is a very basic implementation of date and time
10953 objects, used to support storing and retrieving time-related SQL types.")
10954       (home-page "https://marijnhaverbeke.nl/postmodern/")
10955       (license license:zlib))))
10956
10957 (define-public cl-simple-date
10958   (sbcl-package->cl-source-package sbcl-simple-date))
10959
10960 (define-public ecl-simple-date
10961   (sbcl-package->ecl-package sbcl-simple-date))
10962
10963 (define-public sbcl-cl-postgres
10964   (package
10965     (inherit sbcl-simple-date)
10966     (name "sbcl-cl-postgres")
10967     (native-inputs
10968      `(("fiveam" ,sbcl-fiveam)
10969        ("simple-date" ,sbcl-simple-date)))
10970     (inputs
10971      `(("md5" ,sbcl-md5)
10972        ("split-sequence" ,sbcl-split-sequence)
10973        ("usocket" ,sbcl-usocket)))
10974     (arguments
10975      `(#:tests? #f)) ; TODO: Break simple-date/postgres-glue circular dependency
10976     (synopsis "Common Lisp interface for PostgreSQL")
10977     (description
10978      "@code{cl-postgres} is a low-level library used for interfacing with
10979 a PostgreSQL server over a socket.")))
10980
10981 (define-public cl-postgres
10982   (sbcl-package->cl-source-package sbcl-cl-postgres))
10983
10984 (define-public sbcl-simple-date-postgres-glue
10985   (package
10986     (inherit sbcl-simple-date)
10987     (name "sbcl-simple-date-postgres-glue")
10988     (inputs
10989      `(("cl-postgres" ,sbcl-cl-postgres)
10990        ("simple-date" ,sbcl-simple-date)))
10991     (arguments
10992      `(#:asd-file "simple-date.asd"
10993        #:asd-system-name "simple-date/postgres-glue"))))
10994
10995 (define-public cl-simple-date-postgres-glue
10996   (sbcl-package->cl-source-package sbcl-simple-date-postgres-glue))
10997
10998 (define-public sbcl-s-sql
10999   (package
11000     (inherit sbcl-simple-date)
11001     (name "sbcl-s-sql")
11002     (inputs
11003      `(("alexandria" ,sbcl-alexandria)
11004        ("cl-postgres" ,sbcl-cl-postgres)))
11005     (arguments
11006      `(#:tests? #f)) ; TODO: Break postmodern circular dependency
11007     (synopsis "Lispy DSL for SQL")
11008     (description
11009      "@code{s-sql} is a Common Lisp library that can be used to compile
11010 s-expressions to strings of SQL code, escaping any Lisp values inside, and
11011 doing as much as possible of the work at compile time.")))
11012
11013 (define-public cl-s-sql
11014   (sbcl-package->cl-source-package sbcl-s-sql))
11015
11016 (define-public sbcl-postmodern
11017   (package
11018     (inherit sbcl-simple-date)
11019     (name "sbcl-postmodern")
11020     (native-inputs
11021      `(("fiveam" ,sbcl-fiveam)
11022        ("simple-date" ,sbcl-simple-date)
11023        ("simple-date-postgres-glue" ,sbcl-simple-date-postgres-glue)))
11024     (inputs
11025      `(("alexandria" ,sbcl-alexandria)
11026        ("bordeaux-threads" ,sbcl-bordeaux-threads)
11027        ("cl-postgres" ,sbcl-cl-postgres)
11028        ("closer-mop" ,sbcl-closer-mop)
11029        ("global-vars" ,sbcl-global-vars)
11030        ("s-sql" ,sbcl-s-sql)
11031        ("split-sequence" ,sbcl-split-sequence)))
11032     (arguments
11033      ;; TODO: Fix missing dependency errors for simple-date/postgres-glue,
11034      ;; cl-postgres/tests and s-sql/tests.
11035      `(#:tests? #f))
11036     (synopsis "Common Lisp library for interacting with PostgreSQL")
11037     (description
11038      "@code{postmodern} is a Common Lisp library for interacting with
11039 PostgreSQL databases.  It provides the following features:
11040
11041 @itemize
11042 @item Efficient communication with the database server without need for
11043 foreign libraries.
11044 @item Support for UTF-8 on Unicode-aware Lisp implementations.
11045 @item A syntax for mixing SQL and Lisp code.
11046 @item Convenient support for prepared statements and stored procedures.
11047 @item A metaclass for simple database-access objects.
11048 @end itemize\n")))
11049
11050 (define-public cl-postmodern
11051   (sbcl-package->cl-source-package sbcl-postmodern))
11052
11053 (define-public sbcl-dbi
11054   (package
11055     (name "sbcl-dbi")
11056     (version "0.9.4")
11057     (source
11058      (origin
11059        (method git-fetch)
11060        (uri (git-reference
11061              (url "https://github.com/fukamachi/cl-dbi.git")
11062              (commit version)))
11063        (file-name (git-file-name name version))
11064        (sha256
11065         (base32 "0m1fsravfaizamdak84adh3jxc4j91maqnrb4m08bfbmb04cdqhs"))))
11066     (build-system asdf-build-system/sbcl)
11067     (inputs
11068      `(("bordeaux-threads" ,sbcl-bordeaux-threads)
11069        ("closer-mop" ,sbcl-closer-mop)
11070        ("split-sequence" ,sbcl-split-sequence)))
11071     (arguments
11072      `(#:tests? #f)) ; TODO: Break circular dependency with dbd-*
11073     (synopsis "Database independent interface for Common Lisp")
11074     (description
11075      "@code{dbi} is a Common Lisp library providing a database independent
11076 interface for MySQL, PostgreSQL and SQLite.")
11077     (home-page "https://github.com/fukamachi/cl-dbi")
11078     (license license:llgpl)))
11079
11080 (define-public cl-dbi
11081   (sbcl-package->cl-source-package sbcl-dbi))
11082
11083 (define-public sbcl-dbd-mysql
11084   (package
11085    (inherit sbcl-dbi)
11086    (name "sbcl-dbd-mysql")
11087    (inputs
11088     `(("cl-mysql" ,sbcl-cl-mysql)
11089       ("dbi" ,sbcl-dbi)))
11090    (synopsis "Database driver for MySQL")))
11091
11092 (define-public cl-dbd-mysql
11093   (sbcl-package->cl-source-package sbcl-dbd-mysql))
11094
11095 (define-public sbcl-dbd-postgres
11096   (package
11097    (inherit sbcl-dbi)
11098    (name "sbcl-dbd-postgres")
11099    (inputs
11100     `(("cl-postgres" ,sbcl-cl-postgres)
11101       ("dbi" ,sbcl-dbi)
11102       ("trivial-garbage" ,sbcl-trivial-garbage)))
11103    (synopsis "Database driver for PostgreSQL")))
11104
11105 (define-public cl-dbd-postgres
11106   (sbcl-package->cl-source-package sbcl-dbd-postgres))
11107
11108 (define-public sbcl-dbd-sqlite3
11109   (package
11110    (inherit sbcl-dbi)
11111    (name "sbcl-dbd-sqlite3")
11112    (inputs
11113     `(("cl-sqlite" ,sbcl-cl-sqlite)
11114       ("dbi" ,sbcl-dbi)
11115       ("trivial-garbage" ,sbcl-trivial-garbage)))
11116    (synopsis "Database driver for SQLite3")))
11117
11118 (define-public cl-dbd-sqlite3
11119   (sbcl-package->cl-source-package sbcl-dbd-sqlite3))
11120
11121 (define-public sbcl-uffi
11122   (package
11123     (name "sbcl-uffi")
11124     (version "2.1.2")
11125     (source
11126      (origin
11127        (method git-fetch)
11128        (uri (git-reference
11129              (url "http://git.kpe.io/uffi.git")
11130              (commit (string-append "v" version))))
11131        (file-name (git-file-name name version))
11132        (sha256
11133         (base32 "1hqszvz0a3wk4s9faa83sc3vjxcb5rxmjclyr17yzwg55z733kry"))))
11134     (build-system asdf-build-system/sbcl)
11135     (arguments
11136      `(#:tests? #f ; TODO: Fix use of deprecated ASDF functions
11137        #:phases
11138        (modify-phases %standard-phases
11139          (add-after 'unpack 'fix-permissions
11140            (lambda _
11141              (make-file-writable "doc/html.tar.gz")
11142              #t)))))
11143     (synopsis "Universal foreign function library for Common Lisp")
11144     (description
11145      "UFFI provides a universal foreign function interface (FFI)
11146  for Common Lisp.")
11147     (home-page "http://quickdocs.org/uffi/")
11148     (license license:llgpl)))
11149
11150 (define-public cl-uffi
11151   (package
11152     (inherit (sbcl-package->cl-source-package sbcl-uffi))
11153     (arguments
11154      `(#:phases
11155        ;; asdf-build-system/source has its own phases and does not inherit
11156        ;; from asdf-build-system/sbcl phases.
11157        (modify-phases %standard-phases/source
11158          (add-after 'unpack 'fix-permissions
11159            (lambda _
11160              (make-file-writable "doc/html.tar.gz")
11161              #t)))))))
11162
11163 (define-public sbcl-clsql
11164   (package
11165     (name "sbcl-clsql")
11166     (version "6.7.0")
11167     (source
11168      (origin
11169        (method git-fetch)
11170        (uri (git-reference
11171              (url "http://git.kpe.io/clsql.git")
11172              (commit (string-append "v" version))))
11173        (file-name (git-file-name name version))
11174        (sha256
11175         (base32 "1v1k3s5bsy3lgd9gk459bzpb1r0kdjda25s29samxw4gsgf1fqvp"))
11176        (snippet
11177         '(begin
11178            ;; Remove precompiled libraries.
11179            (delete-file "db-mysql/clsql_mysql.dll")
11180            (delete-file "uffi/clsql_uffi.dll")
11181            (delete-file "uffi/clsql_uffi.lib")
11182            #t))))
11183     (build-system asdf-build-system/sbcl)
11184     (native-inputs
11185      `(("cffi-uffi-compat" ,sbcl-cffi-uffi-compat)
11186        ("rt" ,sbcl-rt)
11187        ("uffi" ,sbcl-uffi)))
11188     (arguments
11189      `(#:phases
11190        (modify-phases %standard-phases
11191          (add-after 'unpack 'fix-permissions
11192            (lambda _
11193              (make-file-writable "doc/html.tar.gz")
11194              #t))
11195          (add-after 'unpack 'fix-tests
11196            (lambda _
11197              (substitute* "clsql.asd"
11198                (("clsql-tests :force t")
11199                 "clsql-tests"))
11200              #t)))))
11201     (synopsis "Common Lisp SQL Interface library")
11202     (description
11203      "@code{clsql} is a Common Lisp interface to SQL RDBMS based on the
11204 Xanalys CommonSQL interface for Lispworks.  It provides low-level database
11205 interfaces as well as a functional and an object oriented interface.")
11206     (home-page "http://clsql.kpe.io/")
11207     (license license:llgpl)))
11208
11209 (define-public cl-clsql
11210   (package
11211     (inherit (sbcl-package->cl-source-package sbcl-clsql))
11212     (native-inputs
11213      `(("rt" ,cl-rt)))
11214     (inputs
11215      `(("mysql" ,mysql)
11216        ("postgresql" ,postgresql)
11217        ("sqlite" ,sqlite)
11218        ("zlib" ,zlib)))
11219     (propagated-inputs
11220      `(("cl-postgres" ,cl-postgres)
11221        ("cffi-uffi-compat" ,cl-cffi-uffi-compat)
11222        ("md5" ,cl-md5)
11223        ("uffi" ,cl-uffi)))
11224     (arguments
11225      `(#:phases
11226        ;; asdf-build-system/source has its own phases and does not inherit
11227        ;; from asdf-build-system/sbcl phases.
11228        (modify-phases %standard-phases/source
11229          (add-after 'unpack 'fix-permissions
11230            (lambda _
11231              (make-file-writable "doc/html.tar.gz")
11232              #t)))))))
11233
11234 (define-public sbcl-clsql-uffi
11235   (package
11236     (inherit sbcl-clsql)
11237     (name "sbcl-clsql-uffi")
11238     (inputs
11239      `(("cffi-uffi-compat" ,sbcl-cffi-uffi-compat)
11240        ("clsql" ,sbcl-clsql)
11241        ("uffi" ,sbcl-uffi)))
11242     (synopsis "UFFI helper functions for Common Lisp SQL interface library")))
11243
11244 (define-public sbcl-clsql-sqlite3
11245   (package
11246     (inherit sbcl-clsql)
11247     (name "sbcl-clsql-sqlite3")
11248     (inputs
11249      `(("clsql" ,sbcl-clsql)
11250        ("clsql-uffi" ,sbcl-clsql-uffi)
11251        ("sqlite" ,sqlite)))
11252     (arguments
11253      (substitute-keyword-arguments (package-arguments sbcl-clsql)
11254        ((#:phases phases '%standard-phases)
11255         `(modify-phases ,phases
11256            (add-after 'unpack 'fix-paths
11257              (lambda* (#:key inputs #:allow-other-keys)
11258                (substitute* "db-sqlite3/sqlite3-loader.lisp"
11259                  (("libsqlite3")
11260                   (string-append (assoc-ref inputs "sqlite")
11261                                  "/lib/libsqlite3")))
11262                #t))))))
11263     (synopsis "SQLite3 driver for Common Lisp SQL interface library")))
11264
11265 (define-public sbcl-clsql-postgresql
11266   (package
11267     (inherit sbcl-clsql)
11268     (name "sbcl-clsql-postgresql")
11269     (inputs
11270      `(("clsql" ,sbcl-clsql)
11271        ("clsql-uffi" ,sbcl-clsql-uffi)
11272        ("postgresql" ,postgresql)))
11273     (arguments
11274      (substitute-keyword-arguments (package-arguments sbcl-clsql)
11275        ((#:phases phases '%standard-phases)
11276         `(modify-phases ,phases
11277            (add-after 'unpack 'fix-paths
11278              (lambda* (#:key inputs #:allow-other-keys)
11279                (substitute* "db-postgresql/postgresql-loader.lisp"
11280                  (("libpq")
11281                   (string-append (assoc-ref inputs "postgresql")
11282                                  "/lib/libpq")))
11283                #t))))))
11284     (synopsis "PostgreSQL driver for Common Lisp SQL interface library")))
11285
11286 (define-public sbcl-clsql-postgresql-socket3
11287   (package
11288     (inherit sbcl-clsql)
11289     (name "sbcl-clsql-postgresql-socket3")
11290     (inputs
11291      `(("cl-postgres" ,sbcl-cl-postgres)
11292        ("clsql" ,sbcl-clsql)
11293        ("md5" ,sbcl-md5)))
11294     (arguments
11295      (substitute-keyword-arguments (package-arguments sbcl-clsql)
11296        ((#:phases phases '%standard-phases)
11297         `(modify-phases ,phases
11298            (add-after 'create-asd-file 'fix-asd-file
11299              (lambda* (#:key outputs #:allow-other-keys)
11300                (let* ((out (assoc-ref outputs "out"))
11301                       (lib (string-append out "/lib/" (%lisp-type)))
11302                       (asd (string-append lib "/clsql-postgresql-socket3.asd")))
11303                  (substitute* asd
11304                    (("CLSQL-POSTGRESQL-SOCKET-SYSTEM::")
11305                     "")))
11306                #t))))))
11307     (synopsis "PostgreSQL driver for Common Lisp SQL interface library")))
11308
11309 (define-public sbcl-clsql-mysql
11310   (package
11311     (inherit sbcl-clsql)
11312     (name "sbcl-clsql-mysql")
11313     (inputs
11314      `(("mysql" ,mysql)
11315        ("sbcl-clsql" ,sbcl-clsql)
11316        ("sbcl-clsql-uffi" ,sbcl-clsql-uffi)
11317        ("zlib" ,zlib)))
11318     (arguments
11319      (substitute-keyword-arguments (package-arguments sbcl-clsql)
11320        ((#:phases phases '%standard-phases)
11321         `(modify-phases ,phases
11322            (add-after 'unpack 'fix-paths
11323              (lambda* (#:key inputs outputs #:allow-other-keys)
11324                (let ((lib (string-append "#p\""
11325                                          (assoc-ref outputs "out")
11326                                          "/lib/\"")))
11327                  (substitute* "clsql-mysql.asd"
11328                    (("#p\"/usr/lib/clsql/clsql_mysql\\.so\"")
11329                     lib))
11330                  (substitute* "db-mysql/mysql-loader.lisp"
11331                    (("libmysqlclient" all)
11332                     (string-append (assoc-ref inputs "mysql") "/lib/" all))
11333                    (("clsql-mysql-system::\\*library-file-dir\\*")
11334                     lib)))
11335                #t))
11336            (add-before 'build 'build-helper-library
11337              (lambda* (#:key inputs outputs #:allow-other-keys)
11338                (let* ((mysql (assoc-ref inputs "mysql"))
11339                       (inc-dir (string-append mysql "/include/mysql"))
11340                       (lib-dir (string-append mysql "/lib"))
11341                       (shared-lib-dir (string-append (assoc-ref outputs "out")
11342                                                      "/lib"))
11343                       (shared-lib (string-append shared-lib-dir
11344                                                  "/clsql_mysql.so")))
11345                  (mkdir-p shared-lib-dir)
11346                  (invoke "gcc" "-fPIC" "-shared"
11347                          "-I" inc-dir
11348                          "db-mysql/clsql_mysql.c"
11349                          "-Wl,-soname=clsql_mysql"
11350                          "-L" lib-dir "-lmysqlclient" "-lz"
11351                          "-o" shared-lib)
11352                  #t)))))))
11353     (synopsis "MySQL driver for Common Lisp SQL interface library")))
11354
11355 (define-public sbcl-sycamore
11356   (let ((commit "fd2820fec165ad514493426dea209728f64e6d18"))
11357     (package
11358       (name "sbcl-sycamore")
11359       (version "0.0.20120604")
11360       (source
11361        (origin
11362          (method git-fetch)
11363          (uri (git-reference
11364                (url "https://github.com/ndantam/sycamore/")
11365                (commit commit)))
11366          (file-name (git-file-name name version))
11367          (sha256
11368           (base32 "00bv1aj89q5vldmq92zp2364jq312zjq2mbd3iyz1s2b4widzhl7"))))
11369       (build-system asdf-build-system/sbcl)
11370       (arguments
11371        `(#:asd-file "src/sycamore.asd"))
11372       (inputs
11373        `(("alexandria" ,sbcl-alexandria)
11374          ("cl-ppcre" ,sbcl-cl-ppcre)))
11375       (synopsis "Purely functional data structure library in Common Lisp")
11376       (description
11377        "Sycamore is a fast, purely functional data structure library in Common Lisp.
11378 If features:
11379
11380 @itemize
11381 @item Fast, purely functional weight-balanced binary trees.
11382 @item Leaf nodes are simple-vectors, greatly reducing tree height.
11383 @item Interfaces for tree Sets and Maps (dictionaries).
11384 @item Ropes.
11385 @item Purely functional pairing heaps.
11386 @item Purely functional amortized queue.
11387 @end itemize\n")
11388       (home-page "http://ndantam.github.io/sycamore/")
11389       (license license:bsd-3))))
11390
11391 (define-public cl-sycamore
11392   (sbcl-package->cl-source-package sbcl-sycamore))
11393
11394 (define-public sbcl-trivial-package-local-nicknames
11395   (package
11396     (name "sbcl-trivial-package-local-nicknames")
11397     (version "0.2")
11398     (home-page "https://github.com/phoe/trivial-package-local-nicknames")
11399     (source
11400      (origin
11401        (method git-fetch)
11402        (uri (git-reference
11403              (url home-page)
11404              (commit "16b7ad4c2b120f50da65154191f468ea5598460e")))
11405        (file-name (git-file-name name version))
11406        (sha256
11407         (base32 "18qc27xkjzdcqrilpk3pm7djldwq5rm3ggd5h9cr8hqcd54i2fqg"))))
11408     (build-system asdf-build-system/sbcl)
11409     (synopsis "Common Lisp compatibility library for package local nicknames")
11410     (description
11411      "This library is a portable compatibility layer around package local nicknames (PLN).
11412 This was done so there is a portability library for the PLN API not included
11413 in DEFPACKAGE.")
11414     (license license:unlicense)))
11415
11416 (define-public cl-trivial-package-local-nicknames
11417   (sbcl-package->cl-source-package sbcl-trivial-package-local-nicknames))
11418
11419 (define-public sbcl-enchant
11420   (let ((commit "6af162a7bf10541cbcfcfa6513894900329713fa"))
11421     (package
11422       (name "sbcl-enchant")
11423       (version (git-version "0.0.0" "1" commit))
11424       (home-page "https://github.com/tlikonen/cl-enchant")
11425       (source
11426        (origin
11427          (method git-fetch)
11428          (uri (git-reference
11429                (url home-page)
11430                (commit commit)))
11431          (file-name (git-file-name name version))
11432          (sha256
11433           (base32 "19yh5ihirzi1d8xqy1cjqipzd6ly3245cfxa5s9xx496rryz0s01"))))
11434       (build-system asdf-build-system/sbcl)
11435       (inputs
11436        `(("enchant" ,enchant)
11437          ("cffi" ,sbcl-cffi)))
11438       (arguments
11439        `(#:phases
11440          (modify-phases %standard-phases
11441            (add-after 'unpack 'fix-paths
11442              (lambda* (#:key inputs #:allow-other-keys)
11443                (substitute* "load-enchant.lisp"
11444                  (("libenchant")
11445                   (string-append
11446                    (assoc-ref inputs "enchant") "/lib/libenchant-2"))))))))
11447       (synopsis "Common Lisp interface for the Enchant spell-checker library")
11448       (description
11449        "Enchant is a Common Lisp interface for the Enchant spell-checker
11450 library.  The Enchant library is a generic spell-checker library which uses
11451 other spell-checkers transparently as back-end.  The library supports the
11452 multiple checkers, including Aspell and Hunspell.")
11453       (license license:public-domain))))
11454
11455 (define-public cl-enchant
11456   (sbcl-package->cl-source-package sbcl-enchant))
11457
11458 (define-public sbcl-cl-change-case
11459   (let ((commit "5ceff2a5f8bd845b6cb510c6364176b27a238fd3"))
11460     (package
11461       (name "sbcl-cl-change-case")
11462       (version (git-version "0.1.0" "1" commit))
11463       (home-page "https://github.com/rudolfochrist/cl-change-case")
11464       (source
11465        (origin
11466          (method git-fetch)
11467          (uri (git-reference
11468                (url home-page)
11469                (commit commit)))
11470          (file-name (git-file-name name version))
11471          (sha256
11472           (base32 "1afyglglk9z3yg8gylcl301bl2r8vq3sllyznzj9s5xi5gs6qyf2"))))
11473       (build-system asdf-build-system/sbcl)
11474       (inputs
11475        `(("cl-ppcre" ,sbcl-cl-ppcre)
11476          ("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)))
11477       (native-inputs
11478        `(("fiveam" ,sbcl-fiveam)))
11479       (arguments
11480        '(;; FIXME: Test pass but phase fails with 'Component
11481          ;; "cl-change-case-test" not found, required by'.
11482          #:tests? #f
11483          #:test-asd-file "cl-change-case-test.asd"))
11484       (synopsis "Convert Common Lisp strings between camelCase, PascalCase and more")
11485       (description
11486        "@code{cl-change-case} is library to convert strings between camelCase,
11487 PascalCase, snake_case, param-case, CONSTANT_CASE and more.")
11488       (license license:llgpl))))
11489
11490 (define-public cl-change-case
11491   (sbcl-package->cl-source-package sbcl-cl-change-case))
11492
11493 (define-public sbcl-moptilities
11494   (let ((commit "a436f16b357c96b82397ec018ea469574c10dd41"))
11495     (package
11496       (name "sbcl-moptilities")
11497       (version (git-version "0.3.13" "1" commit))
11498       (home-page "https://github.com/gwkkwg/moptilities/")
11499       (source
11500        (origin
11501          (method git-fetch)
11502          (uri (git-reference
11503                (url home-page)
11504                (commit commit)))
11505          (file-name (git-file-name name version))
11506          (sha256
11507           (base32 "1q12bqjbj47lx98yim1kfnnhgfhkl80102fkgp9pdqxg0fp6g5fc"))))
11508       (build-system asdf-build-system/sbcl)
11509       (inputs
11510        `(("closer-mop" ,sbcl-closer-mop)))
11511       (native-inputs
11512        `(("lift" ,sbcl-lift)))
11513       (synopsis "Compatibility layer for Common Lisp MOP implementation differences")
11514       (description
11515        "MOP utilities provide a common interface between Lisps and make the
11516 MOP easier to use.")
11517       (license license:expat))))
11518
11519 (define-public cl-moptilities
11520   (sbcl-package->cl-source-package sbcl-moptilities))
11521
11522 (define-public sbcl-osicat
11523   (let ((commit "de0c18a367eedc857e1902a7319828af072a0d97"))
11524     (package
11525       (name "sbcl-osicat")
11526       (version (git-version "0.7.0" "1" commit))
11527       (home-page "http://www.common-lisp.net/project/osicat/")
11528       (source
11529        (origin
11530          (method git-fetch)
11531          (uri (git-reference
11532                (url "https://github.com/osicat/osicat")
11533                (commit commit)))
11534          (file-name (git-file-name name version))
11535          (sha256
11536           (base32 "15viw5pi5sa7qq9b4n2rr3dj2jkqr180rh9z1lh8w3rgl42i2adc"))))
11537       (build-system asdf-build-system/sbcl)
11538       (arguments
11539        `(#:phases
11540          (modify-phases %standard-phases
11541            ;; The cleanup phase moves files around but we need to keep the
11542            ;; directory structure for the grovel-generated library.
11543            (replace 'cleanup
11544              (lambda* (#:key outputs #:allow-other-keys)
11545                (let* ((out (assoc-ref outputs "out"))
11546                       (lib (string-append out "/lib/sbcl/")))
11547                  (delete-file-recursively (string-append lib "src"))
11548                  (delete-file-recursively (string-append lib "tests"))
11549                  (for-each delete-file
11550                            (filter (lambda (file)
11551                                      (not (member (basename file) '("libosicat.so"))))
11552                                    (find-files (string-append lib "posix") ".*"))))
11553                #t)))))
11554       (inputs
11555        `(("alexandria" ,sbcl-alexandria)
11556          ("cffi" ,sbcl-cffi)
11557          ("trivial-features" ,sbcl-trivial-features)))
11558       (native-inputs
11559        `(("cffi-grovel" ,sbcl-cffi-grovel)
11560          ("rt" ,sbcl-rt)))
11561       (synopsis "Operating system interface for Common Lisp")
11562       (description
11563        "Osicat is a lightweight operating system interface for Common Lisp on
11564 Unix-platforms.  It is not a POSIX-style API, but rather a simple lispy
11565 accompaniment to the standard ANSI facilities.")
11566       (license license:expat))))
11567
11568 (define-public cl-osicat
11569   (sbcl-package->cl-source-package sbcl-osicat))