gnu/packages/lisp-xyz.scm

   1 ;;; GNU Guix --- Functional package management for GNU
   2 ;;; Copyright © 2014 John Darrington <jmd@gnu.org>
   3 ;;; Copyright © 2015 Taylan Ulrich Bayırlı/Kammer <taylanbayirli@gmail.com>
   4 ;;; Copyright © 2015 Mark H Weaver <mhw@netris.org>
   5 ;;; Copyright © 2016 Federico Beffa <beffa@fbengineering.ch>
   6 ;;; Copyright © 2016, 2017 ng0 <ng0@n0.is>
   7 ;;; Copyright © 2016, 2017 Andy Patterson <ajpatter@uwaterloo.ca>
   8 ;;; Copyright © 2017, 2019, 2020 Ricardo Wurmus <rekado@elephly.net>
   9 ;;; Copyright © 2017, 2018, 2019 Efraim Flashner <efraim@flashner.co.il>
  10 ;;; Copyright © 2017, 2019 Tobias Geerinckx-Rice <me@tobias.gr>
  11 ;;; Copyright © 2018 Benjamin Slade <slade@jnanam.net>
  12 ;;; Copyright © 2018 Alex Vong <alexvong1995@gmail.com>
  13 ;;; Copyright © 2018 Pierre Neidhardt <mail@ambrevar.xyz>
  14 ;;; Copyright © 2018, 2019 Pierre Langlois <pierre.langlois@gmx.com>
  15 ;;; Copyright © 2019, 2020 Katherine Cox-Buday <cox.katherine.e@gmail.com>
  16 ;;; Copyright © 2019 Jesse Gildersleve <jessejohngildersleve@protonmail.com>
  17 ;;; Copyright © 2019, 2020 Guillaume Le Vaillant <glv@posteo.net>
  18 ;;; Copyright © 2019 Brett Gilio <brettg@gnu.org>
  19 ;;;
  20 ;;; This file is part of GNU Guix.
  21 ;;;
  22 ;;; GNU Guix is free software; you can redistribute it and/or modify it
  23 ;;; under the terms of the GNU General Public License as published by
  24 ;;; the Free Software Foundation; either version 3 of the License, or (at
  25 ;;; your option) any later version.
  26 ;;;
  27 ;;; GNU Guix is distributed in the hope that it will be useful, but
  28 ;;; WITHOUT ANY WARRANTY; without even the implied warranty of
  29 ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  30 ;;; GNU General Public License for more details.
  31 ;;;
  32 ;;; You should have received a copy of the GNU General Public License
  33 ;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.
  34
  35 ;;; This file only contains Common Lisp libraries.
  36 ;;; Common Lisp compilers and tooling go to lisp.scm.
  37 ;;; Common Lisp applications should go to the most appropriate file,
  38 ;;; e.g. StumpWM is in wm.scm.
  39
  40 (define-module (gnu packages lisp-xyz)
  41   #:use-module (gnu packages)
  42   #:use-module ((guix licenses) #:prefix license:)
  43   #:use-module (guix packages)
  44   #:use-module (guix download)
  45   #:use-module (guix git-download)
  46   #:use-module (guix hg-download)
  47   #:use-module (guix utils)
  48   #:use-module (guix build-system asdf)
  49   #:use-module (guix build-system trivial)
  50   #:use-module (gnu packages c)
  51   #:use-module (gnu packages compression)
  52   #:use-module (gnu packages glib)
  53   #:use-module (gnu packages gtk)
  54   #:use-module (gnu packages imagemagick)
  55   #:use-module (gnu packages libevent)
  56   #:use-module (gnu packages libffi)
  57   #:use-module (gnu packages lisp)
  58   #:use-module (gnu packages maths)
  59   #:use-module (gnu packages pkg-config)
  60   #:use-module (gnu packages python)
  61   #:use-module (gnu packages python-xyz)
  62   #:use-module (gnu packages sqlite)
  63   #:use-module (gnu packages tcl)
  64   #:use-module (gnu packages tls)
  65   #:use-module (gnu packages webkit)
  66   #:use-module (gnu packages xdisorg)
  67   #:use-module (ice-9 match)
  68   #:use-module (srfi srfi-19))
  69
  70 (define-public sbcl-alexandria
  71   (let ((revision "1")
  72         (commit "3b849bc0116ea70f215ee6b2fbf354e862aaa9dd"))
  73     (package
  74       (name "sbcl-alexandria")
  75       (version (git-version "1.0.0" revision commit))
  76       (source
  77        (origin
  78          (method git-fetch)
  79          (uri (git-reference
  80                (url "https://gitlab.common-lisp.net/alexandria/alexandria.git")
  81                (commit commit)))
  82          (sha256
  83           (base32
  84            "04amwvx2vl691f0plcfbqqwxgib9zimih7jrn5zl7mbwvrxy022b"))
  85          (file-name (git-file-name name version))))
  86       (build-system asdf-build-system/sbcl)
  87       (native-inputs
  88        `(("rt" ,sbcl-rt)))
  89       (synopsis "Collection of portable utilities for Common Lisp")
  90       (description
  91        "Alexandria is a collection of portable utilities.  It does not contain
  92 conceptual extensions to Common Lisp.  It is conservative in scope, and
  93 portable between implementations.")
  94       (home-page "https://common-lisp.net/project/alexandria/")
  95       (license license:public-domain))))
  96
  97 (define-public cl-alexandria
  98   (sbcl-package->cl-source-package sbcl-alexandria))
  99
 100 (define-public ecl-alexandria
 101   (sbcl-package->ecl-package sbcl-alexandria))
 102
 103 (define-public sbcl-net.didierverna.asdf-flv
 104   (package
 105     (name "sbcl-net.didierverna.asdf-flv")
 106     (version "2.1")
 107     (source
 108      (origin
 109        (method git-fetch)
 110        (uri (git-reference
 111              (url "https://github.com/didierverna/asdf-flv")
 112              (commit (string-append "version-" version))))
 113        (file-name (git-file-name "asdf-flv" version))
 114        (sha256
 115         (base32 "1fi2y4baxan103jbg4idjddzihy03kwnj2mzbwrknw4d4x7xlgwj"))))
 116     (build-system asdf-build-system/sbcl)
 117     (synopsis "Common Lisp ASDF extension to provide support for file-local variables")
 118     (description "ASDF-FLV provides support for file-local variables through
 119 ASDF.  A file-local variable behaves like @code{*PACKAGE*} and
 120 @code{*READTABLE*} with respect to @code{LOAD} and @code{COMPILE-FILE}: a new
 121 dynamic binding is created before processing the file, so that any
 122 modification to the variable becomes essentially file-local.
 123
 124 In order to make one or several variables file-local, use the macros
 125 @code{SET-FILE-LOCAL-VARIABLE(S)}.")
 126     (home-page "https://www.lrde.epita.fr/~didier/software/lisp/misc.php#asdf-flv")
 127     (license (license:non-copyleft
 128               "https://www.gnu.org/prep/maintain/html_node/License-Notices-for-Other-Files.html"
 129               "GNU All-Permissive License"))))
 130
 131 (define-public cl-net.didierverna.asdf-flv
 132   (sbcl-package->cl-source-package sbcl-net.didierverna.asdf-flv))
 133
 134 (define-public ecl-net.didierverna.asdf-flv
 135   (sbcl-package->ecl-package sbcl-net.didierverna.asdf-flv))
 136
 137 (define-public sbcl-fiveam
 138   (package
 139     (name "sbcl-fiveam")
 140     (version "1.4.1")
 141     (source
 142      (origin
 143        (method git-fetch)
 144        (uri (git-reference
 145              (url "https://github.com/sionescu/fiveam.git")
 146              (commit (string-append "v" version))))
 147        (file-name (git-file-name "fiveam" version))
 148        (sha256
 149         (base32 "1q3d38pwafnwnw42clq0f8g5xw7pbzr287jl9jsqmb1vb0n1vrli"))))
 150     (inputs
 151      `(("alexandria" ,sbcl-alexandria)
 152        ("net.didierverna.asdf-flv" ,sbcl-net.didierverna.asdf-flv)
 153        ("trivial-backtrace" ,sbcl-trivial-backtrace)))
 154     (build-system asdf-build-system/sbcl)
 155     (synopsis "Common Lisp testing framework")
 156     (description "FiveAM is a simple (as far as writing and running tests
 157 goes) regression testing framework.  It has been designed with Common Lisp's
 158 interactive development model in mind.")
 159     (home-page "https://common-lisp.net/project/fiveam/")
 160     (license license:bsd-3)))
 161
 162 (define-public cl-fiveam
 163   (sbcl-package->cl-source-package sbcl-fiveam))
 164
 165 (define-public ecl-fiveam
 166   (sbcl-package->ecl-package sbcl-fiveam))
 167
 168 (define-public sbcl-bordeaux-threads
 169   (package
 170     (name "sbcl-bordeaux-threads")
 171     (version "0.8.7")
 172     (source (origin
 173               (method git-fetch)
 174               (uri (git-reference
 175                     (url "https://github.com/sionescu/bordeaux-threads.git")
 176                     (commit (string-append "v" version))))
 177               (sha256
 178                (base32 "1whpfmyxp2fsw6viqj45fqgsifgr534c575bfh5vaqw5m84b6alp"))
 179               (file-name
 180                (git-file-name "bordeaux-threads" version))))
 181     (inputs `(("alexandria" ,sbcl-alexandria)))
 182     (native-inputs `(("fiveam" ,sbcl-fiveam)))
 183     (build-system asdf-build-system/sbcl)
 184     (synopsis "Portable shared-state concurrency library for Common Lisp")
 185     (description "BORDEAUX-THREADS is a proposed standard for a minimal
 186 MP/Threading interface.  It is similar to the CLIM-SYS threading and lock
 187 support.")
 188     (home-page "https://common-lisp.net/project/bordeaux-threads/")
 189     (license license:x11)))
 190
 191 (define-public cl-bordeaux-threads
 192   (sbcl-package->cl-source-package sbcl-bordeaux-threads))
 193
 194 (define-public ecl-bordeaux-threads
 195   (sbcl-package->ecl-package sbcl-bordeaux-threads))
 196
 197 (define-public sbcl-trivial-gray-streams
 198   (let ((revision "1")
 199         (commit "0483ade330508b4b2edeabdb47d16ec9437ee1cb"))
 200     (package
 201       (name "sbcl-trivial-gray-streams")
 202       (version (string-append "0.0.0-" revision "." (string-take commit 7)))
 203       (source
 204        (origin
 205          (method git-fetch)
 206          (uri
 207           (git-reference
 208            (url "https://github.com/trivial-gray-streams/trivial-gray-streams.git")
 209            (commit commit)))
 210          (sha256
 211           (base32 "0m3rpf2x0zmdk3nf1qfa01j6a55vj7gkwhyw78qslcgbjlgh8p4d"))
 212          (file-name
 213           (string-append "trivial-gray-streams-" version "-checkout"))))
 214       (build-system asdf-build-system/sbcl)
 215       (synopsis "Compatibility layer for Gray streams implementations")
 216       (description "Gray streams is an interface proposed for inclusion with
 217 ANSI CL by David N. Gray.  The proposal did not make it into ANSI CL, but most
 218 popular CL implementations implement it.  This package provides an extremely
 219 thin compatibility layer for gray streams.")
 220       (home-page "http://www.cliki.net/trivial-gray-streams")
 221       (license license:x11))))
 222
 223 (define-public cl-trivial-gray-streams
 224   (sbcl-package->cl-source-package sbcl-trivial-gray-streams))
 225
 226 (define-public ecl-trivial-gray-streams
 227   (sbcl-package->ecl-package sbcl-trivial-gray-streams))
 228
 229 (define-public sbcl-fiasco
 230   (let ((commit "d62f7558b21addc89f87e306f65d7f760632655f")
 231         (revision "1"))
 232     (package
 233       (name "sbcl-fiasco")
 234       (version (git-version "0.0.1" revision commit))
 235       (source
 236        (origin
 237          (method git-fetch)
 238          (uri (git-reference
 239                (url "https://github.com/joaotavora/fiasco.git")
 240                (commit commit)))
 241          (file-name (git-file-name "fiasco" version))
 242          (sha256
 243           (base32
 244            "1zwxs3d6iswayavcmb49z2892xhym7n556d8dnmvalc32pm9bkjh"))))
 245       (build-system asdf-build-system/sbcl)
 246       (inputs
 247        `(("alexandria" ,sbcl-alexandria)
 248          ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
 249       (synopsis "Simple and powerful test framework for Common Lisp")
 250       (description "A Common Lisp test framework that treasures your failures,
 251 logical continuation of Stefil.  It focuses on interactive debugging.")
 252       (home-page "https://github.com/joaotavora/fiasco")
 253       ;; LICENCE specifies this is public-domain unless the legislation
 254       ;; doesn't allow or recognize it.  In that case it falls back to a
 255       ;; permissive licence.
 256       (license (list license:public-domain
 257                      (license:x11-style "file://LICENCE"))))))
 258
 259 (define-public cl-fiasco
 260   (sbcl-package->cl-source-package sbcl-fiasco))
 261
 262 (define-public ecl-fiasco
 263   (sbcl-package->ecl-package sbcl-fiasco))
 264
 265 (define-public sbcl-flexi-streams
 266   (package
 267     (name "sbcl-flexi-streams")
 268     (version "1.0.18")
 269     (source
 270      (origin
 271        (method git-fetch)
 272        (uri (git-reference
 273              (url "https://github.com/edicl/flexi-streams.git")
 274              (commit (string-append "v" version))))
 275        (file-name (git-file-name "flexi-streams" version))
 276        (sha256
 277         (base32 "0bjv7fd2acknidc5dyi3h85pn10krxv5jyxs1xg8jya2rlfv7f1j"))))
 278     (build-system asdf-build-system/sbcl)
 279     (arguments
 280      `(#:phases
 281        (modify-phases %standard-phases
 282          (add-after 'unpack 'make-git-checkout-writable
 283            (lambda _
 284              (for-each make-file-writable (find-files "."))
 285              #t)))))
 286     (inputs `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
 287     (synopsis "Implementation of virtual bivalent streams for Common Lisp")
 288     (description "Flexi-streams is an implementation of \"virtual\" bivalent
 289 streams that can be layered atop real binary or bivalent streams and that can
 290 be used to read and write character data in various single- or multi-octet
 291 encodings which can be changed on the fly.  It also supplies in-memory binary
 292 streams which are similar to string streams.")
 293     (home-page "http://weitz.de/flexi-streams/")
 294     (license license:bsd-3)))
 295
 296 (define-public cl-flexi-streams
 297   (sbcl-package->cl-source-package sbcl-flexi-streams))
 298
 299 (define-public ecl-flexi-streams
 300   (sbcl-package->ecl-package sbcl-flexi-streams))
 301
 302 (define-public sbcl-cl-ppcre
 303   (package
 304     (name "sbcl-cl-ppcre")
 305     (version "2.1.1")
 306     (source
 307      (origin
 308        (method git-fetch)
 309        (uri (git-reference
 310              (url "https://github.com/edicl/cl-ppcre.git")
 311              (commit (string-append "v" version))))
 312        (file-name (git-file-name "cl-ppcre" version))
 313        (sha256
 314         (base32 "0dwvr29diqzcg5n6jvbk2rnd90i05l7n828hhw99khmqd0kz7xsi"))))
 315     (build-system asdf-build-system/sbcl)
 316     (native-inputs `(("flexi-streams" ,sbcl-flexi-streams)))
 317     (synopsis "Portable regular expression library for Common Lisp")
 318     (description "CL-PPCRE is a portable regular expression library for Common
 319 Lisp, which is compatible with perl.  It is pretty fast, thread-safe, and
 320 compatible with ANSI-compliant Common Lisp implementations.")
 321     (home-page "http://weitz.de/cl-ppcre/")
 322     (license license:bsd-2)))
 323
 324 (define-public cl-ppcre
 325   (sbcl-package->cl-source-package sbcl-cl-ppcre))
 326
 327 (define-public ecl-cl-ppcre
 328   (sbcl-package->ecl-package sbcl-cl-ppcre))
 329
 330 (define sbcl-cl-unicode-base
 331   (package
 332     (name "sbcl-cl-unicode-base")
 333     (version "0.1.6")
 334     (source (origin
 335               (method git-fetch)
 336               (uri (git-reference
 337                     (url "https://github.com/edicl/cl-unicode.git")
 338                     (commit (string-append "v" version))))
 339               (file-name (git-file-name name version))
 340               (sha256
 341                (base32
 342                 "0ykx2s9lqfl74p1px0ik3l2izd1fc9jd1b4ra68s5x34rvjy0hza"))))
 343     (build-system asdf-build-system/sbcl)
 344     (arguments
 345      '(#:asd-file "cl-unicode.asd"
 346        #:asd-system-name "cl-unicode/base"))
 347     (inputs
 348      `(("cl-ppcre" ,sbcl-cl-ppcre)))
 349     (home-page "http://weitz.de/cl-unicode/")
 350     (synopsis "Portable Unicode library for Common Lisp")
 351     (description "CL-UNICODE is a portable Unicode library Common Lisp, which
 352 is compatible with perl.  It is pretty fast, thread-safe, and compatible with
 353 ANSI-compliant Common Lisp implementations.")
 354     (license license:bsd-2)))
 355
 356 (define-public sbcl-cl-unicode
 357   (package
 358     (inherit sbcl-cl-unicode-base)
 359     (name "sbcl-cl-unicode")
 360     (inputs
 361      `(("cl-unicode/base" ,sbcl-cl-unicode-base)
 362        ,@(package-inputs sbcl-cl-unicode-base)))
 363     (native-inputs
 364      `(("flexi-streams" ,sbcl-flexi-streams)))
 365     (arguments '())))
 366
 367 (define-public ecl-cl-unicode
 368   (sbcl-package->ecl-package sbcl-cl-unicode))
 369
 370 (define-public cl-unicode
 371   (sbcl-package->cl-source-package sbcl-cl-unicode))
 372
 373 (define-public sbcl-zpb-ttf
 374   (package
 375     (name "sbcl-zpb-ttf")
 376     (version "1.0.3")
 377     (source
 378      (origin
 379        (method git-fetch)
 380        (uri (git-reference
 381              (url "https://github.com/xach/zpb-ttf.git")
 382              (commit (string-append "release-" version))))
 383        (file-name (git-file-name name version))
 384        (sha256
 385         (base32
 386          "1wh66vjijzqlydnrihynpwp6796917xwrh0i9li93c17kyxa74ih"))))
 387     (build-system asdf-build-system/sbcl)
 388     (home-page "https://github.com/xach/zpb-ttf")
 389     (synopsis "TrueType font file access for Common Lisp")
 390     (description
 391      "ZPB-TTF is a TrueType font file parser that provides an interface for
 392 reading typographic metrics, glyph outlines, and other information from the
 393 file.")
 394     (license license:bsd-2)))
 395
 396 (define-public ecl-zpb-ttf
 397   (sbcl-package->ecl-package sbcl-zpb-ttf))
 398
 399 (define-public cl-zpb-ttf
 400   (sbcl-package->cl-source-package sbcl-zpb-ttf))
 401
 402 (define-public sbcl-cl-aa
 403   (package
 404     (name "sbcl-cl-aa")
 405     (version "0.1.5")
 406     (source
 407      (origin
 408        (method url-fetch)
 409        (uri (string-append "http://projects.tuxee.net/cl-vectors/"
 410                            "files/cl-vectors-" version ".tar.gz"))
 411        (sha256
 412         (base32
 413          "04lhwi0kq8pkwhgd885pk80m1cp9sfvjjn5zj70s1dnckibhdmqh"))))
 414     (build-system asdf-build-system/sbcl)
 415     (arguments '(#:asd-file "cl-aa.asd"))
 416     (home-page "http://projects.tuxee.net/cl-vectors/")
 417     (synopsis "Polygon rasterizer")
 418     (description
 419      "This is a Common Lisp library implementing the AA polygon rasterization
 420 algorithm from the @url{http://antigrain.com, Antigrain} project.")
 421     (license license:expat)))
 422
 423 (define-public ecl-cl-aa
 424   (sbcl-package->ecl-package sbcl-cl-aa))
 425
 426 (define-public cl-aa
 427   (sbcl-package->cl-source-package sbcl-cl-aa))
 428
 429 (define-public sbcl-cl-paths
 430   (package
 431     (inherit sbcl-cl-aa)
 432     (name "sbcl-cl-paths")
 433     (arguments '(#:asd-file "cl-paths.asd"))
 434     (synopsis "Facilities to create and manipulate vectorial paths")
 435     (description
 436      "This package provides facilities to create and manipulate vectorial
 437 paths.")))
 438
 439 (define-public ecl-cl-paths
 440   (sbcl-package->ecl-package sbcl-cl-paths))
 441
 442 (define-public cl-paths
 443   (sbcl-package->cl-source-package sbcl-cl-paths))
 444
 445 (define-public sbcl-cl-paths-ttf
 446   (package
 447     (inherit sbcl-cl-aa)
 448     (name "sbcl-cl-paths-ttf")
 449     (arguments '(#:asd-file "cl-paths-ttf.asd"))
 450     (inputs
 451      `(("cl-paths" ,sbcl-cl-paths)
 452        ("zpb-ttf" ,sbcl-zpb-ttf)))
 453     (synopsis "Facilities to create and manipulate vectorial paths")
 454     (description
 455      "This package provides facilities to create and manipulate vectorial
 456 paths.")))
 457
 458 (define-public ecl-cl-paths-ttf
 459   (sbcl-package->ecl-package sbcl-cl-paths-ttf))
 460
 461 (define-public cl-paths-ttf
 462   (sbcl-package->cl-source-package sbcl-cl-paths-ttf))
 463
 464 (define-public sbcl-cl-vectors
 465   (package
 466     (inherit sbcl-cl-aa)
 467     (name "sbcl-cl-vectors")
 468     (arguments '(#:asd-file "cl-vectors.asd"))
 469     (inputs
 470      `(("cl-aa" ,sbcl-cl-aa)
 471        ("cl-paths" ,sbcl-cl-paths)))
 472     (synopsis "Create, transform and render anti-aliased vectorial paths")
 473     (description
 474      "This is a pure Common Lisp library to create, transform and render
 475 anti-aliased vectorial paths.")))
 476
 477 (define-public ecl-cl-vectors
 478   (sbcl-package->ecl-package sbcl-cl-vectors))
 479
 480 (define-public cl-vectors
 481   (sbcl-package->cl-source-package sbcl-cl-vectors))
 482
 483 (define-public sbcl-spatial-trees
 484   ;; There have been no releases.
 485   (let ((commit "81fdad0a0bf109c80a53cc96eca2e093823400ba")
 486         (revision "1"))
 487     (package
 488       (name "sbcl-spatial-trees")
 489       (version (git-version "0" revision commit))
 490       (source
 491        (origin
 492          (method git-fetch)
 493          (uri (git-reference
 494                (url "https://github.com/rpav/spatial-trees.git")
 495                (commit commit)))
 496          (file-name (git-file-name name version))
 497          (sha256
 498           (base32
 499            "11rhc6h501dwcik2igkszz7b9n515cr99m5pjh4r2qfwgiri6ysa"))))
 500       (build-system asdf-build-system/sbcl)
 501       (arguments
 502        '(#:tests? #f           ; spatial-trees.test requires spatial-trees.nns
 503          #:asd-file "spatial-trees.asd"
 504          #:test-asd-file "spatial-trees.test.asd"))
 505       (native-inputs
 506        `(("fiveam" ,sbcl-fiveam)))
 507       (home-page "https://github.com/rpav/spatial-trees")
 508       (synopsis "Dynamic index data structures for spatially-extended data")
 509       (description
 510        "Spatial-trees is a set of dynamic index data structures for
 511 spatially-extended data.")
 512       (license license:bsd-3))))
 513
 514 (define-public ecl-spatial-trees
 515   (sbcl-package->ecl-package sbcl-spatial-trees))
 516
 517 (define-public cl-spatial-trees
 518   (sbcl-package->cl-source-package sbcl-spatial-trees))
 519
 520 (define-public sbcl-flexichain
 521   ;; There are no releases.
 522   (let ((commit "13d2a6c505ed0abfcd4c4ec7d7145059b06855d6")
 523         (revision "1"))
 524     (package
 525       (name "sbcl-flexichain")
 526       (version "1.5.1")
 527       (source
 528        (origin
 529          (method git-fetch)
 530          (uri (git-reference
 531                (url "https://github.com/robert-strandh/Flexichain.git")
 532                (commit commit)))
 533          (file-name (git-file-name name version))
 534          (sha256
 535           (base32
 536            "0pfyvhsfbjd2sjb30grfs52r51a428xglv7bwydvpg2lc117qimg"))))
 537       (build-system asdf-build-system/sbcl)
 538       (home-page "https://github.com/robert-strandh/Flexichain.git")
 539       (synopsis "Dynamically add elements to or remove them from sequences")
 540       (description
 541        "This package provides an implementation of the flexichain protocol,
 542 allowing client code to dynamically add elements to, and delete elements from
 543 a sequence (or chain) of such elements.")
 544       (license license:lgpl2.1+))))
 545
 546 (define-public ecl-flexichain
 547   (sbcl-package->ecl-package sbcl-flexichain))
 548
 549 (define-public cl-flexichain
 550   (sbcl-package->cl-source-package sbcl-flexichain))
 551
 552 (define-public sbcl-cl-pdf
 553   ;; There are no releases
 554   (let ((commit "752e337e6d6fc206f09d091a982e7f8e5c404e4e")
 555         (revision "1"))
 556     (package
 557       (name "sbcl-cl-pdf")
 558       (version (git-version "0" revision commit))
 559       (source
 560        (origin
 561          (method git-fetch)
 562          (uri (git-reference
 563                (url "https://github.com/mbattyani/cl-pdf.git")
 564                (commit commit)))
 565          (file-name (git-file-name name version))
 566          (sha256
 567           (base32
 568            "1cg3k3m3r11ipb8j008y8ipynj97l3xjlpi2knqc9ndmx4r3kb1r"))))
 569       (build-system asdf-build-system/sbcl)
 570       (inputs
 571        `(("iterate" ,sbcl-iterate)
 572          ("zpb-ttf" ,sbcl-zpb-ttf)))
 573       (home-page "https://github.com/mbattyani/cl-pdf")
 574       (synopsis "Common Lisp library for generating PDF files")
 575       (description
 576        "CL-PDF is a cross-platform Common Lisp library for generating PDF
 577 files.")
 578       (license license:bsd-2))))
 579
 580 (define-public ecl-cl-pdf
 581   (sbcl-package->ecl-package sbcl-cl-pdf))
 582
 583 (define-public cl-pdf
 584   (sbcl-package->cl-source-package sbcl-cl-pdf))
 585
 586 (define-public sbcl-clx
 587   (package
 588     (name "sbcl-clx")
 589     (version "0.7.5")
 590     (source
 591      (origin
 592        (method git-fetch)
 593        (uri
 594         (git-reference
 595          (url "https://github.com/sharplispers/clx.git")
 596          (commit version)))
 597        (sha256
 598         (base32
 599          "1vi67z9hpj5rr4xcmfbfwzmlcc0ah7hzhrmfid6lqdkva238v2wf"))
 600        (file-name (string-append "clx-" version))))
 601     (build-system asdf-build-system/sbcl)
 602     (native-inputs
 603      `(("fiasco" ,sbcl-fiasco)))
 604     (home-page "http://www.cliki.net/portable-clx")
 605     (synopsis "X11 client library for Common Lisp")
 606     (description "CLX is an X11 client library for Common Lisp.  The code was
 607 originally taken from a CMUCL distribution, was modified somewhat in order to
 608 make it compile and run under SBCL, then a selection of patches were added
 609 from other CLXes around the net.")
 610     (license license:x11)))
 611
 612 (define-public cl-clx
 613   (sbcl-package->cl-source-package sbcl-clx))
 614
 615 (define-public ecl-clx
 616   (sbcl-package->ecl-package sbcl-clx))
 617
 618 (define-public sbcl-cl-ppcre-unicode
 619   (package (inherit sbcl-cl-ppcre)
 620     (name "sbcl-cl-ppcre-unicode")
 621     (arguments
 622      `(#:tests? #f ; tests fail with "Component :CL-PPCRE-TEST not found"
 623        #:asd-file "cl-ppcre-unicode.asd"))
 624     (inputs
 625      `(("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
 626        ("sbcl-cl-unicode" ,sbcl-cl-unicode)))))
 627
 628 (define-public ecl-cl-ppcre-unicode
 629   (sbcl-package->ecl-package sbcl-cl-ppcre-unicode))
 630
 631 ;; The slynk that users expect to install includes all of slynk's contrib
 632 ;; modules.  Therefore, we build the base module and all contribs first; then
 633 ;; we expose the union of these as `sbcl-slynk'.  The following variable
 634 ;; describes the base module.
 635 (define sbcl-slynk-boot0
 636   (let ((revision "2")
 637         (commit "cbf84c36c4eca8b032e3fd16177a7bc02df3ec4c"))
 638     (package
 639       (name "sbcl-slynk-boot0")
 640       (version (string-append "1.0.0-beta-" revision "." (string-take commit 7)))
 641       (source
 642        (origin
 643          (method git-fetch)
 644          (uri
 645           (git-reference
 646            (url "https://github.com/joaotavora/sly.git")
 647            (commit commit)))
 648          (sha256
 649           (base32 "13dyhsravn591p7g6is01mp2ynzjnnj7pwgi57r6xqmd4611y9vh"))
 650          (file-name (string-append "slynk-" version "-checkout"))
 651          (modules '((guix build utils)
 652                     (ice-9 ftw)))
 653          (snippet
 654           '(begin
 655              ;; Move the contribs into the main source directory for easier
 656              ;; access
 657              (substitute* "slynk/slynk.asd"
 658                (("\\.\\./contrib")
 659                 "contrib")
 660                (("\\(defsystem :slynk/util")
 661                 "(defsystem :slynk/util :depends-on (:slynk)")
 662                ((":depends-on \\(:slynk :slynk/util\\)")
 663                 ":depends-on (:slynk :slynk-util)"))
 664              (substitute* "contrib/slynk-trace-dialog.lisp"
 665                (("\\(slynk::reset-inspector\\)") ; Causes problems on load
 666                 "nil"))
 667              (substitute* "contrib/slynk-profiler.lisp"
 668                (("slynk:to-line")
 669                 "slynk-pprint-to-line"))
 670              (substitute* "contrib/slynk-fancy-inspector.lisp"
 671                (("slynk/util") "slynk-util")
 672                ((":compile-toplevel :load-toplevel") ""))
 673              (rename-file "contrib" "slynk/contrib")
 674              ;; Move slynk's contents into the base directory for easier
 675              ;; access
 676              (for-each (lambda (file)
 677                          (unless (string-prefix? "." file)
 678                            (rename-file (string-append "slynk/" file)
 679                                         (string-append "./" (basename file)))))
 680                        (scandir "slynk"))
 681              #t))))
 682       (build-system asdf-build-system/sbcl)
 683       (arguments
 684        `(#:tests? #f ; No test suite
 685          #:asd-system-name "slynk"))
 686       (synopsis "Common Lisp IDE for Emacs")
 687       (description "SLY is a fork of SLIME, an IDE backend for Common Lisp.
 688 It also features a completely redesigned REPL based on Emacs's own
 689 full-featured comint.el, live code annotations, and a consistent interactive
 690 button interface.  Everything can be copied to the REPL.  One can create
 691 multiple inspectors with independent history.")
 692       (home-page "https://github.com/joaotavora/sly")
 693       (license license:public-domain)
 694       (properties `((cl-source-variant . ,(delay cl-slynk)))))))
 695
 696 (define-public cl-slynk
 697   (package
 698     (inherit (sbcl-package->cl-source-package sbcl-slynk-boot0))
 699     (name "cl-slynk")))
 700
 701 (define ecl-slynk-boot0
 702   (sbcl-package->ecl-package sbcl-slynk-boot0))
 703
 704 (define sbcl-slynk-arglists
 705   (package
 706     (inherit sbcl-slynk-boot0)
 707     (name "sbcl-slynk-arglists")
 708     (inputs `(("slynk" ,sbcl-slynk-boot0)))
 709     (arguments
 710      (substitute-keyword-arguments (package-arguments sbcl-slynk-boot0)
 711        ((#:asd-file _ "") "slynk.asd")
 712        ((#:asd-system-name _ #f) "slynk/arglists")))))
 713
 714 (define ecl-slynk-arglists
 715   (sbcl-package->ecl-package sbcl-slynk-arglists))
 716
 717 (define sbcl-slynk-util
 718   (package
 719     (inherit sbcl-slynk-boot0)
 720     (name "sbcl-slynk-util")
 721     (inputs `(("slynk" ,sbcl-slynk-boot0)))
 722     (arguments
 723      (substitute-keyword-arguments (package-arguments sbcl-slynk-boot0)
 724        ((#:asd-file _ "") "slynk.asd")
 725        ((#:asd-system-name _ #f) "slynk/util")))))
 726
 727 (define ecl-slynk-util
 728   (sbcl-package->ecl-package sbcl-slynk-util))
 729
 730 (define sbcl-slynk-fancy-inspector
 731   (package
 732     (inherit sbcl-slynk-arglists)
 733     (name "sbcl-slynk-fancy-inspector")
 734     (inputs `(("slynk-util" ,sbcl-slynk-util)
 735               ,@(package-inputs sbcl-slynk-arglists)))
 736     (arguments
 737      (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
 738        ((#:asd-system-name _ #f) "slynk/fancy-inspector")))))
 739
 740 (define ecl-slynk-fancy-inspector
 741   (sbcl-package->ecl-package sbcl-slynk-fancy-inspector))
 742
 743 (define sbcl-slynk-package-fu
 744   (package
 745     (inherit sbcl-slynk-arglists)
 746     (name "sbcl-slynk-package-fu")
 747     (arguments
 748      (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
 749        ((#:asd-system-name _ #f) "slynk/package-fu")))))
 750
 751 (define ecl-slynk-package-fu
 752   (sbcl-package->ecl-package sbcl-slynk-package-fu))
 753
 754 (define sbcl-slynk-mrepl
 755   (package
 756     (inherit sbcl-slynk-fancy-inspector)
 757     (name "sbcl-slynk-mrepl")
 758     (arguments
 759      (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
 760        ((#:asd-system-name _ #f) "slynk/mrepl")))))
 761
 762 (define ecl-slynk-mrepl
 763   (sbcl-package->ecl-package sbcl-slynk-mrepl))
 764
 765 (define sbcl-slynk-trace-dialog
 766   (package
 767     (inherit sbcl-slynk-arglists)
 768     (name "sbcl-slynk-trace-dialog")
 769     (arguments
 770      (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
 771        ((#:asd-system-name _ #f) "slynk/trace-dialog")))))
 772
 773 (define ecl-slynk-trace-dialog
 774   (sbcl-package->ecl-package sbcl-slynk-trace-dialog))
 775
 776 (define sbcl-slynk-profiler
 777   (package
 778     (inherit sbcl-slynk-arglists)
 779     (name "sbcl-slynk-profiler")
 780     (arguments
 781      (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
 782        ((#:asd-system-name _ #f) "slynk/profiler")))))
 783
 784 (define ecl-slynk-profiler
 785   (sbcl-package->ecl-package sbcl-slynk-profiler))
 786
 787 (define sbcl-slynk-stickers
 788   (package
 789     (inherit sbcl-slynk-arglists)
 790     (name "sbcl-slynk-stickers")
 791     (arguments
 792      (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
 793        ((#:asd-system-name _ #f) "slynk/stickers")))))
 794
 795 (define ecl-slynk-stickers
 796   (sbcl-package->ecl-package sbcl-slynk-stickers))
 797
 798 (define sbcl-slynk-indentation
 799   (package
 800     (inherit sbcl-slynk-arglists)
 801     (name "sbcl-slynk-indentation")
 802     (arguments
 803      (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
 804        ((#:asd-system-name _ #f) "slynk/indentation")))))
 805
 806 (define ecl-slynk-indentation
 807   (sbcl-package->ecl-package sbcl-slynk-indentation))
 808
 809 (define sbcl-slynk-retro
 810   (package
 811     (inherit sbcl-slynk-arglists)
 812     (name "sbcl-slynk-retro")
 813     (arguments
 814      (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
 815        ((#:asd-system-name _ #f) "slynk/retro")))))
 816
 817 (define ecl-slynk-retro
 818   (sbcl-package->ecl-package sbcl-slynk-retro))
 819
 820 (define slynk-systems
 821   '("slynk"
 822     "slynk-util"
 823     "slynk-arglists"
 824     "slynk-fancy-inspector"
 825     "slynk-package-fu"
 826     "slynk-mrepl"
 827     "slynk-profiler"
 828     "slynk-trace-dialog"
 829     "slynk-stickers"
 830     "slynk-indentation"
 831     "slynk-retro"))
 832
 833 (define-public sbcl-slynk
 834   (package
 835     (inherit sbcl-slynk-boot0)
 836     (name "sbcl-slynk")
 837     (inputs
 838      `(("slynk" ,sbcl-slynk-boot0)
 839        ("slynk-util" ,sbcl-slynk-util)
 840        ("slynk-arglists" ,sbcl-slynk-arglists)
 841        ("slynk-fancy-inspector" ,sbcl-slynk-fancy-inspector)
 842        ("slynk-package-fu" ,sbcl-slynk-package-fu)
 843        ("slynk-mrepl" ,sbcl-slynk-mrepl)
 844        ("slynk-profiler" ,sbcl-slynk-profiler)
 845        ("slynk-trace-dialog" ,sbcl-slynk-trace-dialog)
 846        ("slynk-stickers" ,sbcl-slynk-stickers)
 847        ("slynk-indentation" ,sbcl-slynk-indentation)
 848        ("slynk-retro" ,sbcl-slynk-retro)))
 849     (native-inputs `(("sbcl" ,sbcl)))
 850     (build-system trivial-build-system)
 851     (source #f)
 852     (outputs '("out" "image"))
 853     (arguments
 854      `(#:modules ((guix build union)
 855                   (guix build utils)
 856                   (guix build lisp-utils))
 857        #:builder
 858        (begin
 859          (use-modules (ice-9 match)
 860                       (srfi srfi-1)
 861                       (guix build union)
 862                       (guix build lisp-utils))
 863
 864          (union-build
 865           (assoc-ref %outputs "out")
 866           (filter-map
 867            (match-lambda
 868              ((name . path)
 869               (if (string-prefix? "slynk" name) path #f)))
 870            %build-inputs))
 871
 872          (prepend-to-source-registry
 873           (string-append (assoc-ref %outputs "out") "//"))
 874
 875          (parameterize ((%lisp-type "sbcl")
 876                         (%lisp (string-append (assoc-ref %build-inputs "sbcl")
 877                                               "/bin/sbcl")))
 878            (build-image (string-append
 879                          (assoc-ref %outputs "image")
 880                          "/bin/slynk")
 881                         %outputs
 882                         #:dependencies ',slynk-systems))
 883          #t)))))
 884
 885 (define-public ecl-slynk
 886   (package
 887     (inherit sbcl-slynk)
 888     (name "ecl-slynk")
 889     (inputs
 890      (map (match-lambda
 891             ((name pkg . _)
 892              (list name (sbcl-package->ecl-package pkg))))
 893           (package-inputs sbcl-slynk)))
 894     (native-inputs '())
 895     (outputs '("out"))
 896     (arguments
 897      '(#:modules ((guix build union))
 898        #:builder
 899        (begin
 900          (use-modules (ice-9 match)
 901                       (guix build union))
 902          (match %build-inputs
 903            (((names . paths) ...)
 904             (union-build (assoc-ref %outputs "out")
 905                          paths)
 906             #t)))))))
 907
 908 (define-public sbcl-parse-js
 909   (let ((commit "fbadc6029bec7039602abfc06c73bb52970998f6")
 910         (revision "1"))
 911     (package
 912       (name "sbcl-parse-js")
 913       (version (string-append "0.0.0-" revision "." (string-take commit 9)))
 914       (source
 915        (origin
 916          (method git-fetch)
 917          (uri (git-reference
 918                (url "http://marijn.haverbeke.nl/git/parse-js")
 919                (commit commit)))
 920          (file-name (string-append name "-" commit "-checkout"))
 921          (sha256
 922           (base32
 923            "1wddrnr5kiya5s3gp4cdq6crbfy9fqcz7fr44p81502sj3bvdv39"))))
 924       (build-system asdf-build-system/sbcl)
 925       (home-page "http://marijnhaverbeke.nl/parse-js/")
 926       (synopsis "Parse JavaScript")
 927       (description "Parse-js is a Common Lisp package for parsing
 928 JavaScript (ECMAScript 3).  It has basic support for ECMAScript 5.")
 929       (license license:zlib))))
 930
 931 (define-public cl-parse-js
 932   (sbcl-package->cl-source-package sbcl-parse-js))
 933
 934 (define-public sbcl-parse-number
 935   (package
 936     (name "sbcl-parse-number")
 937     (version "1.7")
 938     (source
 939      (origin
 940        (method git-fetch)
 941        (uri (git-reference
 942               (url "https://github.com/sharplispers/parse-number/")
 943               (commit (string-append "v" version))))
 944        (file-name (git-file-name name version))
 945        (sha256
 946         (base32
 947          "0sk06ib1bhqv9y39vwnnw44vmbc4b0kvqm37xxmkxd4dwchq82d7"))))
 948     (build-system asdf-build-system/sbcl)
 949     (home-page "http://www.cliki.net/PARSE-NUMBER")
 950     (synopsis "Parse numbers")
 951     (description "@code{parse-number} is a library of functions for parsing
 952 strings into one of the standard Common Lisp number types without using the
 953 reader.  @code{parse-number} accepts an arbitrary string and attempts to parse
 954 the string into one of the standard Common Lisp number types, if possible, or
 955 else @code{parse-number} signals an error of type @code{invalid-number}.")
 956     (license license:bsd-3)))
 957
 958 (define-public cl-parse-number
 959   (sbcl-package->cl-source-package sbcl-parse-number))
 960
 961 (define-public sbcl-iterate
 962   (package
 963     (name "sbcl-iterate")
 964     ;; The latest official release (1.4.3) fails to build so we have to take
 965     ;; the current darcs tarball from quicklisp.
 966     (version "20160825")
 967     (source
 968      (origin
 969        (method url-fetch)
 970        (uri (string-append "http://beta.quicklisp.org/archive/iterate/"
 971                            "2016-08-25/iterate-"
 972                            version "-darcs.tgz"))
 973        (sha256
 974         (base32
 975          "0kvz16gnxnkdz0fy1x8y5yr28nfm7i2qpvix7mgwccdpjmsb4pgm"))))
 976     (build-system asdf-build-system/sbcl)
 977     (native-inputs
 978      `(("rt" ,sbcl-rt)))
 979     (home-page "https://common-lisp.net/project/iterate/")
 980     (synopsis "Iteration construct for Common Lisp")
 981     (description "@code{iterate} is an iteration construct for Common Lisp.
 982 It is similar to the @code{CL:LOOP} macro, with these distinguishing marks:
 983
 984 @itemize
 985 @item it is extensible,
 986 @item it helps editors like Emacs indent iterate forms by having a more
 987   lisp-like syntax, and
 988 @item it isn't part of the ANSI standard for Common Lisp.
 989 @end itemize\n")
 990     (license license:expat)))
 991
 992 (define-public cl-iterate
 993   (sbcl-package->cl-source-package sbcl-iterate))
 994
 995 (define-public ecl-iterate
 996   (sbcl-package->ecl-package sbcl-iterate))
 997
 998 (define-public sbcl-cl-uglify-js
 999   ;; There have been many bug fixes since the 2010 release.
1000   (let ((commit "429c5e1d844e2f96b44db8fccc92d6e8e28afdd5")
1001         (revision "1"))
1002     (package
1003       (name "sbcl-cl-uglify-js")
1004       (version (string-append "0.1-" revision "." (string-take commit 9)))
1005       (source
1006        (origin
1007          (method git-fetch)
1008          (uri (git-reference
1009                (url "https://github.com/mishoo/cl-uglify-js.git")
1010                (commit commit)))
1011          (file-name (git-file-name name version))
1012          (sha256
1013           (base32
1014            "0k39y3c93jgxpr7gwz7w0d8yknn1fdnxrjhd03057lvk5w8js27a"))))
1015       (build-system asdf-build-system/sbcl)
1016       (inputs
1017        `(("sbcl-parse-js" ,sbcl-parse-js)
1018          ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
1019          ("sbcl-cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)
1020          ("sbcl-parse-number" ,sbcl-parse-number)
1021          ("sbcl-iterate" ,sbcl-iterate)))
1022       (home-page "https://github.com/mishoo/cl-uglify-js")
1023       (synopsis "JavaScript compressor library for Common Lisp")
1024       (description "This is a Common Lisp version of UglifyJS, a JavaScript
1025 compressor.  It works on data produced by @code{parse-js} to generate a
1026 @dfn{minified} version of the code.  Currently it can:
1027
1028 @itemize
1029 @item reduce variable names (usually to single letters)
1030 @item join consecutive @code{var} statements
1031 @item resolve simple binary expressions
1032 @item group most consecutive statements using the @code{sequence} operator (comma)
1033 @item remove unnecessary blocks
1034 @item convert @code{IF} expressions in various ways that result in smaller code
1035 @item remove some unreachable code
1036 @end itemize\n")
1037       (license license:zlib))))
1038
1039 (define-public cl-uglify-js
1040   (sbcl-package->cl-source-package sbcl-cl-uglify-js))
1041
1042 (define-public uglify-js
1043   (package
1044     (inherit sbcl-cl-uglify-js)
1045     (name "uglify-js")
1046     (build-system trivial-build-system)
1047     (arguments
1048      `(#:modules ((guix build utils))
1049        #:builder
1050        (let* ((bin    (string-append (assoc-ref %outputs "out") "/bin/"))
1051               (script (string-append bin "uglify-js")))
1052          (use-modules (guix build utils))
1053          (mkdir-p bin)
1054          (with-output-to-file script
1055            (lambda _
1056              (format #t "#!~a/bin/sbcl --script
1057  (require :asdf)
1058  (push (truename \"~a/lib/sbcl\") asdf:*central-registry*)"
1059                      (assoc-ref %build-inputs "sbcl")
1060                      (assoc-ref %build-inputs "sbcl-cl-uglify-js"))
1061              ;; FIXME: cannot use progn here because otherwise it fails to
1062              ;; find cl-uglify-js.
1063              (for-each
1064               write
1065               '(;; Quiet, please!
1066                 (let ((*standard-output* (make-broadcast-stream))
1067                       (*error-output* (make-broadcast-stream)))
1068                   (asdf:load-system :cl-uglify-js))
1069                 (let ((file (cadr *posix-argv*)))
1070                   (if file
1071                       (format t "~a"
1072                               (cl-uglify-js:ast-gen-code
1073                                (cl-uglify-js:ast-mangle
1074                                 (cl-uglify-js:ast-squeeze
1075                                  (with-open-file (in file)
1076                                                  (parse-js:parse-js in))))
1077                                :beautify nil))
1078                       (progn
1079                        (format *error-output*
1080                                "Please provide a JavaScript file.~%")
1081                        (sb-ext:exit :code 1))))))))
1082          (chmod script #o755)
1083          #t)))
1084     (inputs
1085      `(("sbcl" ,sbcl)
1086        ("sbcl-cl-uglify-js" ,sbcl-cl-uglify-js)))
1087     (synopsis "JavaScript compressor")))
1088
1089 (define-public sbcl-cl-strings
1090   (let ((revision "1")
1091         (commit "c5c5cbafbf3e6181d03c354d66e41a4f063f00ae"))
1092     (package
1093       (name "sbcl-cl-strings")
1094       (version (git-version "0.0.0" revision commit))
1095       (source
1096        (origin
1097          (method git-fetch)
1098          (uri (git-reference
1099                (url "https://github.com/diogoalexandrefranco/cl-strings")
1100                (commit commit)))
1101          (sha256
1102           (base32
1103            "00754mfaqallj480lwd346nkfb6ra8pa8xcxcylf4baqn604zlmv"))
1104          (file-name (string-append "cl-strings-" version "-checkout"))))
1105       (build-system asdf-build-system/sbcl)
1106       (synopsis "Portable, dependency-free set of utilities to manipulate strings in Common Lisp")
1107       (description
1108        "@command{cl-strings} is a small, portable, dependency-free set of
1109 utilities that make it even easier to manipulate text in Common Lisp.  It has
1110 100% test coverage and works at least on sbcl, ecl, ccl, abcl and clisp.")
1111       (home-page "https://github.com/diogoalexandrefranco/cl-strings")
1112       (license license:expat))))
1113
1114 (define-public cl-strings
1115   (sbcl-package->cl-source-package sbcl-cl-strings))
1116
1117 (define-public ecl-cl-strings
1118   (sbcl-package->ecl-package sbcl-cl-strings))
1119
1120 (define-public sbcl-trivial-features
1121   (package
1122     (name "sbcl-trivial-features")
1123     (version "0.8")
1124     (source
1125      (origin
1126        (method git-fetch)
1127        (uri (git-reference
1128              (url "https://github.com/trivial-features/trivial-features.git")
1129              (commit (string-append "v" version))))
1130        (file-name (git-file-name "trivial-features" version))
1131        (sha256
1132         (base32 "0ccv7dqyrk55xga78i5vzlic7mdwp28in3g1a8fqhlk6626scsq9"))))
1133     (build-system asdf-build-system/sbcl)
1134     (arguments '(#:tests? #f))
1135     (home-page "http://cliki.net/trivial-features")
1136     (synopsis "Ensures consistency of @code{*FEATURES*} in Common Lisp")
1137     (description "Trivial-features ensures that @code{*FEATURES*} is
1138 consistent across multiple Common Lisp implementations.")
1139     (license license:expat)))
1140
1141 (define-public cl-trivial-features
1142   (sbcl-package->cl-source-package sbcl-trivial-features))
1143
1144 (define-public ecl-trivial-features
1145   (sbcl-package->ecl-package sbcl-trivial-features))
1146
1147 (define-public sbcl-hu.dwim.asdf
1148   (package
1149     (name "sbcl-hu.dwim.asdf")
1150     (version "20190521")
1151     (source
1152      (origin
1153        (method url-fetch)
1154        (uri (string-append "http://beta.quicklisp.org/archive/hu.dwim.asdf/"
1155                            "2019-05-21/hu.dwim.asdf-" version "-darcs.tgz"))
1156        (sha256
1157         (base32
1158          "0rsbv71vyszy8w35yjwb5h6zcmknjq223hkzir79y72qdsc6sabn"))))
1159     (build-system asdf-build-system/sbcl)
1160     (home-page "https://hub.darcs.net/hu.dwim/hu.dwim.asdf")
1161     (synopsis "Extensions to ASDF")
1162     (description "Various ASDF extensions such as attached test and
1163 documentation system, explicit development support, etc.")
1164     (license license:public-domain)))
1165
1166 (define-public cl-hu.dwim.asdf
1167   (sbcl-package->cl-source-package sbcl-hu.dwim.asdf))
1168
1169 (define-public ecl-hu.dwim.asdf
1170   (sbcl-package->ecl-package sbcl-hu.dwim.asdf))
1171
1172 (define-public sbcl-hu.dwim.stefil
1173   (let ((commit "ab6d1aa8995878a1b66d745dfd0ba021090bbcf9"))
1174     (package
1175       (name "sbcl-hu.dwim.stefil")
1176       (version (git-version "0.0.0" "1" commit))
1177       (source
1178        (origin
1179          (method git-fetch)
1180          (uri
1181           (git-reference
1182            (url "https://gitlab.common-lisp.net/xcvb/hu.dwim.stefil.git")
1183            (commit commit)))
1184          (sha256
1185           (base32 "1d8yccw65zj3zh46cbi3x6nmn1dwdb76s9d0av035077mvyirqqp"))
1186          (file-name (git-file-name "hu.dwim.stefil" version))))
1187       (build-system asdf-build-system/sbcl)
1188       (native-inputs
1189        `(("asdf:cl-hu.dwim.asdf" ,sbcl-hu.dwim.asdf)))
1190       (inputs
1191        `(("sbcl-alexandria" ,sbcl-alexandria)))
1192       (home-page "https://hub.darcs.net/hu.dwim/hu.dwim.stefil")
1193       (synopsis "Simple test framework")
1194       (description "Stefil is a simple test framework for Common Lisp,
1195 with a focus on interactive development.")
1196       (license license:public-domain))))
1197
1198 (define-public cl-hu.dwim.stefil
1199   (sbcl-package->cl-source-package sbcl-hu.dwim.stefil))
1200
1201 (define-public ecl-hu.dwim.stefil
1202   (sbcl-package->ecl-package sbcl-hu.dwim.stefil))
1203
1204 (define-public sbcl-babel
1205   (package
1206     (name "sbcl-babel")
1207     (version "0.5.0")
1208     (source
1209      (origin
1210        (method git-fetch)
1211        (uri (git-reference
1212              (url "https://github.com/cl-babel/babel.git")
1213              (commit (string-append "v" version))))
1214        (file-name (git-file-name "babel" version))
1215        (sha256
1216         (base32 "139a8rn2gnhj082n8jg01gc8fyr63hkj57hgrnmb3d1r327yc77f"))))
1217     (build-system asdf-build-system/sbcl)
1218     (native-inputs
1219      `(("tests:cl-hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
1220     (inputs
1221      `(("sbcl-alexandria" ,sbcl-alexandria)
1222        ("sbcl-trivial-features" ,sbcl-trivial-features)))
1223     (home-page "https://common-lisp.net/project/babel/")
1224     (synopsis "Charset encoding and decoding library")
1225     (description "Babel is a charset encoding and decoding library, not unlike
1226 GNU libiconv, but completely written in Common Lisp.")
1227     (license license:expat)))
1228
1229 (define-public cl-babel
1230   (sbcl-package->cl-source-package sbcl-babel))
1231
1232 (define-public ecl-babel
1233   (sbcl-package->ecl-package sbcl-babel))
1234
1235 (define-public sbcl-cl-yacc
1236   (package
1237     (name "sbcl-cl-yacc")
1238     (version "0.3")
1239     (source
1240      (origin
1241        (method git-fetch)
1242        (uri (git-reference
1243              (url "https://github.com/jech/cl-yacc")
1244              (commit (string-append "cl-yacc-" version))))
1245        (sha256
1246         (base32
1247          "16946pzf8vvadnyfayvj8rbh4zjzw90h0azz2qk1mxrvhh5wklib"))
1248        (file-name (string-append "cl-yacc-" version "-checkout"))))
1249     (build-system asdf-build-system/sbcl)
1250     (arguments
1251      `(#:asd-file "yacc.asd"
1252        #:asd-system-name "yacc"))
1253     (synopsis "LALR(1) parser generator for Common Lisp, similar in spirit to Yacc")
1254     (description
1255      "CL-Yacc is a LALR(1) parser generator for Common Lisp, similar in spirit
1256 to AT&T Yacc, Berkeley Yacc, GNU Bison, Zebu, lalr.cl or lalr.scm.
1257
1258 CL-Yacc uses the algorithm due to Aho and Ullman, which is the one also used
1259 by AT&T Yacc, Berkeley Yacc and Zebu.  It does not use the faster algorithm due
1260 to DeRemer and Pennello, which is used by Bison and lalr.scm (not lalr.cl).")
1261     (home-page "https://www.irif.fr/~jch//software/cl-yacc/")
1262     (license license:expat)))
1263
1264 (define-public cl-yacc
1265   (sbcl-package->cl-source-package sbcl-cl-yacc))
1266
1267 (define-public ecl-cl-yacc
1268   (sbcl-package->ecl-package sbcl-cl-yacc))
1269
1270 (define-public sbcl-jpl-util
1271   (let ((commit "0311ed374e19a49d43318064d729fe3abd9a3b62"))
1272     (package
1273       (name "sbcl-jpl-util")
1274       (version "20151005")
1275       (source
1276        (origin
1277          (method git-fetch)
1278          (uri (git-reference
1279                ;; Quicklisp uses this fork.
1280                (url "https://github.com/hawkir/cl-jpl-util")
1281                (commit commit)))
1282          (file-name
1283           (git-file-name "jpl-util" version))
1284          (sha256
1285           (base32
1286            "0nc0rk9n8grkg3045xsw34whmcmddn2sfrxki4268g7kpgz0d2yz"))))
1287       (build-system asdf-build-system/sbcl)
1288       (synopsis "Collection of Common Lisp utility functions and macros")
1289       (description
1290        "@command{cl-jpl-util} is a collection of Common Lisp utility functions
1291 and macros, primarily for software projects written in CL by the author.")
1292       (home-page "https://www.thoughtcrime.us/software/cl-jpl-util/")
1293       (license license:isc))))
1294
1295 (define-public cl-jpl-util
1296   (sbcl-package->cl-source-package sbcl-jpl-util))
1297
1298 (define-public ecl-jpl-util
1299   (sbcl-package->ecl-package sbcl-jpl-util))
1300
1301 (define-public sbcl-jpl-queues
1302   (package
1303     (name "sbcl-jpl-queues")
1304     (version "0.1")
1305     (source
1306      (origin
1307        (method url-fetch)
1308        (uri (string-append
1309              "http://www.thoughtcrime.us/software/jpl-queues/jpl-queues-"
1310              version
1311              ".tar.gz"))
1312        (sha256
1313         (base32
1314          "1wvvv7j117h9a42qaj1g4fh4mji28xqs7s60rn6d11gk9jl76h96"))))
1315     (build-system asdf-build-system/sbcl)
1316     (inputs
1317      `(("jpl-util" ,sbcl-jpl-util)
1318        ("bordeaux-threads" ,sbcl-bordeaux-threads)))
1319     (arguments
1320      ;; Tests seem to be broken.
1321      `(#:tests? #f))
1322     (synopsis "Common Lisp library implementing a few different kinds of queues")
1323     (description
1324      "A Common Lisp library implementing a few different kinds of queues:
1325
1326 @itemize
1327 @item Bounded and unbounded FIFO queues.
1328 @item Lossy bounded FIFO queues that drop elements when full.
1329 @item Unbounded random-order queues that use less memory than unbounded FIFO queues.
1330 @end itemize
1331
1332 Additionally, a synchronization wrapper is provided to make any queue
1333 conforming to the @command{jpl-queues} API thread-safe for lightweight
1334 multithreading applications.  (See Calispel for a more sophisticated CL
1335 multithreaded message-passing library with timeouts and alternation among
1336 several blockable channels.)")
1337     (home-page "https://www.thoughtcrime.us/software/jpl-queues/")
1338     (license license:isc)))
1339
1340 (define-public cl-jpl-queues
1341   (sbcl-package->cl-source-package sbcl-jpl-queues))
1342
1343 (define-public ecl-jpl-queues
1344   (sbcl-package->ecl-package sbcl-jpl-queues))
1345
1346 (define-public sbcl-eos
1347   (let ((commit "b0faca83781ead9a588661e37bd47f90362ccd94"))
1348     (package
1349       (name "sbcl-eos")
1350       (version (git-version "0.0.0" "1" commit))
1351       (source
1352        (origin
1353          (method git-fetch)
1354          (uri (git-reference
1355                (url "https://github.com/adlai/Eos")
1356                (commit commit)))
1357          (sha256
1358           (base32
1359            "1bq8cfg087iyxmxi1mwgx5cfgy3b8ydrf81xljcis8qbgb2vszph"))
1360          (file-name (git-file-name "eos" version))))
1361       (build-system asdf-build-system/sbcl)
1362       (synopsis "Unit Testing for Common Lisp")
1363       (description
1364        "Eos was a unit testing library for Common Lisp.
1365 It began as a fork of FiveAM; however, FiveAM development has continued, while
1366 that of Eos has not.  Thus, Eos is now deprecated in favor of FiveAM.")
1367       (home-page "https://github.com/adlai/Eos")
1368       (license license:expat))))
1369
1370 (define-public cl-eos
1371   (sbcl-package->cl-source-package sbcl-eos))
1372
1373 (define-public ecl-eos
1374   (sbcl-package->ecl-package sbcl-eos))
1375
1376 (define-public sbcl-esrap
1377   (let ((commit "133be8b05c2aae48696fe5b739eea2fa573fa48d"))
1378     (package
1379       (name "sbcl-esrap")
1380       (version (git-version "0.0.0" "1" commit))
1381       (source
1382        (origin
1383          (method git-fetch)
1384          (uri (git-reference
1385                (url "https://github.com/nikodemus/esrap")
1386                (commit commit)))
1387          (sha256
1388           (base32
1389            "02d5clihsdryhf7pix8c5di2571fdsffh75d40fkzhws90r5mksl"))
1390          (file-name (git-file-name "esrap" version))))
1391       (build-system asdf-build-system/sbcl)
1392       (native-inputs
1393        `(("eos" ,sbcl-eos)))            ;For testing only.
1394       (inputs
1395        `(("alexandria" ,sbcl-alexandria)))
1396       (synopsis "Common Lisp packrat parser")
1397       (description
1398        "A packrat parser for Common Lisp.
1399 In addition to regular Packrat / Parsing Grammar / TDPL features ESRAP supports:
1400
1401 @itemize
1402 @item dynamic redefinition of nonterminals
1403 @item inline grammars
1404 @item semantic predicates
1405 @item introspective facilities (describing grammars, tracing, setting breaks)
1406 @end itemize\n")
1407       (home-page "https://nikodemus.github.io/esrap/")
1408       (license license:expat))))
1409
1410 (define-public cl-esrap
1411   (sbcl-package->cl-source-package sbcl-esrap))
1412
1413 (define-public ecl-esrap
1414   (sbcl-package->ecl-package sbcl-esrap))
1415
1416 (define-public sbcl-split-sequence
1417   (package
1418     (name "sbcl-split-sequence")
1419     (version "2.0.0")
1420     (source
1421      (origin
1422        (method git-fetch)
1423        (uri (git-reference
1424              (url "https://github.com/sharplispers/split-sequence")
1425              (commit (string-append "v" version))))
1426        (sha256
1427         (base32
1428          "0jcpnx21hkfwqj5fvp7kc6pn1qcz9hk7g2s5x8h0349x1j2irln0"))
1429        (file-name (git-file-name "split-sequence" version))))
1430     (build-system asdf-build-system/sbcl)
1431     (native-inputs
1432      `(("fiveam" ,sbcl-fiveam)))
1433     (synopsis "Member of the Common Lisp Utilities family of programs")
1434     (description
1435      "Splits sequence into a list of subsequences delimited by objects
1436 satisfying the test.")
1437     (home-page "https://cliki.net/split-sequence")
1438     (license license:expat)))
1439
1440 (define-public cl-split-sequence
1441   (sbcl-package->cl-source-package sbcl-split-sequence))
1442
1443 (define-public ecl-split-sequence
1444   (sbcl-package->ecl-package sbcl-split-sequence))
1445
1446 (define-public sbcl-html-encode
1447   (package
1448     (name "sbcl-html-encode")
1449     (version "1.2")
1450     (source
1451      (origin
1452        (method url-fetch)
1453        (uri (string-append
1454              "http://beta.quicklisp.org/archive/html-encode/2010-10-06/html-encode-"
1455              version ".tgz"))
1456        (sha256
1457         (base32
1458          "06mf8wn95yf5swhmzk4vp0xr4ylfl33dgfknkabbkd8n6jns8gcf"))
1459        (file-name (string-append "colorize" version "-checkout"))))
1460     (build-system asdf-build-system/sbcl)
1461     (synopsis "Common Lisp library for encoding text in various web-savvy encodings")
1462     (description
1463      "A library for encoding text in various web-savvy encodings.")
1464     (home-page "http://quickdocs.org/html-encode/")
1465     (license license:expat)))
1466
1467 (define-public cl-html-encode
1468   (sbcl-package->cl-source-package sbcl-html-encode))
1469
1470 (define-public ecl-html-encode
1471   (sbcl-package->ecl-package sbcl-html-encode))
1472
1473 (define-public sbcl-colorize
1474   (let ((commit "ea676b584e0899cec82f21a9e6871172fe3c0eb5"))
1475     (package
1476       (name "sbcl-colorize")
1477       (version (git-version "0.0.0" "1" commit))
1478       (source
1479        (origin
1480          (method git-fetch)
1481          (uri (git-reference
1482                (url "https://github.com/kingcons/colorize")
1483                (commit commit)))
1484          (sha256
1485           (base32
1486            "1pdg4kiaczmr3ivffhirp7m3lbr1q27rn7dhaay0vwghmi31zcw9"))
1487          (file-name (git-file-name "colorize" version))))
1488       (build-system asdf-build-system/sbcl)
1489       (inputs
1490        `(("alexandria" ,sbcl-alexandria)
1491          ("split-sequence" ,sbcl-split-sequence)
1492          ("html-encode" ,sbcl-html-encode)))
1493       (synopsis "Common Lisp for syntax highlighting")
1494       (description
1495        "@command{colorize} is a Lisp library for syntax highlighting
1496 supporting the following languages: Common Lisp, Emacs Lisp, Scheme, Clojure,
1497 C, C++, Java, Python, Erlang, Haskell, Objective-C, Diff, Webkit.")
1498       (home-page "https://github.com/kingcons/colorize")
1499       ;; TODO: Missing license?
1500       (license license:expat))))
1501
1502 (define-public cl-colorize
1503   (sbcl-package->cl-source-package sbcl-colorize))
1504
1505 (define-public ecl-colorize
1506   (sbcl-package->ecl-package sbcl-colorize))
1507
1508 (define-public sbcl-3bmd
1509   (let ((commit "192ea13435b605a96ef607df51317056914cabbd"))
1510     (package
1511       (name "sbcl-3bmd")
1512       (version (git-version "0.0.0" "1" commit))
1513       (source
1514        (origin
1515          (method git-fetch)
1516          (uri (git-reference
1517                (url "https://github.com/3b/3bmd")
1518                (commit commit)))
1519          (sha256
1520           (base32
1521            "1rgv3gi7wf963ikmmpk132wgn0icddf226gq3bmcnk1fr3v9gf2f"))
1522          (file-name (git-file-name "3bmd" version))))
1523       (build-system asdf-build-system/sbcl)
1524       (arguments
1525        ;; FIXME: We need to specify the name because the build-system thinks
1526        ;; "3" is a version marker.
1527        `(#:asd-system-name "3bmd"))
1528       (inputs
1529        `(("esrap" ,sbcl-esrap)
1530          ("split-sequence" ,sbcl-split-sequence)))
1531       (synopsis "Markdown processor in Command Lisp using esrap parser")
1532       (description
1533        "Common Lisp Markdown -> HTML converter, using @command{esrap} for
1534 parsing, and grammar based on @command{peg-markdown}.")
1535       (home-page "https://github.com/3b/3bmd")
1536       (license license:expat))))
1537
1538 (define-public cl-3bmd
1539   (sbcl-package->cl-source-package sbcl-3bmd))
1540
1541 (define-public ecl-3bmd
1542   (sbcl-package->ecl-package sbcl-3bmd))
1543
1544 (define-public sbcl-3bmd-ext-code-blocks
1545   (let ((commit "192ea13435b605a96ef607df51317056914cabbd"))
1546     (package
1547       (inherit sbcl-3bmd)
1548       (name "sbcl-3bmd-ext-code-blocks")
1549       (arguments
1550        `(#:asd-system-name "3bmd-ext-code-blocks"
1551          #:asd-file "3bmd-ext-code-blocks.asd"))
1552       (inputs
1553        `(("3bmd" ,sbcl-3bmd)
1554          ("colorize" ,sbcl-colorize)))
1555       (synopsis "3bmd extension which adds support for GitHub-style fenced
1556 code blocks")
1557       (description
1558        "3bmd extension which adds support for GitHub-style fenced code blocks,
1559 with @command{colorize} support."))))
1560
1561 (define-public cl-3bmd-ext-code-blocks
1562   (sbcl-package->cl-source-package sbcl-3bmd-ext-code-blocks))
1563
1564 (define-public ecl-3bmd-ext-code-blocks
1565   (sbcl-package->ecl-package sbcl-3bmd-ext-code-blocks))
1566
1567 (define-public sbcl-cl-fad
1568   (package
1569     (name "sbcl-cl-fad")
1570     (version "0.7.6")
1571     (source
1572      (origin
1573        (method git-fetch)
1574        (uri (git-reference
1575              (url "https://github.com/edicl/cl-fad/")
1576              (commit (string-append "v" version))))
1577        (sha256
1578         (base32
1579          "1gc8i82v6gks7g0lnm54r4prk2mklidv2flm5fvbr0a7rsys0vpa"))
1580        (file-name (string-append "cl-fad" version "-checkout"))))
1581     (build-system asdf-build-system/sbcl)
1582     (inputs
1583      `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
1584     (synopsis "Portable pathname library for Common Lisp")
1585     (description
1586      "CL-FAD (for \"Files and Directories\") is a thin layer atop Common
1587 Lisp's standard pathname functions.  It is intended to provide some
1588 unification between current CL implementations on Windows, OS X, Linux, and
1589 Unix.  Most of the code was written by Peter Seibel for his book Practical
1590 Common Lisp.")
1591     (home-page "https://edicl.github.io/cl-fad/")
1592     (license license:bsd-2)))
1593
1594 (define-public cl-fad
1595   (sbcl-package->cl-source-package sbcl-cl-fad))
1596
1597 (define-public ecl-cl-fad
1598   (sbcl-package->ecl-package sbcl-cl-fad))
1599
1600 (define-public sbcl-rt
1601   (package
1602     (name "sbcl-rt")
1603     (version "1990.12.19")
1604     (source
1605      (origin
1606        (method url-fetch)
1607        (uri (string-append "http://beta.quicklisp.org/archive/rt/2010-10-06/rt-"
1608                            "20101006-git" ".tgz"))
1609        (sha256
1610         (base32
1611          "1jncar0xwkqk8yrc2dln389ivvgzs7ijdhhs3zpfyi5d21f0qa1v"))))
1612     (build-system asdf-build-system/sbcl)
1613     (synopsis "MIT Regression Tester")
1614     (description
1615      "RT provides a framework for writing regression test suites.")
1616     (home-page "https://github.com/sharplispers/nibbles")
1617     (license license:unlicense)))
1618
1619 (define-public cl-rt
1620   (sbcl-package->cl-source-package sbcl-rt))
1621
1622 (define-public ecl-rt
1623   (sbcl-package->ecl-package sbcl-rt))
1624
1625 (define-public sbcl-nibbles
1626   (package
1627     (name "sbcl-nibbles")
1628     (version "0.14")
1629     (source
1630      (origin
1631        (method git-fetch)
1632        (uri (git-reference
1633              (url "https://github.com/sharplispers/nibbles/")
1634              (commit (string-append "v" version))))
1635        (sha256
1636         (base32
1637          "1v7qfgpvdr6nz7v63dj69d26dis0kff3rd8xamr1llfdvza2pm8f"))
1638        (file-name (git-file-name "nibbles" version))))
1639     (build-system asdf-build-system/sbcl)
1640     (native-inputs
1641      ;; Tests only.
1642      `(("rt" ,sbcl-rt)))
1643     (synopsis "Common Lisp library for accessing octet-addressed blocks of data")
1644     (description
1645      "When dealing with network protocols and file formats, it's common to
1646 have to read or write 16-, 32-, or 64-bit datatypes in signed or unsigned
1647 flavors.  Common Lisp sort of supports this by specifying :element-type for
1648 streams, but that facility is underspecified and there's nothing similar for
1649 read/write from octet vectors.  What most people wind up doing is rolling their
1650 own small facility for their particular needs and calling it a day.
1651
1652 This library attempts to be comprehensive and centralize such
1653 facilities.  Functions to read 16-, 32-, and 64-bit quantities from octet
1654 vectors in signed or unsigned flavors are provided; these functions are also
1655 SETFable.  Since it's sometimes desirable to read/write directly from streams,
1656 functions for doing so are also provided.  On some implementations,
1657 reading/writing IEEE singles/doubles (i.e. single-float and double-float) will
1658 also be supported.")
1659     (home-page "https://github.com/sharplispers/nibbles")
1660     (license license:bsd-3)))
1661
1662 (define-public cl-nibbles
1663   (sbcl-package->cl-source-package sbcl-nibbles))
1664
1665 (define-public ecl-nibbles
1666   (sbcl-package->ecl-package sbcl-nibbles))
1667
1668 (define-public sbcl-ironclad
1669   (package
1670     (name "sbcl-ironclad")
1671     (version "0.48")
1672     (source
1673      (origin
1674        (method git-fetch)
1675        (uri (git-reference
1676              (url "https://github.com/sharplispers/ironclad/")
1677              (commit (string-append "v" version))))
1678        (sha256
1679         (base32
1680          "1wzczpgvgjc5h8ghz75kxi7iykmqxqchdhgdhkif9j99kyqvbyam"))
1681        (file-name (git-file-name name version))))
1682     (build-system asdf-build-system/sbcl)
1683     (native-inputs
1684      ;; Tests only.
1685      `(("rt" ,sbcl-rt)))
1686     (inputs
1687      `(("bordeaux-threads" ,sbcl-bordeaux-threads)
1688        ("flexi-streams" ,sbcl-flexi-streams)))
1689     (synopsis "Cryptographic toolkit written in Common Lisp")
1690     (description
1691      "Ironclad is a cryptography library written entirely in Common Lisp.
1692 It includes support for several popular ciphers, digests, MACs and public key
1693 cryptography algorithms.  For several implementations that support Gray
1694 streams, support is included for convenient stream wrappers.")
1695     (home-page "https://github.com/sharplispers/ironclad")
1696     (license license:bsd-3)))
1697
1698 (define-public cl-ironclad
1699   (sbcl-package->cl-source-package sbcl-ironclad))
1700
1701 (define-public ecl-ironclad
1702   (sbcl-package->ecl-package sbcl-ironclad))
1703
1704 (define-public sbcl-named-readtables
1705   (let ((commit "4dfb89fa1af6b305b6492b8af042f5190c11e9fc")
1706         (revision "1"))
1707     (package
1708       (name "sbcl-named-readtables")
1709       (version (string-append "0.9-" revision "." (string-take commit 7)))
1710       (source
1711        (origin
1712          (method git-fetch)
1713          (uri (git-reference
1714                (url "https://github.com/melisgl/named-readtables.git")
1715                (commit commit)))
1716          (sha256
1717           (base32 "083kgh5462iqbb4px6kq8s7sggvpvkm36hx4qi9rnaw53b6ilqkk"))
1718          (file-name (git-file-name "named-readtables" version))))
1719       (build-system asdf-build-system/sbcl)
1720       (arguments
1721        ;; Tests seem to be broken.
1722        `(#:tests? #f))
1723       (home-page "https://github.com/melisgl/named-readtables/")
1724       (synopsis "Library that creates a namespace for named readtables")
1725       (description "Named readtables is a library that creates a namespace for
1726 named readtables, which is akin to package namespacing in Common Lisp.")
1727       (license license:bsd-3))))
1728
1729 (define-public cl-named-readtables
1730   (sbcl-package->cl-source-package sbcl-named-readtables))
1731
1732 (define-public ecl-named-readtables
1733   (sbcl-package->ecl-package sbcl-named-readtables))
1734
1735 (define-public sbcl-pythonic-string-reader
1736   (let ((commit "47a70ba1e32362e03dad6ef8e6f36180b560f86a"))
1737     (package
1738       (name "sbcl-pythonic-string-reader")
1739       (version (git-version "0.0.0" "1" commit))
1740       (source
1741        (origin
1742          (method git-fetch)
1743          (uri (git-reference
1744                (url "https://github.com/smithzvk/pythonic-string-reader/")
1745                (commit commit)))
1746          (sha256
1747           (base32 "1b5iryqw8xsh36swckmz8rrngmc39k92si33fgy5pml3n9l5rq3j"))
1748          (file-name (git-file-name "pythonic-string-reader" version))))
1749       (build-system asdf-build-system/sbcl)
1750       (inputs
1751        `(("named-readtables" ,sbcl-named-readtables)))
1752       (home-page "https://github.com/smithzvk/pythonic-string-reader")
1753       (synopsis "Read table modification inspired by Python's three quote strings")
1754       (description "This piece of code sets up some reader macros that make it
1755 simpler to input string literals which contain backslashes and double quotes
1756 This is very useful for writing complicated docstrings and, as it turns out,
1757 writing code that contains string literals that contain code themselves.")
1758       (license license:bsd-3))))
1759
1760 (define-public cl-pythonic-string-reader
1761   (sbcl-package->cl-source-package sbcl-pythonic-string-reader))
1762
1763 (define-public ecl-pythonic-string-reader
1764   (sbcl-package->ecl-package sbcl-pythonic-string-reader))
1765
1766 ;; SLIME does not have a ASDF system definition to build all of Swank.  As a
1767 ;; result, the asdf-build-system/sbcl will produce an almost empty package.
1768 ;; Some work was done to fix this at
1769 ;; https://github.com/sionescu/slime/tree/swank-asdf but it was never merged
1770 ;; and is now lagging behind.  Building SBCL fasls might not be worth the
1771 ;; hassle, so let's just ship the source then.
1772 (define-public cl-slime-swank
1773   (package
1774     (name "cl-slime-swank")
1775     (version "2.24")
1776     (source
1777      (origin
1778        (file-name (string-append name "-" version ".tar.gz"))
1779        (method git-fetch)
1780        (uri (git-reference
1781              (url "https://github.com/slime/slime/")
1782              (commit (string-append "v" version))))
1783        (sha256
1784         (base32
1785          "0js24x42m7b5iymb4rxz501dff19vav5pywnzv50b673rbkaaqvh"))))
1786     (build-system asdf-build-system/source)
1787     (home-page "https://github.com/slime/slime")
1788     (synopsis "Common Lisp Swank server")
1789     (description
1790      "This is only useful if you want to start a Swank server in a Lisp
1791 processes that doesn't run under Emacs.  Lisp processes created by
1792 @command{M-x slime} automatically start the server.")
1793     (license (list license:gpl2+ license:public-domain))))
1794
1795 (define-public sbcl-slime-swank
1796   (deprecated-package "sbcl-slime-swank" cl-slime-swank))
1797
1798 (define-public sbcl-mgl-pax
1799   (let ((commit "818448418d6b9de74620f606f5b23033c6082769"))
1800     (package
1801       (name "sbcl-mgl-pax")
1802       (version (git-version "0.0.0" "1" commit))
1803       (source
1804        (origin
1805          (method git-fetch)
1806          (uri (git-reference
1807                (url "https://github.com/melisgl/mgl-pax")
1808                (commit commit)))
1809          (sha256
1810           (base32
1811            "1p97zfkh130bdxqqxwaw2j9psv58751wakx7czbfpq410lg7dd7i"))
1812          (file-name (git-file-name "mgl-pax" version))))
1813       (build-system asdf-build-system/sbcl)
1814       (inputs
1815        `(("3bmd" ,sbcl-3bmd)
1816          ("3bmd-ext-code-blocks" ,sbcl-3bmd-ext-code-blocks)
1817          ("babel" ,sbcl-babel)
1818          ("cl-fad" ,sbcl-cl-fad)
1819          ("ironclad" ,sbcl-ironclad)
1820          ("named-readtables" ,sbcl-named-readtables)
1821          ("pythonic-string-reader" ,sbcl-pythonic-string-reader)))
1822       (propagated-inputs
1823        ;; Packages having mgl-pax as input complain that it can't find
1824        ;; swank if we put it in inputs, so let's put it in propageted-inputs.
1825        `(("swank" ,cl-slime-swank)))
1826       (synopsis "Exploratory programming environment and documentation generator")
1827       (description
1828        "PAX provides an extremely poor man's Explorable Programming
1829 environment.  Narrative primarily lives in so called sections that mix markdown
1830 docstrings with references to functions, variables, etc, all of which should
1831 probably have their own docstrings.
1832
1833 The primary focus is on making code easily explorable by using SLIME's
1834 @command{M-.} (@command{slime-edit-definition}).  See how to enable some
1835 fanciness in Emacs Integration.  Generating documentation from sections and all
1836 the referenced items in Markdown or HTML format is also implemented.
1837
1838 With the simplistic tools provided, one may accomplish similar effects as with
1839 Literate Programming, but documentation is generated from code, not vice versa
1840 and there is no support for chunking yet.  Code is first, code must look
1841 pretty, documentation is code.")
1842       (home-page "http://quotenil.com/")
1843       (license license:expat))))
1844
1845 (define-public cl-mgl-pax
1846   (sbcl-package->cl-source-package sbcl-mgl-pax))
1847
1848 (define-public ecl-mgl-pax
1849   (sbcl-package->ecl-package sbcl-mgl-pax))
1850
1851 (define-public sbcl-lisp-unit
1852   (let ((commit "89653a232626b67400bf9a941f9b367da38d3815"))
1853     (package
1854       (name "sbcl-lisp-unit")
1855       (version (git-version "0.0.0" "1" commit))
1856       (source
1857        (origin
1858          (method git-fetch)
1859          (uri (git-reference
1860                (url "https://github.com/OdonataResearchLLC/lisp-unit")
1861                (commit commit)))
1862          (sha256
1863           (base32
1864            "0p6gdmgr7p383nvd66c9y9fp2bjk4jx1lpa5p09g43hr9y9pp9ry"))
1865          (file-name (git-file-name "lisp-unit" version))))
1866       (build-system asdf-build-system/sbcl)
1867       (synopsis "Common Lisp Test framework inspired by JUnit to be simple of use")
1868       (description
1869        "@command{lisp-unit} is a Common Lisp library that supports unit
1870 testing.  It is an extension of the library written by Chris Riesbeck.")
1871       (home-page "https://github.com/OdonataResearchLLC/lisp-unit")
1872       (license license:expat))))
1873
1874 (define-public cl-lisp-unit
1875   (sbcl-package->cl-source-package sbcl-lisp-unit))
1876
1877 (define-public ecl-lisp-unit
1878   (sbcl-package->ecl-package sbcl-lisp-unit))
1879
1880 (define-public sbcl-anaphora
1881   (package
1882     (name "sbcl-anaphora")
1883     (version "0.9.6")
1884     (source
1885      (origin
1886        (method git-fetch)
1887        (uri (git-reference
1888              (url "https://github.com/tokenrove/anaphora")
1889              (commit version)))
1890        (sha256
1891         (base32
1892          "19wfrk3asimznkli0x2rfy637hwpdgqyvwj3vhq9x7vjvyf5vv6x"))
1893        (file-name (git-file-name "anaphora" version))))
1894     (build-system asdf-build-system/sbcl)
1895     (native-inputs
1896      `(("rt" ,sbcl-rt)))
1897     (synopsis "The anaphoric macro collection from Hell")
1898     (description
1899      "Anaphora is the anaphoric macro collection from Hell: it includes many
1900 new fiends in addition to old friends like @command{aif} and
1901 @command{awhen}.")
1902     (home-page "https://github.com/tokenrove/anaphora")
1903     (license license:public-domain)))
1904
1905 (define-public cl-anaphora
1906   (sbcl-package->cl-source-package sbcl-anaphora))
1907
1908 (define-public ecl-anaphora
1909   (sbcl-package->ecl-package sbcl-anaphora))
1910
1911 (define-public sbcl-lift
1912   (let ((commit "7d49a66c62759535624037826891152223d4206c"))
1913     (package
1914       (name "sbcl-lift")
1915       (version (git-version "1.7.1" "1" commit))
1916       (source
1917        (origin
1918          (method git-fetch)
1919          (uri (git-reference
1920                (url "https://github.com/gwkkwg/lift")
1921                (commit commit)))
1922          (sha256
1923           (base32
1924            "127v5avpz1i4m0lkaxqrq8hrl69rdazqaxf6s8awf0nd7wj2g4dp"))
1925          (file-name (git-file-name "lift" version))
1926          (modules '((guix build utils)))
1927          (snippet
1928           ;; Don't keep the bundled website
1929           `(begin
1930              (delete-file-recursively "website")
1931              #t))))
1932       (build-system asdf-build-system/sbcl)
1933       (arguments
1934        ;; The tests require a debugger, but we run with the debugger disabled.
1935        '(#:tests? #f))
1936       (synopsis "LIsp Framework for Testing")
1937       (description
1938        "The LIsp Framework for Testing (LIFT) is a unit and system test tool for LISP.
1939 Though inspired by SUnit and JUnit, it's built with Lisp in mind.  In LIFT,
1940 testcases are organized into hierarchical testsuites each of which can have
1941 its own fixture.  When run, a testcase can succeed, fail, or error.  LIFT
1942 supports randomized testing, benchmarking, profiling, and reporting.")
1943       (home-page "https://github.com/gwkkwg/lift")
1944       (license license:expat))))
1945
1946 (define-public cl-lift
1947   (sbcl-package->cl-source-package sbcl-lift))
1948
1949 (define-public ecl-lift
1950   (sbcl-package->ecl-package sbcl-lift))
1951
1952 (define-public sbcl-let-plus
1953   (let ((commit "5f14af61d501ecead02ec6b5a5c810efc0c9fdbb"))
1954     (package
1955       (name "sbcl-let-plus")
1956       (version (git-version "0.0.0" "1" commit))
1957       (source
1958        (origin
1959          (method git-fetch)
1960          (uri (git-reference
1961                (url "https://github.com/sharplispers/let-plus")
1962                (commit commit)))
1963          (sha256
1964           (base32
1965            "0i050ca2iys9f5mb7dgqgqdxfnc3b0rnjdwv95sqd490vkiwrsaj"))
1966          (file-name (git-file-name "let-plus" version))))
1967       (build-system asdf-build-system/sbcl)
1968       (inputs
1969        `(("alexandria" ,sbcl-alexandria)
1970          ("anaphora" ,sbcl-anaphora)))
1971       (native-inputs
1972        `(("lift" ,sbcl-lift)))
1973       (synopsis "Destructuring extension of let*")
1974       (description
1975        "This library implements the let+ macro, which is a dectructuring
1976 extension of let*.  It features:
1977
1978 @itemize
1979 @item Clean, consistent syntax and small implementation (less than 300 LOC,
1980 not counting tests)
1981 @item Placeholder macros allow editor hints and syntax highlighting
1982 @item @command{&ign} for ignored values (in forms where that makes sense)
1983 @item Very easy to extend
1984 @end itemize\n")
1985       (home-page "https://github.com/sharplispers/let-plus")
1986       (license license:boost1.0))))
1987
1988 (define-public cl-let-plus
1989   (sbcl-package->cl-source-package sbcl-let-plus))
1990
1991 (define-public ecl-let-plus
1992   (sbcl-package->ecl-package sbcl-let-plus))
1993
1994 (define-public sbcl-cl-colors
1995   (let ((commit "827410584553f5c717eec6182343b7605f707f75"))
1996     (package
1997       (name "sbcl-cl-colors")
1998       (version (git-version "0.0.0" "1" commit))
1999       (source
2000        (origin
2001          (method git-fetch)
2002          (uri (git-reference
2003                (url "https://github.com/tpapp/cl-colors")
2004                (commit commit)))
2005          (sha256
2006           (base32
2007            "0l446lday4hybsm9bq3jli97fvv8jb1d33abg79vbylpwjmf3y9a"))
2008          (file-name (git-file-name "cl-colors" version))))
2009       (build-system asdf-build-system/sbcl)
2010       (inputs
2011        `(("alexandria" ,sbcl-alexandria)
2012          ("let-plus" ,sbcl-let-plus)))
2013       (synopsis "Simple color library for Common Lisp")
2014       (description
2015        "This is a very simple color library for Common Lisp, providing
2016
2017 @itemize
2018 @item Types for representing colors in HSV and RGB spaces.
2019 @item Simple conversion functions between the above types (and also
2020 hexadecimal representation for RGB).
2021 @item Some predefined colors (currently X11 color names – of course the
2022 library does not depend on X11).Because color in your terminal is nice.
2023 @end itemize
2024
2025 This library is no longer supported by its author.")
2026       (home-page "https://github.com/tpapp/cl-colors")
2027       (license license:boost1.0))))
2028
2029 (define-public cl-colors
2030   (sbcl-package->cl-source-package sbcl-cl-colors))
2031
2032 (define-public ecl-cl-colors
2033   (sbcl-package->ecl-package sbcl-cl-colors))
2034
2035 (define-public sbcl-cl-ansi-text
2036   (let ((commit "53badf7878f27f22f2d4a2a43e6df458e43acbe9"))
2037     (package
2038       (name "sbcl-cl-ansi-text")
2039       (version (git-version "1.0.0" "1" commit))
2040       (source
2041        (origin
2042          (method git-fetch)
2043          (uri (git-reference
2044                (url "https://github.com/pnathan/cl-ansi-text")
2045                (commit commit)))
2046          (sha256
2047           (base32
2048            "11i27n0dbz5lmygiw65zzr8lx0rac6b6yysqranphn31wls6ja3v"))
2049          (file-name (git-file-name "cl-ansi-text" version))))
2050       (build-system asdf-build-system/sbcl)
2051       (inputs
2052        `(("alexandria" ,sbcl-alexandria)
2053          ("cl-colors" ,sbcl-cl-colors)))
2054       (native-inputs
2055        `(("fiveam" ,sbcl-fiveam)))
2056       (synopsis "ANSI terminal color implementation for Common Lisp")
2057       (description
2058        "@command{cl-ansi-text} provides utilities which enable printing to an
2059 ANSI terminal with colored text.  It provides the macro @command{with-color}
2060 which causes everything printed in the body to be displayed with the provided
2061 color.  It further provides functions which will print the argument with the
2062 named color.")
2063       (home-page "https://github.com/pnathan/cl-ansi-text")
2064       (license license:llgpl))))
2065
2066 (define-public cl-ansi-text
2067   (sbcl-package->cl-source-package sbcl-cl-ansi-text))
2068
2069 (define-public ecl-cl-ansi-text
2070   (sbcl-package->ecl-package sbcl-cl-ansi-text))
2071
2072 (define-public sbcl-prove-asdf
2073   (let ((commit "4f9122bd393e63c5c70c1fba23070622317cfaa0"))
2074     (package
2075       (name "sbcl-prove-asdf")
2076       (version (git-version "1.0.0" "1" commit))
2077       (source
2078        (origin
2079          (method git-fetch)
2080          (uri (git-reference
2081                (url "https://github.com/fukamachi/prove")
2082                (commit commit)))
2083          (sha256
2084           (base32
2085            "07sbfw459z8bbjvx1qlmfa8qk2mvbjnnzi2mi0x72blaj8bkl4vc"))
2086          (file-name (git-file-name "prove" version))))
2087       (build-system asdf-build-system/sbcl)
2088       (arguments
2089        `(#:asd-file "prove-asdf.asd"))
2090       (synopsis "Test requirement for the Common Lisp 'prove' library")
2091       (description
2092        "Test requirement for the Common Lisp @command{prove} library.")
2093       (home-page "https://github.com/fukamachi/prove")
2094       (license license:expat))))
2095
2096 (define-public cl-prove-asdf
2097   (sbcl-package->cl-source-package sbcl-prove-asdf))
2098
2099 (define-public ecl-prove-asdf
2100   (sbcl-package->ecl-package sbcl-prove-asdf))
2101
2102 (define-public sbcl-prove
2103   (package
2104     (inherit sbcl-prove-asdf)
2105     (name "sbcl-prove")
2106     (inputs
2107      `(("alexandria" ,sbcl-alexandria)
2108        ("cl-ppcre" ,sbcl-cl-ppcre)
2109        ("cl-ansi-text" ,sbcl-cl-ansi-text)))
2110     (native-inputs
2111      `(("prove-asdf" ,sbcl-prove-asdf)))
2112     (arguments
2113      `(#:asd-file "prove.asd"))
2114     (synopsis "Yet another unit testing framework for Common Lisp")
2115     (description
2116      "This project was originally called @command{cl-test-more}.
2117 @command{prove} is yet another unit testing framework for Common Lisp.  The
2118 advantages of @command{prove} are:
2119
2120 @itemize
2121 @item Various simple functions for testing and informative error messages
2122 @item ASDF integration
2123 @item Extensible test reporters
2124 @item Colorizes the report if it's available (note for SLIME)
2125 @item Reports test durations
2126 @end itemize\n")))
2127
2128 (define-public cl-prove
2129   (sbcl-package->cl-source-package sbcl-prove))
2130
2131 (define-public ecl-prove
2132   (sbcl-package->ecl-package sbcl-prove))
2133
2134 (define-public sbcl-proc-parse
2135   (let ((commit "ac3636834d561bdc2686c956dbd82494537285fd"))
2136     (package
2137       (name "sbcl-proc-parse")
2138       (version (git-version "0.0.0" "1" commit))
2139       (source
2140        (origin
2141          (method git-fetch)
2142          (uri (git-reference
2143                (url "https://github.com/fukamachi/proc-parse")
2144                (commit commit)))
2145          (sha256
2146           (base32
2147            "06rnl0h4cx6xv2wj3jczmmcxqn2703inmmvg1s4npbghmijsybfh"))
2148          (file-name (git-file-name "proc-parse" version))))
2149       (build-system asdf-build-system/sbcl)
2150       (inputs
2151        `(("alexandria" ,sbcl-alexandria)
2152          ("babel" ,sbcl-babel)))
2153       (native-inputs
2154        `(("prove" ,sbcl-prove)
2155          ("prove-asdf" ,sbcl-prove-asdf)))
2156       (arguments
2157        ;; TODO: Tests don't find "proc-parse-test", why?
2158        `(#:tests? #f))
2159       (synopsis "Procedural vector parser")
2160       (description
2161        "This is a string/octets parser library for Common Lisp with speed and
2162 readability in mind.  Unlike other libraries, the code is not a
2163 pattern-matching-like, but a char-by-char procedural parser.")
2164       (home-page "https://github.com/fukamachi/proc-parse")
2165       (license license:bsd-2))))
2166
2167 (define-public cl-proc-parse
2168   (sbcl-package->cl-source-package sbcl-proc-parse))
2169
2170 (define-public ecl-proc-parse
2171   (sbcl-package->ecl-package sbcl-proc-parse))
2172
2173 (define-public sbcl-parse-float
2174   (let ((commit "2aae569f2a4b2eb3bfb5401a959425dcf151b09c"))
2175     (package
2176       (name "sbcl-parse-float")
2177       (version (git-version "0.0.0" "1" commit))
2178       (source
2179        (origin
2180          (method git-fetch)
2181          (uri (git-reference
2182                (url "https://github.com/soemraws/parse-float")
2183                (commit commit)))
2184          (sha256
2185           (base32
2186            "08xw8cchhmqcc0byng69m3f5a2izc9y2290jzz2k0qrbibp1fdk7"))
2187          (file-name (git-file-name "proc-parse" version))))
2188       (build-system asdf-build-system/sbcl)
2189       (inputs
2190        `(("alexandria" ,sbcl-alexandria)
2191          ("babel" ,sbcl-babel)))
2192       (native-inputs
2193        `(("prove" ,sbcl-prove)
2194          ("prove-asdf" ,sbcl-prove-asdf)))
2195       (arguments
2196        ;; TODO: Tests don't find "proc-parse-test", why?
2197        `(#:tests? #f))
2198       (synopsis "Parse a floating point value from a string in Common Lisp")
2199       (description
2200        "This package exports the following function to parse floating-point
2201 values from a string in Common Lisp.")
2202       (home-page "https://github.com/soemraws/parse-float")
2203       (license license:public-domain))))
2204
2205 (define-public cl-parse-float
2206   (sbcl-package->cl-source-package sbcl-parse-float))
2207
2208 (define-public ecl-parse-float
2209   (sbcl-package->ecl-package sbcl-parse-float))
2210
2211 (define-public sbcl-ascii-strings
2212   (let ((revision "1")
2213         (changeset "5048480a61243e6f1b02884012c8f25cdbee6d97"))
2214     (package
2215       (name "sbcl-ascii-strings")
2216       (version (string-append "0-" revision "." (string-take changeset 7)))
2217       (source
2218        (origin
2219          (method hg-fetch)
2220          (uri (hg-reference
2221                (url "https://bitbucket.org/vityok/cl-string-match/")
2222                (changeset changeset)))
2223          (sha256
2224           (base32
2225            "01wn5qx562w43ssy92xlfgv79w7p0nv0wbl76mpmba131n9ziq2y"))
2226          (file-name (git-file-name "cl-string-match" version))))
2227       (build-system asdf-build-system/sbcl)
2228       (inputs
2229        `(("alexandria" ,sbcl-alexandria)
2230          ("babel" ,sbcl-babel)))
2231       (arguments
2232        `(#:asd-file "ascii-strings.asd"))
2233       (synopsis "Operations on ASCII strings")
2234       (description
2235        "Operations on ASCII strings.  Essentially this can be any kind of
2236 single-byte encoded strings.")
2237       (home-page "https://bitbucket.org/vityok/cl-string-match/")
2238       (license license:bsd-3))))
2239
2240 (define-public cl-ascii-strings
2241   (sbcl-package->cl-source-package sbcl-ascii-strings))
2242
2243 (define-public ecl-ascii-strings
2244   (sbcl-package->ecl-package sbcl-ascii-strings))
2245
2246 (define-public sbcl-simple-scanf
2247   (package
2248     (inherit sbcl-ascii-strings)
2249     (name "sbcl-simple-scanf")
2250     (inputs
2251      `(("alexandria" ,sbcl-alexandria)
2252        ("iterate" ,sbcl-iterate)
2253        ("proc-parse" ,sbcl-proc-parse)
2254        ("parse-float" ,sbcl-parse-float)))
2255     (arguments
2256      `(#:asd-file "simple-scanf.asd"))
2257     (synopsis "Simple scanf-like functionality implementation")
2258     (description
2259      "A simple scanf-like functionality implementation.")))
2260
2261 (define-public cl-simple-scanf
2262   (sbcl-package->cl-source-package sbcl-simple-scanf))
2263
2264 (define-public ecl-simple-scanf
2265   (sbcl-package->ecl-package sbcl-simple-scanf))
2266
2267 (define-public sbcl-cl-string-match
2268   (package
2269     (inherit sbcl-ascii-strings)
2270     (name "sbcl-cl-string-match")
2271     (inputs
2272      `(("alexandria" ,sbcl-alexandria)
2273        ("ascii-strings" ,sbcl-ascii-strings)
2274        ("yacc" ,sbcl-cl-yacc)
2275        ("jpl-util" ,sbcl-jpl-util)
2276        ("jpl-queues" ,sbcl-jpl-queues)
2277        ("mgl-pax" ,sbcl-mgl-pax)
2278        ("iterate" ,sbcl-iterate)))
2279     ;; TODO: Tests are not evaluated properly.
2280     (native-inputs
2281      ;; For testing:
2282      `(("lisp-unit" ,sbcl-lisp-unit)
2283        ("simple-scanf" ,sbcl-simple-scanf)))
2284     (arguments
2285      `(#:tests? #f
2286        #:asd-file "cl-string-match.asd"))
2287     (synopsis "Portable, dependency-free set of utilities to manipulate strings in Common Lisp")
2288     (description
2289      "@command{cl-strings} is a small, portable, dependency-free set of
2290 utilities that make it even easier to manipulate text in Common Lisp.  It has
2291 100% test coverage and works at least on sbcl, ecl, ccl, abcl and clisp.")))
2292
2293 (define-public cl-string-match
2294   (sbcl-package->cl-source-package sbcl-cl-string-match))
2295
2296 (define-public ecl-cl-string-match
2297   (sbcl-package->ecl-package sbcl-cl-string-match))
2298
2299 (define-public sbcl-ptester
2300   (package
2301     (name "sbcl-ptester")
2302     (version "20160929")
2303     (source
2304      (origin
2305        (method url-fetch)
2306        (uri (string-append "http://beta.quicklisp.org/archive/ptester/"
2307                            (date->string (string->date version "~Y~m~d") "~Y-~m-~d")
2308                            "/ptester-"
2309                            version
2310                            "-git.tgz"))
2311        (sha256
2312         (base32
2313          "04rlq1zljhxc65pm31bah3sq3as24l0sdivz440s79qlnnyh13hz"))))
2314     (build-system asdf-build-system/sbcl)
2315     (home-page "http://quickdocs.org/ptester/")
2316     (synopsis "Portable test harness package")
2317     (description
2318      "@command{ptester} is a portable testing framework based on Franz's
2319 tester module.")
2320     (license license:lgpl3+)))
2321
2322 (define-public cl-ptester
2323   (sbcl-package->cl-source-package sbcl-ptester))
2324
2325 (define-public ecl-ptester
2326   (sbcl-package->ecl-package sbcl-ptester))
2327
2328 (define-public sbcl-puri
2329   (package
2330     (name "sbcl-puri")
2331     (version "20180228")
2332     (source
2333      (origin
2334        (method url-fetch)
2335        (uri (string-append "http://beta.quicklisp.org/archive/puri/"
2336                            (date->string (string->date version "~Y~m~d") "~Y-~m-~d")
2337                            "/puri-"
2338                            version
2339                            "-git.tgz"))
2340        (sha256
2341         (base32
2342          "1s4r5adrjy5asry45xbcbklxhdjydvf6n55z897nvyw33bigrnbz"))))
2343     (build-system asdf-build-system/sbcl)
2344     ;; REVIEW: Webiste down?
2345     (native-inputs
2346      `(("ptester" ,sbcl-ptester)))
2347     (home-page "http://files.kpe.io/puri/")
2348     (synopsis "Portable URI Library")
2349     (description
2350      "This is portable Universal Resource Identifier library for Common Lisp
2351 programs.  It parses URI according to the RFC 2396 specification")
2352     (license license:lgpl3+)))
2353
2354 (define-public cl-puri
2355   (sbcl-package->cl-source-package sbcl-puri))
2356
2357 (define-public ecl-puri
2358   (sbcl-package->ecl-package sbcl-puri))
2359
2360 (define-public sbcl-queues
2361   (let ((commit "47d4da65e9ea20953b74aeeab7e89a831b66bc94"))
2362     (package
2363       (name "sbcl-queues")
2364       (version (git-version "0.0.0" "1" commit))
2365       (source
2366        (origin
2367          (method git-fetch)
2368          (uri (git-reference
2369                (url "https://github.com/oconnore/queues")
2370                (commit commit)))
2371          (file-name (git-file-name "queues" version))
2372          (sha256
2373           (base32
2374            "0wdhfnzi4v6d97pggzj2aw55si94w4327br94jrmyvwf351wqjvv"))))
2375       (build-system asdf-build-system/sbcl)
2376       (home-page "https://github.com/oconnore/queues")
2377       (synopsis "Common Lisp queue library")
2378       (description
2379        "This is a simple queue library for Common Lisp with features such as
2380 non-consing thread safe queues and fibonacci priority queues.")
2381       (license license:expat))))
2382
2383 (define-public cl-queues
2384   (sbcl-package->cl-source-package sbcl-queues))
2385
2386 (define-public ecl-queues
2387   (sbcl-package->ecl-package sbcl-queues))
2388
2389 (define-public sbcl-queues.simple-queue
2390   (package
2391     (inherit sbcl-queues)
2392     (name "sbcl-queues.simple-queue")
2393     (inputs
2394      `(("sbcl-queues" ,sbcl-queues)))
2395     (arguments
2396      `(#:asd-file "queues.simple-queue.asd"))
2397     (synopsis "Simple queue implementation")
2398     (description
2399      "This is a simple queue library for Common Lisp with features such as
2400 non-consing thread safe queues and fibonacci priority queues.")
2401     (license license:expat)))
2402
2403 (define-public cl-queues.simple-queue
2404   (sbcl-package->cl-source-package sbcl-queues.simple-queue))
2405
2406 (define-public ecl-queues.simple-queue
2407   (sbcl-package->ecl-package sbcl-queues.simple-queue))
2408
2409 (define-public sbcl-queues.simple-cqueue
2410   (package
2411     (inherit sbcl-queues)
2412     (name "sbcl-queues.simple-cqueue")
2413     (inputs
2414      `(("sbcl-queues" ,sbcl-queues)
2415        ("sbcl-queues.simple-queue" ,sbcl-queues.simple-queue)
2416        ("bordeaux-threads" ,sbcl-bordeaux-threads)))
2417     (arguments
2418      `(#:asd-file "queues.simple-cqueue.asd"))
2419     (synopsis "Thread safe queue implementation")
2420     (description
2421      "This is a simple queue library for Common Lisp with features such as
2422 non-consing thread safe queues and fibonacci priority queues.")
2423     (license license:expat)))
2424
2425 (define-public cl-queues.simple-cqueue
2426   (sbcl-package->cl-source-package sbcl-queues.simple-cqueue))
2427
2428 (define-public ecl-queues.simple-cqueue
2429   (sbcl-package->ecl-package sbcl-queues.simple-cqueue))
2430
2431 (define-public sbcl-queues.priority-queue
2432   (package
2433     (inherit sbcl-queues)
2434     (name "sbcl-queues.priority-queue")
2435     (inputs
2436      `(("sbcl-queues" ,sbcl-queues)))
2437     (arguments
2438      `(#:asd-file "queues.priority-queue.asd"))
2439     (synopsis "Priority queue (Fibonacci) implementation")
2440     (description
2441      "This is a simple queue library for Common Lisp with features such as
2442 non-consing thread safe queues and fibonacci priority queues.")
2443     (license license:expat)))
2444
2445 (define-public cl-queues.priority-queue
2446   (sbcl-package->cl-source-package sbcl-queues.priority-queue))
2447
2448 (define-public ecl-queues.priority-queue
2449   (sbcl-package->ecl-package sbcl-queues.priority-queue))
2450
2451 (define-public sbcl-queues.priority-cqueue
2452   (package
2453     (inherit sbcl-queues)
2454     (name "sbcl-queues.priority-cqueue")
2455     (inputs
2456      `(("sbcl-queues" ,sbcl-queues)
2457        ("sbcl-queues.priority-queue" ,sbcl-queues.priority-queue)
2458        ("bordeaux-threads" ,sbcl-bordeaux-threads)))
2459     (arguments
2460      `(#:asd-file "queues.priority-cqueue.asd"))
2461     (synopsis "Thread safe fibonacci priority queue implementation")
2462     (description
2463      "This is a simple queue library for Common Lisp with features such as
2464 non-consing thread safe queues and fibonacci priority queues.")
2465     (license license:expat)))
2466
2467 (define-public cl-queues.priority-cqueue
2468   (sbcl-package->cl-source-package sbcl-queues.priority-cqueue))
2469
2470 (define-public ecl-queues.priority-cqueue
2471   (sbcl-package->ecl-package sbcl-queues.priority-cqueue))
2472
2473 (define sbcl-cffi-bootstrap
2474   (package
2475     (name "sbcl-cffi-bootstrap")
2476     (version "0.21.0")
2477     (source
2478      (origin
2479        (method git-fetch)
2480        (uri (git-reference
2481              (url "https://github.com/cffi/cffi.git")
2482              (commit (string-append "v" version))))
2483        (file-name (git-file-name "cffi-bootstrap" version))
2484        (sha256
2485         (base32 "1qalargz9bhp850qv60ffwpdqi4xirzar4l3g6qcg8yc6xqf2cjk"))))
2486     (build-system asdf-build-system/sbcl)
2487     (inputs
2488      `(("libffi" ,libffi)
2489        ("alexandria" ,sbcl-alexandria)
2490        ("babel" ,sbcl-babel)
2491        ("trivial-features" ,sbcl-trivial-features)))
2492     (native-inputs
2493      `(("pkg-config" ,pkg-config)))
2494     (arguments
2495      '(#:phases
2496        (modify-phases %standard-phases
2497          (add-after 'unpack 'fix-paths
2498            (lambda* (#:key inputs #:allow-other-keys)
2499              (substitute* "libffi/libffi.lisp"
2500                (("libffi.so.6" all) (string-append
2501                                      (assoc-ref inputs "libffi")
2502                                      "/lib/" all)))
2503              (substitute* "toolchain/c-toolchain.lisp"
2504                (("\"cc\"") (format #f "~S" (which "gcc")))))))
2505        #:asd-system-name "cffi"
2506        #:tests? #f))
2507     (home-page "https://common-lisp.net/project/cffi/")
2508     (synopsis "Common Foreign Function Interface for Common Lisp")
2509     (description "The Common Foreign Function Interface (CFFI)
2510 purports to be a portable foreign function interface for Common Lisp.
2511 The CFFI library is composed of a Lisp-implementation-specific backend
2512 in the CFFI-SYS package, and a portable frontend in the CFFI
2513 package.")
2514     (license license:expat)))
2515
2516 (define-public sbcl-cffi-toolchain
2517   (package
2518     (inherit sbcl-cffi-bootstrap)
2519     (name "sbcl-cffi-toolchain")
2520     (inputs
2521      `(("libffi" ,libffi)
2522        ("sbcl-cffi" ,sbcl-cffi-bootstrap)))
2523     (arguments
2524      (substitute-keyword-arguments (package-arguments sbcl-cffi-bootstrap)
2525        ((#:asd-system-name _) #f)
2526        ((#:tests? _) #t)))))
2527
2528 (define-public sbcl-cffi-libffi
2529   (package
2530     (inherit sbcl-cffi-toolchain)
2531     (name "sbcl-cffi-libffi")
2532     (inputs
2533      `(("cffi" ,sbcl-cffi-bootstrap)
2534        ("cffi-grovel" ,sbcl-cffi-grovel)
2535        ("trivial-features" ,sbcl-trivial-features)
2536        ("libffi" ,libffi)))))
2537
2538 (define-public sbcl-cffi-grovel
2539   (package
2540     (inherit sbcl-cffi-toolchain)
2541     (name "sbcl-cffi-grovel")
2542     (inputs
2543      `(("libffi" ,libffi)
2544        ("cffi" ,sbcl-cffi-bootstrap)
2545        ("cffi-toolchain" ,sbcl-cffi-toolchain)
2546        ("alexandria" ,sbcl-alexandria)))
2547     (arguments
2548      (substitute-keyword-arguments (package-arguments sbcl-cffi-toolchain)
2549        ((#:phases phases)
2550         `(modify-phases ,phases
2551            (add-after 'build 'install-headers
2552              (lambda* (#:key outputs #:allow-other-keys)
2553                (install-file "grovel/common.h"
2554                              (string-append
2555                               (assoc-ref outputs "out")
2556                               "/include/grovel"))))))))))
2557
2558 (define-public sbcl-cffi
2559   (package
2560     (inherit sbcl-cffi-toolchain)
2561     (name "sbcl-cffi")
2562     (inputs (package-inputs sbcl-cffi-bootstrap))
2563     (native-inputs
2564      `(("cffi-grovel" ,sbcl-cffi-grovel)
2565        ("cffi-libffi" ,sbcl-cffi-libffi)
2566        ("rt" ,sbcl-rt)
2567        ("bordeaux-threads" ,sbcl-bordeaux-threads)
2568        ,@(package-native-inputs sbcl-cffi-bootstrap)))))
2569
2570 (define-public cl-cffi
2571   (sbcl-package->cl-source-package sbcl-cffi))
2572
2573 (define-public sbcl-cl-sqlite
2574   (let ((commit "c738e66d4266ef63a1debc4ef4a1b871a068c112"))
2575     (package
2576       (name "sbcl-cl-sqlite")
2577       (version (git-version "0.2" "1" commit))
2578       (source
2579        (origin
2580          (method git-fetch)
2581          (uri (git-reference
2582                (url "https://github.com/dmitryvk/cl-sqlite")
2583                (commit commit)))
2584          (file-name (git-file-name "cl-sqlite" version))
2585          (sha256
2586           (base32
2587            "1ng45k1hdb84sqjryrfx93g66bsbybmpy301wd0fdybnc5jzr36q"))))
2588       (build-system asdf-build-system/sbcl)
2589       (inputs
2590        `(("iterate" ,sbcl-iterate)
2591          ("cffi" ,sbcl-cffi)
2592          ("sqlite" ,sqlite)))
2593       (native-inputs
2594        `(("fiveam" ,sbcl-fiveam)
2595          ("bordeaux-threads" ,sbcl-bordeaux-threads)))
2596       (arguments
2597        `(#:tests? #f                    ; Upstream seems to have issues with tests: https://github.com/dmitryvk/cl-sqlite/issues/7
2598          #:asd-file "sqlite.asd"
2599          #:asd-system-name "sqlite"
2600          #:phases
2601          (modify-phases %standard-phases
2602            (add-after 'unpack 'fix-paths
2603              (lambda* (#:key inputs #:allow-other-keys)
2604                (substitute* "sqlite-ffi.lisp"
2605                  (("libsqlite3" all) (string-append
2606                                       (assoc-ref inputs "sqlite")"/lib/" all))))))))
2607       (home-page "https://common-lisp.net/project/cl-sqlite/")
2608       (synopsis "Common Lisp binding for SQLite")
2609       (description
2610        "The @command{cl-sqlite} package is an interface to the SQLite embedded
2611 relational database engine.")
2612       (license license:public-domain))))
2613
2614 (define-public cl-sqlite
2615   (sbcl-package->cl-source-package sbcl-cl-sqlite))
2616
2617 (define-public sbcl-parenscript
2618   (let ((commit "061d8e286c81c3f45c84fb2b11ee7d83f590a8f8"))
2619     (package
2620       (name "sbcl-parenscript")
2621       (version (git-version "2.6" "1" commit))
2622       (source
2623        (origin
2624          (method git-fetch)
2625          (uri (git-reference
2626                (url "https://gitlab.common-lisp.net/parenscript/parenscript")
2627                (commit commit)))
2628          (file-name (git-file-name "parenscript" version))
2629          (sha256
2630           (base32
2631            "1kbhgsjbikc73m5cwdp4d4fdafyqcr1b7b630qjrziql0nh6mi3k"))))
2632       (build-system asdf-build-system/sbcl)
2633       (inputs
2634        `(("cl-ppcre" ,sbcl-cl-ppcre)
2635          ("anaphora" ,sbcl-anaphora)
2636          ("named-readtables" ,sbcl-named-readtables)))
2637       (home-page "https://common-lisp.net/project/parenscript/")
2638       (synopsis "Translator from a subset of Common Lisp to JavaScript")
2639       (description
2640        "Parenscript is a translator from an extended subset of Common Lisp to
2641 JavaScript.  Parenscript code can run almost identically on both the
2642 browser (as JavaScript) and server (as Common Lisp).
2643
2644 Parenscript code is treated the same way as Common Lisp code, making the full
2645 power of Lisp macros available for JavaScript.  This provides a web
2646 development environment that is unmatched in its ability to reduce code
2647 duplication and provide advanced meta-programming facilities to web
2648 developers.
2649
2650 At the same time, Parenscript is different from almost all other \"language
2651 X\" to JavaScript translators in that it imposes almost no overhead:
2652
2653 @itemize
2654 @item No run-time dependencies: Any piece of Parenscript code is runnable
2655 as-is.  There are no JavaScript files to include.
2656 @item Native types: Parenscript works entirely with native JavaScript data
2657 types.  There are no new types introduced, and object prototypes are not
2658 touched.
2659 @item Native calling convention: Any JavaScript code can be called without the
2660 need for bindings.  Likewise, Parenscript can be used to make efficient,
2661 self-contained JavaScript libraries.
2662 @item Readable code: Parenscript generates concise, formatted, idiomatic
2663 JavaScript code.  Identifier names are preserved.  This enables seamless
2664 debugging in tools like Firebug.
2665 @item Efficiency: Parenscript introduces minimal overhead for advanced Common
2666 Lisp features.  The generated code is almost as fast as hand-written
2667 JavaScript.
2668 @end itemize\n")
2669       (license license:bsd-3))))
2670
2671 (define-public cl-parenscript
2672   (sbcl-package->cl-source-package sbcl-parenscript))
2673
2674 (define-public ecl-parenscript
2675   (sbcl-package->ecl-package sbcl-parenscript))
2676
2677 (define-public sbcl-cl-json
2678   (let ((commit "6dfebb9540bfc3cc33582d0c03c9ec27cb913e79"))
2679     (package
2680       (name "sbcl-cl-json")
2681       (version (git-version "0.5" "1" commit))
2682       (source
2683        (origin
2684          (method git-fetch)
2685          (uri (git-reference
2686                (url "https://github.com/hankhero/cl-json")
2687                (commit commit)))
2688          (file-name (git-file-name "cl-json" version))
2689          (sha256
2690           (base32
2691            "0fx3m3x3s5ji950yzpazz4s0img3l6b3d6l3jrfjv0lr702496lh"))))
2692       (build-system asdf-build-system/sbcl)
2693       (native-inputs
2694        `(("fiveam" ,sbcl-fiveam)))
2695       (home-page "https://github.com/hankhero/cl-json")
2696       (synopsis "JSON encoder and decoder for Common-Lisp")
2697       (description
2698        "@command{cl-json} provides an encoder of Lisp objects to JSON format
2699 and a corresponding decoder of JSON data to Lisp objects.  Both the encoder
2700 and the decoder are highly customizable; at the same time, the default
2701 settings ensure a very simple mode of operation, similar to that provided by
2702 @command{yason} or @command{st-json}.")
2703       (license license:expat))))
2704
2705 (define-public cl-json
2706   (sbcl-package->cl-source-package sbcl-cl-json))
2707
2708 (define-public ecl-cl-json
2709   (sbcl-package->ecl-package sbcl-cl-json))
2710
2711 (define-public sbcl-unix-opts
2712   (package
2713     (name "sbcl-unix-opts")
2714     (version "0.1.7")
2715     (source
2716      (origin
2717        (method git-fetch)
2718        (uri (git-reference
2719              (url "https://github.com/libre-man/unix-opts")
2720              (commit version)))
2721        (file-name (git-file-name "unix-opts" version))
2722        (sha256
2723         (base32
2724          "08djdi1ard09fijb7w9bdmhmwd98b1hzmcnjw9fqjiqa0g3b44rr"))))
2725     (build-system asdf-build-system/sbcl)
2726     (home-page "https://github.com/hankhero/cl-json")
2727     (synopsis "Unix-style command line options parser")
2728     (description
2729      "This is a minimalistic parser of command line options.  The main
2730 advantage of the library is the ability to concisely define command line
2731 options once and then use this definition for parsing and extraction of
2732 command line arguments, as well as printing description of command line
2733 options (you get --help for free).  This way you don't need to repeat
2734 yourself.  Also, @command{unix-opts} doesn't depend on anything and allows to
2735 precisely control behavior of the parser via Common Lisp restarts.")
2736     (license license:expat)))
2737
2738 (define-public cl-unix-opts
2739   (sbcl-package->cl-source-package sbcl-unix-opts))
2740
2741 (define-public ecl-unix-opts
2742   (sbcl-package->ecl-package sbcl-unix-opts))
2743
2744 (define-public sbcl-trivial-garbage
2745   (package
2746     (name "sbcl-trivial-garbage")
2747     (version "0.21")
2748     (source
2749      (origin
2750        (method git-fetch)
2751        (uri (git-reference
2752              (url "https://github.com/trivial-garbage/trivial-garbage.git")
2753              (commit (string-append "v" version))))
2754        (file-name (git-file-name "trivial-garbage" version))
2755        (sha256
2756         (base32 "0122jicfg7pca1wxw8zak1n92h5friqy60988ns0ysksj3fphw9n"))))
2757     (build-system asdf-build-system/sbcl)
2758     (native-inputs
2759      `(("rt" ,sbcl-rt)))
2760     (home-page "https://common-lisp.net/project/trivial-garbage/")
2761     (synopsis "Portable GC-related APIs for Common Lisp")
2762     (description "@command{trivial-garbage} provides a portable API to
2763 finalizers, weak hash-tables and weak pointers on all major implementations of
2764 the Common Lisp programming language.")
2765     (license license:public-domain)))
2766
2767 (define-public cl-trivial-garbage
2768   (sbcl-package->cl-source-package sbcl-trivial-garbage))
2769
2770 (define-public ecl-trivial-garbage
2771   (sbcl-package->ecl-package sbcl-trivial-garbage))
2772
2773 (define-public sbcl-closer-mop
2774   (let ((commit "fac29ce90e3a46e1fc6cf182190e193526fa9dbc"))
2775     (package
2776       (name "sbcl-closer-mop")
2777       (version (git-version  "1.0.0" "1" commit))
2778       (source
2779        (origin
2780          (method git-fetch)
2781          (uri (git-reference
2782                (url "https://github.com/pcostanza/closer-mop")
2783                (commit commit)))
2784          (sha256
2785           (base32 "0hvh77y869h8fg9di5snyg85fxq6fdh9gj1igmx1g6j6j5x915dl"))
2786          (file-name (git-file-name "closer-mop" version ))))
2787       (build-system asdf-build-system/sbcl)
2788       (home-page "https://github.com/pcostanza/closer-mop")
2789       (synopsis "Rectifies absent or incorrect CLOS MOP features")
2790       (description "Closer to MOP is a compatibility layer that rectifies many
2791 of the absent or incorrect CLOS MOP features across a broad range of Common
2792 Lisp implementations.")
2793       (license license:expat))))
2794
2795 (define-public cl-closer-mop
2796   (sbcl-package->cl-source-package sbcl-closer-mop))
2797
2798 (define-public ecl-closer-mop
2799   (sbcl-package->ecl-package sbcl-closer-mop))
2800
2801 (define sbcl-cl-cffi-gtk-boot0
2802   (let ((commit "29443c5aaca975709df8025c4649366d882033cb"))
2803     (package
2804       (name "sbcl-cl-cffi-gtk-boot0")
2805       (version (git-version "0.11.2" "1" commit))
2806       (source
2807        (origin
2808          (method git-fetch)
2809          (uri (git-reference
2810                (url "https://github.com/Ferada/cl-cffi-gtk/")
2811                (commit commit)))
2812          (file-name (git-file-name "cl-cffi-gtk" version))
2813          (sha256
2814           (base32
2815            "0f6s92sf8xyzh1yksqx8bsy1sv0zmy0c13j3b8bavaba5hlxpxah"))))
2816       (build-system asdf-build-system/sbcl)
2817       (inputs
2818        `(("iterate" ,sbcl-iterate)
2819          ("cffi" ,sbcl-cffi)
2820          ("trivial-features" ,sbcl-trivial-features)))
2821       (home-page "https://github.com/Ferada/cl-cffi-gtk/")
2822       (synopsis "Common Lisp binding for GTK+3")
2823       (description
2824        "@command{cl-cffi-gtk} is a Lisp binding to GTK+ 3 (GIMP Toolkit) which
2825 is a library for creating graphical user interfaces.")
2826       (license license:lgpl3))))
2827
2828 (define-public sbcl-cl-cffi-gtk-glib
2829   (package
2830     (inherit sbcl-cl-cffi-gtk-boot0)
2831     (name "sbcl-cl-cffi-gtk-glib")
2832     (inputs
2833      `(("glib" ,glib)
2834        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2835     (arguments
2836      `(#:asd-file "glib/cl-cffi-gtk-glib.asd"
2837        #:phases
2838        (modify-phases %standard-phases
2839          (add-after 'unpack 'fix-paths
2840            (lambda* (#:key inputs #:allow-other-keys)
2841              (substitute* "glib/glib.init.lisp"
2842                (("libglib|libgthread" all) (string-append
2843                                             (assoc-ref inputs "glib") "/lib/" all))))))))))
2844
2845 (define-public sbcl-cl-cffi-gtk-gobject
2846   (package
2847     (inherit sbcl-cl-cffi-gtk-boot0)
2848     (name "sbcl-cl-cffi-gtk-gobject")
2849     (inputs
2850      `(("glib" ,glib)
2851        ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
2852        ("trivial-garbage" ,sbcl-trivial-garbage)
2853        ("bordeaux-threads" ,sbcl-bordeaux-threads)
2854        ("closer-mop" ,sbcl-closer-mop)
2855        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2856     (arguments
2857      `(#:asd-file "gobject/cl-cffi-gtk-gobject.asd"
2858        #:phases
2859        (modify-phases %standard-phases
2860          (add-after 'unpack 'fix-paths
2861            (lambda* (#:key inputs #:allow-other-keys)
2862              (substitute* "gobject/gobject.init.lisp"
2863                (("libgobject" all) (string-append
2864                                     (assoc-ref inputs "glib") "/lib/" all))))))))))
2865
2866 (define-public sbcl-cl-cffi-gtk-gio
2867   (package
2868     (inherit sbcl-cl-cffi-gtk-boot0)
2869     (name "sbcl-cl-cffi-gtk-gio")
2870     (inputs
2871      `(("glib" ,glib)
2872        ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
2873        ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
2874        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2875     (arguments
2876      `(#:asd-file "gio/cl-cffi-gtk-gio.asd"
2877        #:phases
2878        (modify-phases %standard-phases
2879          (add-after 'unpack 'fix-paths
2880            (lambda* (#:key inputs #:allow-other-keys)
2881              (substitute* "gio/gio.init.lisp"
2882                (("libgio" all)
2883                 (string-append
2884                  (assoc-ref inputs "glib") "/lib/" all))))))))))
2885
2886 (define-public sbcl-cl-cffi-gtk-cairo
2887   (package
2888     (inherit sbcl-cl-cffi-gtk-boot0)
2889     (name "sbcl-cl-cffi-gtk-cairo")
2890     (inputs
2891      `(("cairo" ,cairo)
2892        ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
2893        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2894     (arguments
2895      `(#:asd-file "cairo/cl-cffi-gtk-cairo.asd"
2896        #:phases
2897        (modify-phases %standard-phases
2898          (add-after 'unpack 'fix-paths
2899            (lambda* (#:key inputs #:allow-other-keys)
2900              (substitute* "cairo/cairo.init.lisp"
2901                (("libcairo" all)
2902                 (string-append
2903                  (assoc-ref inputs "cairo") "/lib/" all))))))))))
2904
2905 (define-public sbcl-cl-cffi-gtk-pango
2906   (package
2907     (inherit sbcl-cl-cffi-gtk-boot0)
2908     (name "sbcl-cl-cffi-gtk-pango")
2909     (inputs
2910      `(("pango" ,pango)
2911        ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
2912        ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
2913        ("cl-cffi-gtk-cairo" ,sbcl-cl-cffi-gtk-cairo)
2914        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2915     (arguments
2916      `(#:asd-file "pango/cl-cffi-gtk-pango.asd"
2917        #:phases
2918        (modify-phases %standard-phases
2919          (add-after 'unpack 'fix-paths
2920            (lambda* (#:key inputs #:allow-other-keys)
2921              (substitute* "pango/pango.init.lisp"
2922                (("libpango" all)
2923                 (string-append
2924                  (assoc-ref inputs "pango") "/lib/" all))))))))))
2925
2926 (define-public sbcl-cl-cffi-gtk-gdk-pixbuf
2927   (package
2928     (inherit sbcl-cl-cffi-gtk-boot0)
2929     (name "sbcl-cl-cffi-gtk-gdk-pixbuf")
2930     (inputs
2931      `(("gdk-pixbuf" ,gdk-pixbuf)
2932        ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
2933        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2934     (arguments
2935      `(#:asd-file "gdk-pixbuf/cl-cffi-gtk-gdk-pixbuf.asd"
2936        #:phases
2937        (modify-phases %standard-phases
2938          (add-after 'unpack 'fix-paths
2939            (lambda* (#:key inputs #:allow-other-keys)
2940              (substitute* "gdk-pixbuf/gdk-pixbuf.init.lisp"
2941                (("libgdk_pixbuf" all)
2942                 (string-append
2943                  (assoc-ref inputs "gdk-pixbuf") "/lib/" all))))))))))
2944
2945 (define-public sbcl-cl-cffi-gtk-gdk
2946   (package
2947     (inherit sbcl-cl-cffi-gtk-boot0)
2948     (name "sbcl-cl-cffi-gtk-gdk")
2949     (inputs
2950      `(("gtk" ,gtk+)
2951        ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
2952        ("cl-cffi-gtk-gio" ,sbcl-cl-cffi-gtk-gio)
2953        ("cl-cffi-gtk-gdk-pixbuf" ,sbcl-cl-cffi-gtk-gdk-pixbuf)
2954        ("cl-cffi-gtk-cairo" ,sbcl-cl-cffi-gtk-cairo)
2955        ("cl-cffi-gtk-pango" ,sbcl-cl-cffi-gtk-pango)
2956        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2957     (arguments
2958      `(#:asd-file "gdk/cl-cffi-gtk-gdk.asd"
2959        #:phases
2960        (modify-phases %standard-phases
2961          (add-after 'unpack 'fix-paths
2962            (lambda* (#:key inputs #:allow-other-keys)
2963              (substitute* "gdk/gdk.init.lisp"
2964                (("libgdk" all)
2965                 (string-append
2966                  (assoc-ref inputs "gtk") "/lib/" all)))
2967              (substitute* "gdk/gdk.package.lisp"
2968                (("libgtk" all)
2969                 (string-append
2970                  (assoc-ref inputs "gtk") "/lib/" all))))))))))
2971
2972 (define-public sbcl-cl-cffi-gtk
2973   (package
2974     (inherit sbcl-cl-cffi-gtk-boot0)
2975     (name "sbcl-cl-cffi-gtk")
2976     (inputs
2977      `(("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
2978        ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
2979        ("cl-cffi-gtk-gio" ,sbcl-cl-cffi-gtk-gio)
2980        ("cl-cffi-gtk-gdk" ,sbcl-cl-cffi-gtk-gdk)
2981        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2982     (native-inputs
2983      `(("fiveam" ,sbcl-fiveam)))
2984     (arguments
2985      `(#:asd-file "gtk/cl-cffi-gtk.asd"
2986        #:test-asd-file "test/cl-cffi-gtk-test.asd"
2987        ;; TODO: Tests fail with memory fault.
2988        ;; See https://github.com/Ferada/cl-cffi-gtk/issues/24.
2989        #:tests? #f))))
2990
2991 (define-public cl-cffi-gtk
2992   (sbcl-package->cl-source-package sbcl-cl-cffi-gtk))
2993
2994 (define-public sbcl-cl-webkit
2995   (let ((commit "cd2a9008e0c152e54755e8a7f07b050fe36bab31"))
2996     (package
2997       (name "sbcl-cl-webkit")
2998       (version (git-version "2.4" "1" commit))
2999       (source
3000        (origin
3001          (method git-fetch)
3002          (uri (git-reference
3003                (url "https://github.com/jmercouris/cl-webkit")
3004                (commit commit)))
3005          (file-name (git-file-name "cl-webkit" version))
3006          (sha256
3007           (base32
3008            "0f5lyn9i7xrn3g1bddga377mcbawkbxydijpg389q4n04gqj0vwf"))))
3009       (build-system asdf-build-system/sbcl)
3010       (inputs
3011        `(("cffi" ,sbcl-cffi)
3012          ("cl-cffi-gtk" ,sbcl-cl-cffi-gtk)
3013          ("webkitgtk" ,webkitgtk)))
3014       (arguments
3015        `(#:asd-file "webkit2/cl-webkit2.asd"
3016          #:asd-system-name "cl-webkit2"
3017          #:phases
3018          (modify-phases %standard-phases
3019            (add-after 'unpack 'fix-paths
3020              (lambda* (#:key inputs #:allow-other-keys)
3021                (substitute* "webkit2/webkit2.init.lisp"
3022                  (("libwebkit2gtk" all)
3023                   (string-append
3024                    (assoc-ref inputs "webkitgtk") "/lib/" all))))))))
3025       (home-page "https://github.com/jmercouris/cl-webkit")
3026       (synopsis "Binding to WebKitGTK+ for Common Lisp")
3027       (description
3028        "@command{cl-webkit} is a binding to WebKitGTK+ for Common Lisp,
3029 currently targeting WebKit version 2.  The WebKitGTK+ library adds web
3030 browsing capabilities to an application, leveraging the full power of the
3031 WebKit browsing engine.")
3032       (license license:expat))))
3033
3034 (define-public cl-webkit
3035   (sbcl-package->cl-source-package sbcl-cl-webkit))
3036
3037 (define-public sbcl-lparallel
3038   (package
3039     (name "sbcl-lparallel")
3040     (version "2.8.4")
3041     (source
3042      (origin
3043        (method git-fetch)
3044        (uri (git-reference
3045              (url "https://github.com/lmj/lparallel/")
3046              (commit (string-append "lparallel-" version))))
3047        (file-name (git-file-name "lparallel" version))
3048        (sha256
3049         (base32
3050          "0g0aylrbbrqsz0ahmwhvnk4cmc2931fllbpcfgzsprwnqqd7vwq9"))))
3051     (build-system asdf-build-system/sbcl)
3052     (inputs
3053      `(("alexandria" ,sbcl-alexandria)
3054        ("bordeaux-threads" ,sbcl-bordeaux-threads)
3055        ("trivial-garbage" ,sbcl-trivial-garbage)))
3056     (home-page "https://lparallel.org/")
3057     (synopsis "Parallelism for Common Lisp")
3058     (description
3059      "@command{lparallel} is a library for parallel programming in Common
3060 Lisp, featuring:
3061
3062 @itemize
3063 @item a simple model of task submission with receiving queue,
3064 @item constructs for expressing fine-grained parallelism,
3065 @item asynchronous condition handling across thread boundaries,
3066 @item parallel versions of map, reduce, sort, remove, and many others,
3067 @item promises, futures, and delayed evaluation constructs,
3068 @item computation trees for parallelizing interconnected tasks,
3069 @item bounded and unbounded FIFO queues,
3070 @item high and low priority tasks,
3071 @item task killing by category,
3072 @item integrated timeouts.
3073 @end itemize\n")
3074     (license license:expat)))
3075
3076 (define-public cl-lparallel
3077   (sbcl-package->cl-source-package sbcl-lparallel))
3078
3079 (define-public ecl-lparallel
3080   (sbcl-package->ecl-package sbcl-lparallel))
3081
3082 (define-public sbcl-cl-markup
3083   (let ((commit "e0eb7debf4bdff98d1f49d0f811321a6a637b390"))
3084     (package
3085       (name "sbcl-cl-markup")
3086       (version (git-version "0.1" "1" commit))
3087       (source
3088        (origin
3089          (method git-fetch)
3090          (uri (git-reference
3091                (url "https://github.com/arielnetworks/cl-markup/")
3092                (commit commit)))
3093          (file-name (git-file-name "cl-markup" version))
3094          (sha256
3095           (base32
3096            "10l6k45971dl13fkdmva7zc6i453lmq9j4xax2ci6pjzlc6xjhp7"))))
3097       (build-system asdf-build-system/sbcl)
3098       (home-page "https://github.com/arielnetworks/cl-markup/")
3099       (synopsis "Markup generation library for Common Lisp")
3100       (description
3101        "A modern markup generation library for Common Lisp that features:
3102
3103 @itemize
3104 @item Fast (even faster through compiling the code)
3105 @item Safety
3106 @item Support for multiple document types (markup, xml, html, html5, xhtml)
3107 @item Output with doctype
3108 @item Direct output to stream
3109 @end itemize\n")
3110       (license license:lgpl3+))))
3111
3112 (define-public cl-markup
3113   (sbcl-package->cl-source-package sbcl-cl-markup))
3114
3115 (define-public ecl-cl-markup
3116   (sbcl-package->ecl-package sbcl-cl-markup))
3117
3118 (define-public sbcl-cl-css
3119   (let ((commit "8fe654c8f0cf95b300718101cce4feb517f78e2f"))
3120     (package
3121       (name "sbcl-cl-css")
3122       (version (git-version "0.1" "1" commit))
3123       (source
3124        (origin
3125          (method git-fetch)
3126          (uri (git-reference
3127                (url "https://github.com/inaimathi/cl-css/")
3128                (commit commit)))
3129          (file-name (git-file-name "cl-css" version))
3130          (sha256
3131           (base32
3132            "1lc42zi2sw11fl2589sc19nr5sd2p0wy7wgvgwaggxa5f3ajhsmd"))))
3133       (build-system asdf-build-system/sbcl)
3134       (home-page "https://github.com/inaimathi/cl-css/")
3135       (synopsis "Non-validating, inline CSS generator for Common Lisp")
3136       (description
3137        "This is a dead-simple, non validating, inline CSS generator for Common
3138 Lisp.  Its goals are axiomatic syntax, simple implementation to support
3139 portability, and boilerplate reduction in CSS.")
3140       (license license:expat))))
3141
3142 (define-public cl-css
3143   (sbcl-package->cl-source-package sbcl-cl-css))
3144
3145 (define-public ecl-cl-css
3146   (sbcl-package->ecl-package sbcl-cl-css))
3147
3148 (define-public sbcl-portable-threads
3149   (let ((commit "c0e61a1faeb0583c80fd3f20b16cc4c555226920"))
3150     (package
3151       (name "sbcl-portable-threads")
3152       (version (git-version "2.3" "1" commit))
3153       (source
3154        (origin
3155          (method git-fetch)
3156          (uri (git-reference
3157                (url "https://github.com/binghe/portable-threads/")
3158                (commit commit)))
3159          (file-name (git-file-name "portable-threads" version))
3160          (sha256
3161           (base32
3162            "03fmxyarc0xf4kavwkfa0a2spkyfrz6hbgbi9y4q7ny5aykdyfaq"))))
3163       (build-system asdf-build-system/sbcl)
3164       (arguments
3165        `(;; Tests seem broken.
3166          #:tests? #f))
3167       (home-page "https://github.com/binghe/portable-threads")
3168       (synopsis "Portable threads (and scheduled and periodic functions) API for Common Lisp")
3169       (description
3170        "Portable Threads (and Scheduled and Periodic Functions) API for Common
3171 Lisp (from GBBopen project).")
3172       (license license:asl2.0))))
3173
3174 (define-public cl-portable-threads
3175   (sbcl-package->cl-source-package sbcl-portable-threads))
3176
3177 (define-public ecl-portable-threada
3178   (sbcl-package->ecl-package sbcl-portable-threads))
3179
3180 (define-public sbcl-usocket-boot0
3181   ;; usocket's test rely on usocket-server which depends on usocket itself.
3182   ;; We break this cyclic dependency with -boot0 that packages usocket.
3183   (let ((commit "86e7efbfe50101931edf4b67cdcfa7e221ecfde9"))
3184     (package
3185       (name "sbcl-usocket-boot0")
3186       (version (git-version "0.7.1" "1" commit))
3187       (source
3188        (origin
3189          (method git-fetch)
3190          (uri (git-reference
3191                (url "https://github.com/usocket/usocket/")
3192                (commit commit)))
3193          (file-name (git-file-name "usocket" version))
3194          (sha256
3195           (base32
3196            "1lk6ipakrib7kdgzw44hrgmls9akp5pz4h35yynw0k5zwmmq6374"))))
3197       (build-system asdf-build-system/sbcl)
3198       (inputs
3199        `(("split-sequence" ,sbcl-split-sequence)))
3200       (arguments
3201        `(#:tests? #f
3202          #:asd-system-name "usocket"))
3203       (home-page "https://common-lisp.net/project/usocket/")
3204       (synopsis "Universal socket library for Common Lisp (server side)")
3205       (description
3206        "This library strives to provide a portable TCP/IP and UDP/IP socket
3207 interface for as many Common Lisp implementations as possible, while keeping
3208 the abstraction and portability layer as thin as possible.")
3209       (license license:expat))))
3210
3211 (define-public sbcl-usocket-server
3212   (package
3213     (inherit sbcl-usocket-boot0)
3214     (name "sbcl-usocket-server")
3215     (inputs
3216      `(("usocket" ,sbcl-usocket-boot0)
3217        ("portable-threads" ,sbcl-portable-threads)))
3218     (arguments
3219      '(#:asd-system-name "usocket-server"))
3220     (synopsis "Universal socket library for Common Lisp (server side)")))
3221
3222 (define-public cl-usocket-server
3223   (sbcl-package->cl-source-package sbcl-usocket-server))
3224
3225 (define-public ecl-socket-server
3226   (sbcl-package->ecl-package sbcl-usocket-server))
3227
3228 (define-public sbcl-usocket
3229   (package
3230     (inherit sbcl-usocket-boot0)
3231     (name "sbcl-usocket")
3232     (arguments
3233      ;; FIXME: Tests need network access?
3234      `(#:tests? #f))
3235     (native-inputs
3236      ;; Testing only.
3237      `(("usocket-server" ,sbcl-usocket-server)
3238        ("rt" ,sbcl-rt)))))
3239
3240 (define-public cl-usocket
3241   (sbcl-package->cl-source-package sbcl-usocket))
3242
3243 (define-public ecl-socket
3244   (sbcl-package->ecl-package sbcl-usocket))
3245
3246 (define-public sbcl-s-xml
3247   (package
3248     (name "sbcl-s-xml")
3249     (version "3")
3250     (source
3251      (origin
3252        (method url-fetch)
3253        (uri "https://common-lisp.net/project/s-xml/s-xml.tgz")
3254        (sha256
3255         (base32
3256          "061qcr0dzshsa38s5ma4ay924cwak2nq9gy59dw6v9p0qb58nzjf"))))
3257     (build-system asdf-build-system/sbcl)
3258     (home-page "https://common-lisp.net/project/s-xml/")
3259     (synopsis "Simple XML parser implemented in Common Lisp")
3260     (description
3261      "S-XML is a simple XML parser implemented in Common Lisp.  This XML
3262 parser implementation has the following features:
3263
3264 @itemize
3265 @item It works (handling many common XML usages).
3266 @item It is very small (the core is about 700 lines of code, including
3267 comments and whitespace).
3268 @item It has a core API that is simple, efficient and pure functional, much
3269 like that from SSAX (see also http://ssax.sourceforge.net).
3270 @item It supports different DOM models: an XSML-based one, an LXML-based one
3271 and a classic xml-element struct based one.
3272 @item It is reasonably time and space efficient (internally avoiding garbage
3273 generatation as much as possible).
3274 @item It does support CDATA.
3275 @item It should support the same character sets as your Common Lisp
3276 implementation.
3277 @item It does support XML name spaces.
3278 @end itemize
3279
3280 This XML parser implementation has the following limitations:
3281
3282 @itemize
3283 @item It does not support any special tags (like processing instructions).
3284 @item It is not validating, even skips DTD's all together.
3285 @end itemize\n")
3286     (license license:lgpl3+)))
3287
3288 (define-public cl-s-xml
3289   (sbcl-package->cl-source-package sbcl-s-xml))
3290
3291 (define-public ecl-s-xml
3292   (sbcl-package->ecl-package sbcl-s-xml))
3293
3294 (define-public sbcl-s-xml-rpc
3295   (package
3296     (name "sbcl-s-xml-rpc")
3297     (version "7")
3298     (source
3299      (origin
3300        (method url-fetch)
3301        (uri "https://common-lisp.net/project/s-xml-rpc/s-xml-rpc.tgz")
3302        (sha256
3303         (base32
3304          "02z7k163d51v0pzk8mn1xb6h5s6x64gjqkslhwm3a5x26k2gfs11"))))
3305     (build-system asdf-build-system/sbcl)
3306     (inputs
3307      `(("s-xml" ,sbcl-s-xml)))
3308     (home-page "https://common-lisp.net/project/s-xml-rpc/")
3309     (synopsis "Implementation of XML-RPC in Common Lisp for both client and server")
3310     (description
3311      "S-XML-RPC is an implementation of XML-RPC in Common Lisp for both
3312 client and server.")
3313     (license license:lgpl3+)))
3314
3315 (define-public cl-s-xml-rpc
3316   (sbcl-package->cl-source-package sbcl-s-xml-rpc))
3317
3318 (define-public ecl-s-xml-rpc
3319   (sbcl-package->ecl-package sbcl-s-xml-rpc))
3320
3321 (define-public sbcl-trivial-clipboard
3322   (let ((commit "5af3415d1484e6d69a1b5c178f24680d9fd01796"))
3323     (package
3324       (name "sbcl-trivial-clipboard")
3325       (version (git-version "0.0.0.0" "2" commit))
3326       (source
3327        (origin
3328          (method git-fetch)
3329          (uri (git-reference
3330                (url "https://github.com/snmsts/trivial-clipboard")
3331                (commit commit)))
3332          (file-name (git-file-name "trivial-clipboard" version))
3333          (sha256
3334           (base32
3335            "1gb515z5yq6h5548pb1fwhmb0hhq1ssyb78pvxh4alq799xipxs9"))))
3336       (build-system asdf-build-system/sbcl)
3337       (inputs
3338        `(("xclip" ,xclip)))
3339       (native-inputs
3340        `(("fiveam" ,sbcl-fiveam)))
3341       (arguments
3342        `(#:phases
3343          (modify-phases %standard-phases
3344            (add-after 'unpack 'fix-paths
3345              (lambda* (#:key inputs #:allow-other-keys)
3346                (substitute* "src/text.lisp"
3347                  (("\\(executable-find \"xclip\"\\)")
3348                   (string-append "(executable-find \""
3349                                  (assoc-ref inputs "xclip")
3350                                  "/bin/xclip\")"))))))))
3351       (home-page "https://github.com/snmsts/trivial-clipboard")
3352       (synopsis "Access system clipboard in Common Lisp")
3353       (description
3354        "@command{trivial-clipboard} gives access to the system clipboard.")
3355       (license license:expat))))
3356
3357 (define-public cl-trivial-clipboard
3358   (sbcl-package->cl-source-package sbcl-trivial-clipboard))
3359
3360 (define-public ecl-trivial-clipboard
3361   (sbcl-package->ecl-package sbcl-trivial-clipboard))
3362
3363 (define-public sbcl-trivial-backtrace
3364   (let ((commit "ca81c011b86424a381a7563cea3b924f24e6fbeb")
3365         (revision "1"))
3366     (package
3367      (name "sbcl-trivial-backtrace")
3368      (version (git-version "0.0.0" revision commit))
3369      (source
3370       (origin
3371        (method git-fetch)
3372        (uri (git-reference
3373              (url "https://github.com/gwkkwg/trivial-backtrace.git")
3374              (commit commit)))
3375        (file-name (git-file-name "trivial-backtrace" version))
3376        (sha256
3377         (base32 "10p41p43skj6cimdg8skjy7372s8v2xpkg8djjy0l8rm45i654k1"))))
3378      (build-system asdf-build-system/sbcl)
3379      (inputs
3380       `(("sbcl-lift" ,sbcl-lift)))
3381      (arguments
3382       `(#:phases
3383         (modify-phases %standard-phases
3384           (add-after 'check 'delete-test-results
3385             (lambda* (#:key outputs #:allow-other-keys)
3386               (let ((test-results (string-append (assoc-ref outputs "out")
3387                                                  "/share/common-lisp/"
3388                                                  (%lisp-type) "-source"
3389                                                  "/trivial-backtrace"
3390                                                  "/test-results")))
3391                 (when (file-exists? test-results)
3392                   (delete-file-recursively test-results)))
3393               #t)))))
3394      (home-page "https://common-lisp.net/project/trivial-backtrace/")
3395      (synopsis "Portable simple API to work with backtraces in Common Lisp")
3396      (description
3397       "On of the many things that didn't quite get into the Common Lisp
3398 standard was how to get a Lisp to output its call stack when something has
3399 gone wrong.  As such, each Lisp has developed its own notion of what to
3400 display, how to display it, and what sort of arguments can be used to
3401 customize it.  @code{trivial-backtrace} is a simple solution to generating a
3402 backtrace portably.")
3403      (license license:expat))))
3404
3405 (define-public cl-trivial-backtrace
3406   (sbcl-package->cl-source-package sbcl-trivial-backtrace))
3407
3408 (define-public sbcl-rfc2388
3409   (let ((commit "591bcf7e77f2c222c43953a80f8c297751dc0c4e")
3410         (revision "1"))
3411     (package
3412      (name "sbcl-rfc2388")
3413      (version (git-version "0.0.0" revision commit))
3414      (source
3415       (origin
3416        (method git-fetch)
3417        (uri (git-reference
3418              (url "https://github.com/jdz/rfc2388.git")
3419              (commit commit)))
3420        (file-name (git-file-name "rfc2388" version))
3421        (sha256
3422         (base32 "0phh5n3clhl9ji8jaxrajidn22d3f0aq87mlbfkkxlnx2pnw694k"))))
3423      (build-system asdf-build-system/sbcl)
3424      (home-page "https://github.com/jdz/rfc2388/")
3425      (synopsis "An implementation of RFC 2388 in Common Lisp")
3426      (description
3427       "This package contains an implementation of RFC 2388, which is used to
3428 process form data posted with HTTP POST method using enctype
3429 \"multipart/form-data\".")
3430      (license license:bsd-2))))
3431
3432 (define-public cl-rfc2388
3433   (sbcl-package->cl-source-package sbcl-rfc2388))
3434
3435 (define-public sbcl-md5
3436   (package
3437     (name "sbcl-md5")
3438     (version "2.0.4")
3439     (source
3440      (origin
3441        (method url-fetch)
3442        (uri (string-append
3443              "https://github.com/pmai/md5/archive/release-" version ".tar.gz"))
3444        (sha256
3445         (base32 "19yl9n0pjdz5gw4qi711lka97xcd9f81ylg434hk7jwn9f2s6w11"))))
3446     (build-system asdf-build-system/sbcl)
3447     (home-page "https://github.com/pmai/md5")
3448     (synopsis
3449      "Common Lisp implementation of the MD5 Message-Digest Algorithm (RFC 1321)")
3450     (description
3451      "This package implements The MD5 Message-Digest Algorithm, as defined in
3452 RFC 1321 by R. Rivest, published April 1992.")
3453     (license license:public-domain)))
3454
3455 (define-public cl-md5
3456   (sbcl-package->cl-source-package sbcl-md5))
3457
3458 (define-public sbcl-cl+ssl
3459   (let ((commit "141ae91416bc40f1618dc07e48429b84388aa599")
3460         (revision "1"))
3461     (package
3462       (name "sbcl-cl+ssl")
3463       (version (git-version "0.0.0" revision commit))
3464       (source
3465        (origin
3466          (method git-fetch)
3467          (uri (git-reference
3468                (url "https://github.com/cl-plus-ssl/cl-plus-ssl.git")
3469                (commit commit)))
3470          (file-name (git-file-name "cl+ssl" version))
3471          (sha256
3472           (base32 "1s0hg1h9sf8q89v0yrxmzg5f5sng29rgx3n21r9h9yql8351myan"))))
3473       (build-system asdf-build-system/sbcl)
3474       (arguments
3475        '(#:phases
3476          (modify-phases %standard-phases
3477            (add-after 'unpack 'fix-paths
3478              (lambda* (#:key inputs #:allow-other-keys)
3479                (substitute* "src/reload.lisp"
3480                  (("libssl.so" all)
3481                   (string-append
3482                    (assoc-ref inputs "openssl") "/lib/" all))))))))
3483       (inputs
3484        `(("openssl" ,openssl)
3485          ("sbcl-cffi" ,sbcl-cffi)
3486          ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)
3487          ("sbcl-flexi-streams" ,sbcl-flexi-streams)
3488          ("sbcl-bordeaux-threads" ,sbcl-bordeaux-threads)
3489          ("sbcl-trivial-garbage" ,sbcl-trivial-garbage)
3490          ("sbcl-alexandria" ,sbcl-alexandria)
3491          ("sbcl-trivial-features" ,sbcl-trivial-features)))
3492       (home-page "http://common-lisp.net/project/cl-plus-ssl/")
3493       (synopsis "Common Lisp bindings to OpenSSL")
3494       (description
3495        "This library is a fork of SSL-CMUCL.  The original SSL-CMUCL source
3496 code was written by Eric Marsden and includes contributions by Jochen Schmidt.
3497 Development into CL+SSL was done by David Lichteblau.")
3498       (license license:expat))))
3499
3500 (define-public cl-cl+ssl
3501   (sbcl-package->cl-source-package sbcl-cl+ssl))
3502
3503 (define-public sbcl-kmrcl
3504   (let ((version "1.109.0")
3505         (commit "5260068b2eb735af6796740c2db4955afac21636")
3506         (revision "1"))
3507     (package
3508       (name "sbcl-kmrcl")
3509       (version (git-version version revision commit))
3510       (source
3511        (origin
3512          (method git-fetch)
3513          (uri (git-reference
3514                (url "http://git.kpe.io/kmrcl.git/")
3515                (commit commit)))
3516          (file-name (git-file-name name version))
3517          (sha256
3518           (base32 "1va7xjgzfv674bpsli674i7zj3f7wg5kxic41kz18r6hh4n52dfv"))))
3519       (build-system asdf-build-system/sbcl)
3520       (arguments
3521        ;; Tests fail with: :FORCE and :FORCE-NOT arguments not allowed in a
3522        ;; nested call to ASDF/OPERATE:OPERATE unless identically to toplevel
3523        '(#:tests? #f))
3524       (inputs
3525        `(("sbcl-rt" ,sbcl-rt)))
3526       (home-page "http://files.kpe.io/kmrcl/")
3527       (synopsis "General utilities for Common Lisp programs")
3528       (description
3529        "KMRCL is a collection of utilities used by a number of Kevin
3530 Rosenberg's CL packages.")
3531       (license license:llgpl))))
3532
3533 (define-public cl-kmrcl
3534   (sbcl-package->cl-source-package sbcl-kmrcl))
3535
3536 (define-public sbcl-cl-base64
3537   (let ((version "3.3.3"))
3538     (package
3539       (name "sbcl-cl-base64")
3540       (version version)
3541       (source
3542        (origin
3543          (method git-fetch)
3544          (uri (git-reference
3545                (url "http://git.kpe.io/cl-base64.git")
3546                (commit (string-append "v" version))))
3547          (file-name (git-file-name "cl-base64" version))
3548          (sha256
3549           (base32 "1dw6j7n6gsd2qa0p0rbsjxj00acxx3i9ca1qkgl0liy8lpnwkypl"))))
3550       (build-system asdf-build-system/sbcl)
3551       (arguments
3552        ;; Tests fail with: :FORCE and :FORCE-NOT arguments not allowed
3553        ;; in a nested call to ASDF/OPERATE:OPERATE unless identically
3554        ;; to toplevel
3555        '(#:tests? #f))
3556       (inputs
3557        `(("sbcl-ptester" ,sbcl-ptester)
3558          ("sbcl-kmrcl" ,sbcl-kmrcl)))
3559       (home-page "http://files.kpe.io/cl-base64/")
3560       (synopsis
3561        "Common Lisp package to encode and decode base64 with URI support")
3562       (description
3563        "This package provides highly optimized base64 encoding and decoding.
3564 Besides conversion to and from strings, integer conversions are supported.
3565 Encoding with Uniform Resource Identifiers is supported by using a modified
3566 encoding table that uses only URI-compatible characters.")
3567       (license license:bsd-3))))
3568
3569 (define-public cl-base64
3570   (sbcl-package->cl-source-package sbcl-cl-base64))
3571
3572 (define-public sbcl-chunga
3573   (package
3574     (name "sbcl-chunga")
3575     (version "1.1.7")
3576     (source
3577      (origin
3578        (method git-fetch)
3579        (uri (git-reference
3580               (url "https://github.com/edicl/chunga.git")
3581               (commit (string-append "v" version))))
3582        (file-name (git-file-name name version))
3583        (sha256
3584         (base32 "0jzn3nyb3f22gm983rfk99smqs3mhb9ivjmasvhq9qla5cl9pyhd"))))
3585     (build-system asdf-build-system/sbcl)
3586     (inputs
3587      `(("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)))
3588     (home-page "https://edicl.github.io/chunga/")
3589     (synopsis "Portable chunked streams for Common Lisp")
3590     (description
3591      "Chunga implements streams capable of chunked encoding on demand as
3592 defined in RFC 2616.")
3593     (license license:bsd-2)))
3594
3595 (define-public cl-chunga
3596   (sbcl-package->cl-source-package sbcl-chunga))
3597
3598 (define-public sbcl-cl-who
3599   (let ((version "1.1.4")
3600         (commit "2c08caa4bafba720409af9171feeba3f32e86d32")
3601         (revision "1"))
3602     (package
3603       (name "sbcl-cl-who")
3604       (version (git-version version revision commit))
3605       (source
3606        (origin
3607          (method git-fetch)
3608          (uri (git-reference
3609                (url "https://github.com/edicl/cl-who.git")
3610                (commit commit)))
3611          (file-name (git-file-name name version))
3612          (sha256
3613           (base32
3614            "0yjb6sr3yazm288m318kqvj9xk8rm9n1lpimgf65ymqv0i5agxsb"))))
3615       (build-system asdf-build-system/sbcl)
3616       (native-inputs
3617        `(("sbcl-flexi-streams" ,sbcl-flexi-streams)))
3618       (home-page "https://edicl.github.io/cl-who/")
3619       (synopsis "Yet another Lisp markup language")
3620       (description
3621        "There are plenty of Lisp Markup Languages out there - every Lisp
3622 programmer seems to write at least one during his career - and CL-WHO (where
3623 WHO means \"with-html-output\" for want of a better acronym) is probably just
3624 as good or bad as the next one.")
3625       (license license:bsd-2))))
3626
3627 (define-public cl-cl-who
3628   (sbcl-package->cl-source-package sbcl-cl-who))
3629
3630 (define-public sbcl-chipz
3631   (let ((version "0.8")
3632         (commit "75dfbc660a5a28161c57f115adf74c8a926bfc4d")
3633         (revision "1"))
3634     (package
3635       (name "sbcl-chipz")
3636       (version (git-version version revision commit))
3637       (source
3638        (origin
3639          (method git-fetch)
3640          (uri (git-reference
3641                (url "https://github.com/froydnj/chipz.git")
3642                (commit commit)))
3643          (file-name (git-file-name name version))
3644          (sha256
3645           (base32
3646            "0plx4rs39zbs4gjk77h4a2q11zpy75fh9v8hnxrvsf8fnakajhwg"))))
3647       (build-system asdf-build-system/sbcl)
3648       (native-inputs
3649        `(("sbcl-flexi-streams" ,sbcl-flexi-streams)))
3650       (home-page "http://method-combination.net/lisp/chipz/")
3651       (synopsis
3652        "Common Lisp library for decompressing deflate, zlib, gzip, and bzip2
3653 data")
3654       (description
3655        "DEFLATE data, defined in RFC1951, forms the core of popular
3656 compression formats such as zlib (RFC 1950) and gzip (RFC 1952).  As such,
3657 Chipz also provides for decompressing data in those formats as well.  BZIP2 is
3658 the format used by the popular compression tool bzip2.")
3659       ;; The author describes it as "MIT-like"
3660       (license license:expat))))
3661
3662 (define-public cl-chipz
3663   (sbcl-package->cl-source-package sbcl-chipz))
3664
3665 (define-public sbcl-drakma
3666   (package
3667     (name "sbcl-drakma")
3668     (version "2.0.7")
3669     (source
3670      (origin
3671        (method git-fetch)
3672        (uri (git-reference
3673              (url "https://github.com/edicl/drakma.git")
3674              (commit (string-append "v" version))))
3675        (file-name (git-file-name name version))
3676        (sha256
3677         (base32
3678          "1441idnyif9xzx3ln1p3fg36k2v9h4wasjqrzc8y52j61420qpci"))))
3679     (build-system asdf-build-system/sbcl)
3680     (inputs
3681      `(("sbcl-puri" ,sbcl-puri)
3682        ("sbcl-cl-base64" ,sbcl-cl-base64)
3683        ("sbcl-chunga" ,sbcl-chunga)
3684        ("sbcl-flexi-streams" ,sbcl-flexi-streams)
3685        ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
3686        ("sbcl-chipz" ,sbcl-chipz)
3687        ("sbcl-usocket" ,sbcl-usocket)
3688        ("sbcl-cl+ssl" ,sbcl-cl+ssl)))
3689     (native-inputs
3690      `(("sbcl-fiveam" ,sbcl-fiveam)))
3691     (home-page "https://edicl.github.io/drakma/")
3692     (synopsis "HTTP client written in Common Lisp")
3693     (description
3694      "Drakma is a full-featured HTTP client implemented in Common Lisp.  It
3695 knows how to handle HTTP/1.1 chunking, persistent connections, re-usable
3696 sockets, SSL, continuable uploads, file uploads, cookies, and more.")
3697     (license license:bsd-2)))
3698
3699 (define-public cl-drakma
3700   (sbcl-package->cl-source-package sbcl-drakma))
3701
3702 (define-public ecl-drakma
3703   (sbcl-package->ecl-package sbcl-drakma))
3704
3705 (define-public sbcl-hunchentoot
3706   (package
3707     (name "sbcl-hunchentoot")
3708     (version "1.2.38")
3709     (source
3710      (origin
3711        (method git-fetch)
3712        (uri (git-reference
3713              (url "https://github.com/edicl/hunchentoot.git")
3714              (commit (string-append "v" version))))
3715        (file-name (git-file-name "hunchentoot" version))
3716        (sha256
3717         (base32 "1anpcad7w045m4rsjs1f3xdhjwx5cppq1h0vlb3q7dz81fi3i6yq"))))
3718     (build-system asdf-build-system/sbcl)
3719     (native-inputs
3720      `(("sbcl-cl-who" ,sbcl-cl-who)
3721        ("sbcl-drakma" ,sbcl-drakma)))
3722     (inputs
3723      `(("sbcl-chunga" ,sbcl-chunga)
3724        ("sbcl-cl-base64" ,sbcl-cl-base64)
3725        ("sbcl-cl-fad" ,sbcl-cl-fad)
3726        ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
3727        ("sbcl-flexi-streams" ,sbcl-flexi-streams)
3728        ("sbcl-cl+ssl" ,sbcl-cl+ssl)
3729        ("sbcl-md5" ,sbcl-md5)
3730        ("sbcl-rfc2388" ,sbcl-rfc2388)
3731        ("sbcl-trivial-backtrace" ,sbcl-trivial-backtrace)
3732        ("sbcl-usocket" ,sbcl-usocket)))
3733     (home-page "https://edicl.github.io/hunchentoot/")
3734     (synopsis "Web server written in Common Lisp")
3735     (description
3736      "Hunchentoot is a web server written in Common Lisp and at the same
3737 time a toolkit for building dynamic websites.  As a stand-alone web server,
3738 Hunchentoot is capable of HTTP/1.1 chunking (both directions), persistent
3739 connections (keep-alive), and SSL.")
3740     (license license:bsd-2)))
3741
3742 (define-public cl-hunchentoot
3743   (sbcl-package->cl-source-package sbcl-hunchentoot))
3744
3745 (define-public sbcl-trivial-types
3746   (package
3747     (name "sbcl-trivial-types")
3748     (version "0.0.1")
3749     (source
3750      (origin
3751        (method git-fetch)
3752        (uri (git-reference
3753              (url "https://github.com/m2ym/trivial-types.git")
3754              (commit "ee869f2b7504d8aa9a74403641a5b42b16f47d88")))
3755        (file-name (git-file-name name version))
3756        (sha256
3757         (base32 "1s4cp9bdlbn8447q7w7f1wkgwrbvfzp20mgs307l5pxvdslin341"))))
3758     (build-system asdf-build-system/sbcl)
3759     (home-page "https://github.com/m2ym/trivial-types")
3760     (synopsis "Trivial type definitions for Common Lisp")
3761     (description
3762      "TRIVIAL-TYPES provides missing but important type definitions such as
3763 PROPER-LIST, ASSOCIATION-LIST, PROPERTY-LIST and TUPLE.")
3764     (license license:llgpl)))
3765
3766 (define-public cl-trivial-types
3767   (sbcl-package->cl-source-package sbcl-trivial-types))
3768
3769 (define-public sbcl-cl-syntax
3770   (package
3771     (name "sbcl-cl-syntax")
3772     (version "0.0.3")
3773     (source
3774      (origin
3775        (method git-fetch)
3776        (uri (git-reference
3777              (url "https://github.com/m2ym/cl-syntax.git")
3778              (commit "03f0c329bbd55b8622c37161e6278366525e2ccc")))
3779        (file-name (git-file-name "cl-syntax" version))
3780        (sha256
3781         (base32 "17ran8xp77asagl31xv8w819wafh6whwfc9p6dgx22ca537gyl4y"))))
3782     (build-system asdf-build-system/sbcl)
3783     (arguments
3784      '(#:asd-file "cl-syntax.asd"
3785        #:asd-system-name "cl-syntax"))
3786     (inputs `(("sbcl-trivial-types" ,sbcl-trivial-types)
3787               ("sbcl-named-readtables" ,sbcl-named-readtables)))
3788     (home-page "https://github.com/m2ym/cl-syntax")
3789     (synopsis "Reader Syntax Coventions for Common Lisp and SLIME")
3790     (description
3791      "CL-SYNTAX provides Reader Syntax Coventions for Common Lisp and SLIME.")
3792     (license license:llgpl)))
3793
3794 (define-public cl-syntax
3795   (sbcl-package->cl-source-package sbcl-cl-syntax))
3796
3797 (define-public sbcl-cl-annot
3798   (let ((commit "c99e69c15d935eabc671b483349a406e0da9518d")
3799         (revision "1"))
3800     (package
3801       (name "sbcl-cl-annot")
3802       (version (git-version "0.0.0" revision commit))
3803       (source
3804        (origin
3805          (method git-fetch)
3806          (uri (git-reference
3807                (url "https://github.com/m2ym/cl-annot.git")
3808                (commit commit)))
3809          (file-name (git-file-name name version))
3810          (sha256
3811           (base32 "1wq1gs9jjd5m6iwrv06c2d7i5dvqsfjcljgbspfbc93cg5xahk4n"))))
3812       (build-system asdf-build-system/sbcl)
3813     (arguments
3814      '(#:asd-file "cl-annot.asd"
3815        #:asd-system-name "cl-annot"))
3816       (inputs
3817        `(("sbcl-alexandria" ,sbcl-alexandria)))
3818       (home-page "https://github.com/m2ym/cl-annot")
3819       (synopsis "Python-like Annotation Syntax for Common Lisp.")
3820       (description
3821        "@code{cl-annot} is an general annotation library for Common Lisp.")
3822       (license license:llgpl))))
3823
3824 (define-public cl-annot
3825   (sbcl-package->cl-source-package sbcl-cl-annot))
3826
3827 (define-public sbcl-cl-syntax-annot
3828   (package
3829     (name "sbcl-cl-syntax-annot")
3830     (version "0.0.3")
3831     (source
3832      (origin
3833        (method git-fetch)
3834        (uri (git-reference
3835              (url "https://github.com/m2ym/cl-syntax.git")
3836              (commit "03f0c329bbd55b8622c37161e6278366525e2ccc")))
3837        (file-name (git-file-name name version))
3838        (sha256
3839         (base32 "17ran8xp77asagl31xv8w819wafh6whwfc9p6dgx22ca537gyl4y"))))
3840     (build-system asdf-build-system/sbcl)
3841     (arguments
3842      '(#:asd-file "cl-syntax-annot.asd"
3843        #:asd-system-name "cl-syntax-annot"))
3844     (inputs
3845      `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
3846        ("sbcl-cl-annot" ,sbcl-cl-annot)))
3847     (home-page "https://github.com/m2ym/cl-syntax")
3848     (synopsis "Reader Syntax Coventions for Common Lisp and SLIME")
3849     (description
3850      "CL-SYNTAX provides Reader Syntax Coventions for Common Lisp and
3851 SLIME.")
3852     (license license:llgpl)))
3853
3854 (define-public cl-syntax-annot
3855   (sbcl-package->cl-source-package sbcl-cl-syntax-annot))
3856
3857 (define-public sbcl-cl-utilities
3858   (let ((commit "dce2d2f6387091ea90357a130fa6d13a6776884b")
3859         (revision "1"))
3860     (package
3861       (name "sbcl-cl-utilities")
3862       (version (git-version "0.0.0" revision commit))
3863       (source
3864        (origin
3865          (method url-fetch)
3866          (uri
3867           (string-append
3868            "https://gitlab.common-lisp.net/cl-utilities/cl-utilities/-/"
3869            "archive/" commit "/cl-utilities-" commit ".tar.gz"))
3870          (sha256
3871           (base32 "1r46v730yf96nk2vb24qmagv9x96xvd08abqwhf02ghgydv1a7z2"))))
3872       (build-system asdf-build-system/sbcl)
3873       (arguments
3874        '(#:asd-file "cl-utilities.asd"
3875          #:asd-system-name "cl-utilities"
3876          #:phases
3877          (modify-phases %standard-phases
3878            (add-after 'unpack 'fix-paths
3879              (lambda* (#:key inputs #:allow-other-keys)
3880                (substitute* "rotate-byte.lisp"
3881                  (("in-package :cl-utilities)" all)
3882                   "in-package :cl-utilities)\n\n#+sbcl\n(require :sb-rotate-byte)")))))))
3883       (home-page "http://common-lisp.net/project/cl-utilities")
3884       (synopsis "A collection of semi-standard utilities")
3885       (description
3886        "On Cliki.net <http://www.cliki.net/Common%20Lisp%20Utilities>, there
3887 is a collection of Common Lisp Utilities, things that everybody writes since
3888 they're not part of the official standard.  There are some very useful things
3889 there; the only problems are that they aren't implemented as well as you'd
3890 like (some aren't implemented at all) and they aren't conveniently packaged
3891 and maintained.  It takes quite a bit of work to carefully implement utilities
3892 for common use, commented and documented, with error checking placed
3893 everywhere some dumb user might make a mistake.")
3894       (license license:public-domain))))
3895
3896 (define-public cl-utilities
3897   (sbcl-package->cl-source-package sbcl-cl-utilities))
3898
3899 (define-public sbcl-map-set
3900   (let ((commit "7b4b545b68b8")
3901         (revision "1"))
3902     (package
3903       (name "sbcl-map-set")
3904       (version (git-version "0.0.0" revision commit))
3905       (source
3906        (origin
3907          (method url-fetch)
3908          (uri (string-append
3909                "https://bitbucket.org/tarballs_are_good/map-set/get/"
3910                commit ".tar.gz"))
3911          (sha256
3912           (base32 "1sx5j5qdsy5fklspfammwb16kjrhkggdavm922a9q86jm5l0b239"))))
3913       (build-system asdf-build-system/sbcl)
3914       (home-page "https://bitbucket.org/tarballs_are_good/map-set")
3915       (synopsis "Set-like data structure")
3916       (description
3917        "Implementation of a set-like data structure with constant time
3918 addition, removal, and random selection.")
3919       (license license:bsd-3))))
3920
3921 (define-public cl-map-set
3922   (sbcl-package->cl-source-package sbcl-map-set))
3923
3924 (define-public sbcl-quri
3925   (let ((commit "76b75103f21ead092c9f715512fa82441ef61185")
3926         (revision "1"))
3927     (package
3928       (name "sbcl-quri")
3929       (version (git-version "0.1.0" revision commit))
3930       (source
3931        (origin
3932          (method git-fetch)
3933          (uri (git-reference
3934                (url "https://github.com/fukamachi/quri.git")
3935                (commit commit)))
3936          (file-name (git-file-name name version))
3937          (sha256
3938           (base32 "1ccbxsgzdibmzq33mmbmmz9vwl6l03xh6nbpsh1hkdvdcl7q0a60"))))
3939       (build-system asdf-build-system/sbcl)
3940       (arguments
3941        ;; Tests fail with: Component QURI-ASD::QURI-TEST not found,
3942        ;; required by #<SYSTEM "quri">. Why?
3943        '(#:tests? #f))
3944       (native-inputs `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
3945                        ("sbcl-prove" ,sbcl-prove)))
3946       (inputs `(("sbcl-babel" ,sbcl-babel)
3947                 ("sbcl-split-sequence" ,sbcl-split-sequence)
3948                 ("sbcl-cl-utilities" ,sbcl-cl-utilities)
3949                 ("sbcl-alexandria" ,sbcl-alexandria)))
3950       (home-page "https://github.com/fukamachi/quri")
3951       (synopsis "Yet another URI library for Common Lisp")
3952       (description
3953        "QURI (pronounced \"Q-ree\") is yet another URI library for Common
3954 Lisp. It is intended to be a replacement of PURI.")
3955       (license license:bsd-3))))
3956
3957 (define-public cl-quri
3958   (sbcl-package->cl-source-package sbcl-quri))
3959
3960 (define-public sbcl-myway
3961   (let ((commit "286230082a11f879c18b93f17ca571c5f676bfb7")
3962         (revision "1"))
3963     (package
3964      (name "sbcl-myway")
3965      (version (git-version "0.1.0" revision commit))
3966      (source
3967       (origin
3968        (method git-fetch)
3969        (uri (git-reference
3970              (url "https://github.com/fukamachi/myway.git")
3971              (commit commit)))
3972        (file-name (git-file-name "myway" version))
3973        (sha256
3974         (base32 "0briia9bk3lbr0frnx39d1qg6i38dm4j6z9w3yga3d40k6df4a90"))))
3975      (build-system asdf-build-system/sbcl)
3976      (arguments
3977       ;; Tests fail with: Component MYWAY-ASD::MYWAY-TEST not found, required
3978       ;; by #<SYSTEM "myway">. Why?
3979       '(#:tests? #f))
3980      (native-inputs
3981       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
3982         ("sbcl-prove" ,sbcl-prove)))
3983      (inputs
3984       `(("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
3985         ("sbcl-quri" ,sbcl-quri)
3986         ("sbcl-map-set" ,sbcl-map-set)))
3987      (home-page "https://github.com/fukamachi/myway")
3988      (synopsis "Sinatra-compatible URL routing library for Common Lisp")
3989      (description "My Way is a Sinatra-compatible URL routing library.")
3990      (license license:llgpl))))
3991
3992 (define-public cl-myway
3993   (sbcl-package->cl-source-package sbcl-myway))
3994
3995 (define-public sbcl-xsubseq
3996   (let ((commit "5ce430b3da5cda3a73b9cf5cee4df2843034422b")
3997         (revision "1"))
3998     (package
3999      (name "sbcl-xsubseq")
4000      (version (git-version "0.0.1" revision commit))
4001      (source
4002       (origin
4003        (method git-fetch)
4004        (uri (git-reference
4005              (url "https://github.com/fukamachi/xsubseq")
4006              (commit commit)))
4007        (file-name (git-file-name name version))
4008        (sha256
4009         (base32 "1xz79q0p2mclf3sqjiwf6izdpb6xrsr350bv4mlmdlm6rg5r99px"))))
4010      (build-system asdf-build-system/sbcl)
4011      (arguments
4012       ;; Tests fail with: Component XSUBSEQ-ASD::XSUBSEQ-TEST not found,
4013       ;; required by #<SYSTEM "xsubseq">. Why?
4014       '(#:tests? #f))
4015      (native-inputs
4016       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4017         ("sbcl-prove" ,sbcl-prove)))
4018      (home-page "https://github.com/fukamachi/xsubseq")
4019      (synopsis "Efficient way to use \"subseq\"s in Common Lisp")
4020      (description
4021       "XSubseq provides functions to be able to handle \"subseq\"s more
4022 effieiently.")
4023      (license license:bsd-2))))
4024
4025 (define-public cl-xsubseq
4026   (sbcl-package->cl-source-package sbcl-xsubseq))
4027
4028 (define-public sbcl-smart-buffer
4029   (let ((commit "09b9a9a0b3abaa37abe9a730f5aac2643dca4e62")
4030         (revision "1"))
4031     (package
4032       (name "sbcl-smart-buffer")
4033       (version (git-version "0.0.1" revision commit))
4034       (source
4035        (origin
4036          (method git-fetch)
4037          (uri (git-reference
4038                (url "https://github.com/fukamachi/smart-buffer")
4039                (commit commit)))
4040          (file-name (git-file-name name version))
4041          (sha256
4042           (base32 "0qz1zzxx0wm5ff7gpgsq550a59p0qj594zfmm2rglj97dahj54l7"))))
4043       (build-system asdf-build-system/sbcl)
4044       (arguments
4045        ;; Tests fail with: Component SMART-BUFFER-ASD::SMART-BUFFER-TEST not
4046        ;; found, required by #<SYSTEM "smart-buffer">. Why?
4047        `(#:tests? #f))
4048       (native-inputs
4049        `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4050          ("sbcl-prove" ,sbcl-prove)))
4051       (inputs
4052        `(("sbcl-xsubseq" ,sbcl-xsubseq)
4053          ("sbcl-flexi-streams" ,sbcl-flexi-streams)))
4054       (home-page "https://github.com/fukamachi/smart-buffer")
4055       (synopsis "Smart octets buffer")
4056       (description
4057        "Smart-buffer provides an output buffer which changes the destination
4058 depending on content size.")
4059       (license license:bsd-3))))
4060
4061 (define-public cl-smart-buffer
4062   (sbcl-package->cl-source-package sbcl-smart-buffer))
4063
4064 (define-public sbcl-fast-http
4065   (let ((commit "f9e7597191bae380503e20724fd493a24d024935")
4066         (revision "1"))
4067     (package
4068       (name "sbcl-fast-http")
4069       (version (git-version "0.2.0" revision commit))
4070       (source
4071        (origin
4072          (method git-fetch)
4073          (uri (git-reference
4074                (url "https://github.com/fukamachi/fast-http")
4075                (commit commit)))
4076          (file-name (git-file-name name version))
4077          (sha256
4078           (base32 "0qdmwv2zm0sizxdb8nnclgwl0nfjcbjaimbakavikijw7lr9b4jp"))))
4079       (build-system asdf-build-system/sbcl)
4080       (arguments
4081        ;; Tests fail with: Component FAST-HTTP-ASD::FAST-HTTP-TEST not found,
4082        ;; required by #<SYSTEM "fast-http">. Why?
4083        `(#:tests? #f))
4084       (native-inputs
4085        `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4086          ("sbcl-prove" ,sbcl-prove)))
4087       (inputs
4088        `(("sbcl-alexandria" ,sbcl-alexandria)
4089          ("sbcl-proc-parse" ,sbcl-proc-parse)
4090          ("sbcl-xsubseq" ,sbcl-xsubseq)
4091          ("sbcl-smart-buffer" ,sbcl-smart-buffer)
4092          ("sbcl-cl-utilities" ,sbcl-cl-utilities)))
4093       (home-page "https://github.com/fukamachi/fast-http")
4094       (synopsis "HTTP request/response parser for Common Lisp")
4095       (description
4096        "@code{fast-http} is a HTTP request/response protocol parser for Common
4097 Lisp.")
4098       ;; Author specified the MIT license
4099       (license license:expat))))
4100
4101 (define-public cl-fast-http
4102   (sbcl-package->cl-source-package sbcl-fast-http))
4103
4104 (define-public sbcl-static-vectors
4105   (package
4106     (name "sbcl-static-vectors")
4107     (version "1.8.4")
4108     (source
4109      (origin
4110        (method git-fetch)
4111        (uri (git-reference
4112              (url "https://github.com/sionescu/static-vectors.git")
4113              (commit (string-append "v" version))))
4114        (file-name (git-file-name name version))
4115        (sha256
4116         (base32 "0qvf9z6bhwhm8n45fjwkm7j8dcb58szfvndky65cyn4lpdval7m1"))))
4117     (native-inputs
4118      `(("sbcl-fiveam" ,sbcl-fiveam)))
4119     (inputs
4120      `(("sbcl-cffi-grovel" ,sbcl-cffi-grovel)
4121        ("sbcl-cffi" ,sbcl-cffi)))
4122     (build-system asdf-build-system/sbcl)
4123     (home-page "http://common-lisp.net/projects/iolib/")
4124     (synopsis "Allocate SIMPLE-ARRAYs in static memory")
4125     (description
4126      "With @code{static-vectors}, you can create vectors allocated in static
4127 memory.")
4128     (license license:expat)))
4129
4130 (define-public cl-static-vectors
4131   (sbcl-package->cl-source-package sbcl-static-vectors))
4132
4133 (define-public sbcl-marshal
4134   (let ((commit "eff1b15f2b0af2f26f71ad6a4dd5c4beab9299ec")
4135         (revision "1"))
4136     (package
4137      (name "sbcl-marshal")
4138      (version (git-version "1.3.0" revision commit))
4139      (source
4140       (origin
4141        (method git-fetch)
4142        (uri (git-reference
4143              (url "https://github.com/wlbr/cl-marshal.git")
4144              (commit commit)))
4145        (file-name (git-file-name name version))
4146        (sha256
4147         (base32 "08qs6fhk38xpkkjkpcj92mxx0lgy4ygrbbzrmnivdx281syr0gwh"))))
4148      (build-system asdf-build-system/sbcl)
4149      (home-page "https://github.com/wlbr/cl-marshal")
4150      (synopsis "Simple (de)serialization of Lisp datastructures")
4151      (description
4152       "Simple and fast marshalling of Lisp datastructures.  Convert any object
4153 into a string representation, put it on a stream an revive it from there.
4154 Only minimal changes required to make your CLOS objects serializable.")
4155      (license license:expat))))
4156
4157 (define-public cl-marshal
4158   (sbcl-package->cl-source-package sbcl-marshal))
4159
4160 (define-public sbcl-checkl
4161   (let ((commit "80328800d047fef9b6e32dfe6bdc98396aee3cc9")
4162         (revision "1"))
4163     (package
4164       (name "sbcl-checkl")
4165       (version (git-version "0.0.0" revision commit))
4166       (source
4167        (origin
4168          (method git-fetch)
4169          (uri (git-reference
4170                (url "https://github.com/rpav/CheckL.git")
4171                (commit commit)))
4172          (file-name (git-file-name name version))
4173          (sha256
4174           (base32 "0bpisihx1gay44xmyr1dmhlwh00j0zzi04rp9fy35i95l2r4xdlx"))))
4175       (build-system asdf-build-system/sbcl)
4176       (arguments
4177        ;; Error while trying to load definition for system checkl-test from
4178        ;; pathname [...]/checkl-test.asd: The function CHECKL:DEFINE-TEST-OP
4179        ;; is undefined.
4180        '(#:tests? #f))
4181       (native-inputs
4182        `(("sbcl-fiveam" ,sbcl-fiveam)))
4183       (inputs
4184        `(("sbcl-marshal" ,sbcl-marshal)))
4185       (home-page "https://github.com/rpav/CheckL/")
4186       (synopsis "Dynamic testing for Common Lisp")
4187       (description
4188        "CheckL lets you write tests dynamically, it checks resulting values
4189 against the last run.")
4190       ;; The author specifies both LLGPL and "BSD", but the "BSD" license
4191       ;; isn't specified anywhere, so I don't know which kind.  LLGPL is the
4192       ;; stronger of the two and so I think only listing this should suffice.
4193       (license license:llgpl))))
4194
4195 (define-public cl-checkl
4196   (sbcl-package->cl-source-package sbcl-checkl))
4197
4198 (define-public sbcl-fast-io
4199   (let ((commit "dc3a71db7e9b756a88781ae9c342fe9d4bbab51c")
4200         (revision "1"))
4201     (package
4202      (name "sbcl-fast-io")
4203      (version (git-version "1.0.0" revision commit))
4204      (source
4205       (origin
4206        (method git-fetch)
4207        (uri (git-reference
4208              (url "https://github.com/rpav/fast-io.git")
4209              (commit commit)))
4210        (file-name (git-file-name name version))
4211        (sha256
4212         (base32 "1jsp6xvi26ln6fdy5j5zi05xvan8jsqdhisv552dy6xg6ws8i1yq"))))
4213      (build-system asdf-build-system/sbcl)
4214      (arguments
4215       ;; Error while trying to load definition for system fast-io-test from
4216       ;; pathname [...]/fast-io-test.asd: The function CHECKL:DEFINE-TEST-OP
4217       ;; is undefined.
4218       '(#:tests? #f))
4219      (native-inputs
4220       `(("sbcl-fiveam" ,sbcl-fiveam)
4221         ("sbcl-checkl" ,sbcl-checkl)))
4222      (inputs
4223       `(("sbcl-alexandria" ,sbcl-alexandria)
4224         ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)
4225         ("sbcl-static-vectors" ,sbcl-static-vectors)))
4226      (home-page "https://github.com/rpav/fast-io")
4227      (synopsis "Fast octet-vector/stream I/O for Common Lisp")
4228      (description
4229       "Fast-io is about improving performance to octet-vectors and octet
4230 streams (though primarily the former, while wrapping the latter).")
4231      ;; Author specifies this as NewBSD which is an alias
4232      (license license:bsd-3))))
4233
4234 (define-public cl-fast-io
4235   (sbcl-package->cl-source-package sbcl-fast-io))
4236
4237 (define-public sbcl-jonathan
4238   (let ((commit "1f448b4f7ac8265e56e1c02b32ce383e65316300")
4239         (revision "1"))
4240     (package
4241      (name "sbcl-jonathan")
4242      (version (git-version "0.1.0" revision commit))
4243      (source
4244       (origin
4245        (method git-fetch)
4246        (uri (git-reference
4247              (url "https://github.com/Rudolph-Miller/jonathan.git")
4248              (commit commit)))
4249        (file-name (git-file-name name version))
4250        (sha256
4251         (base32 "14x4iwz3mbag5jzzzr4sb6ai0m9r4q4kyypbq32jmsk2dx1hi807"))))
4252      (build-system asdf-build-system/sbcl)
4253      (arguments
4254       ;; Tests fail with: Component JONATHAN-ASD::JONATHAN-TEST not found,
4255       ;; required by #<SYSTEM "jonathan">. Why?
4256       `(#:tests? #f))
4257      (native-inputs
4258       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4259         ("sbcl-prove" ,sbcl-prove)))
4260      (inputs
4261       `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
4262         ("sbcl-cl-syntax-annot" ,sbcl-cl-syntax-annot)
4263         ("sbcl-fast-io" ,sbcl-fast-io)
4264         ("sbcl-proc-parse" ,sbcl-proc-parse)
4265         ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)))
4266      (home-page "http://rudolph-miller.github.io/jonathan/overview.html")
4267      (synopsis "JSON encoder and decoder")
4268      (description
4269       "High performance JSON encoder and decoder.  Currently support: SBCL,
4270 CCL.")
4271      ;; Author specifies the MIT license
4272      (license license:expat))))
4273
4274 (define-public cl-jonathan
4275   (sbcl-package->cl-source-package sbcl-jonathan))
4276
4277 (define-public sbcl-http-body
4278   (let ((commit "dd01dc4f5842e3d29728552e5163acce8386eb73")
4279         (revision "1"))
4280     (package
4281      (name "sbcl-http-body")
4282      (version (git-version "0.1.0" revision commit))
4283      (source
4284       (origin
4285        (method git-fetch)
4286        (uri (git-reference
4287              (url "https://github.com/fukamachi/http-body")
4288              (commit commit)))
4289        (file-name (git-file-name name version))
4290        (sha256
4291         (base32 "1jd06snjvxcprhapgfq8sx0y5lrldkvhf206ix6d5a23dd6zcmr0"))))
4292      (build-system asdf-build-system/sbcl)
4293      (arguments
4294       ;; Tests fail with: Component HTTP-BODY-ASD::HTTP-BODY-TEST not
4295       ;; found, required by #<SYSTEM "http-body">. Why?
4296       `(#:tests? #f))
4297      (native-inputs
4298       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4299         ("sbcl-prove" ,sbcl-prove)))
4300      (inputs
4301       `(("sbcl-fast-http" ,sbcl-fast-http)
4302         ("sbcl-jonathan" ,sbcl-jonathan)
4303         ("sbcl-quri" ,sbcl-quri)))
4304      (home-page "https://github.com/fukamachi/http-body")
4305      (synopsis "HTTP POST data parser")
4306      (description
4307       "HTTP-Body parses HTTP POST data and returns POST parameters.  It
4308 supports application/x-www-form-urlencoded, application/json, and
4309 multipart/form-data.")
4310      (license license:bsd-2))))
4311
4312 (define-public cl-http-body
4313   (sbcl-package->cl-source-package sbcl-http-body))
4314
4315 (define-public sbcl-circular-streams
4316   (let ((commit "e770bade1919c5e8533dd2078c93c3d3bbeb38df")
4317         (revision "1"))
4318     (package
4319      (name "sbcl-circular-streams")
4320      (version (git-version "0.1.0" revision commit))
4321      (source
4322       (origin
4323        (method git-fetch)
4324        (uri (git-reference
4325              (url "https://github.com/fukamachi/circular-streams")
4326              (commit commit)))
4327        (file-name (git-file-name name version))
4328        (sha256
4329         (base32 "1wpw6d5cciyqcf92f7mvihak52pd5s47kk4qq6f0r2z2as68p5rs"))))
4330      (build-system asdf-build-system/sbcl)
4331      (arguments
4332       ;; The tests depend on cl-test-more which is now prove. Prove
4333       ;; tests aren't working for some reason.
4334       `(#:tests? #f))
4335      (inputs
4336       `(("sbcl-fast-io" ,sbcl-fast-io)
4337         ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)))
4338      (home-page "https://github.com/fukamachi/circular-streams")
4339      (synopsis "Circularly readable streams for Common Lisp")
4340      (description
4341       "Circular-Streams allows you to read streams circularly by wrapping real
4342 streams. Once you reach end-of-file of a stream, it's file position will be
4343 reset to 0 and you're able to read it again.")
4344      (license license:llgpl))))
4345
4346 (define-public cl-circular-streams
4347   (sbcl-package->cl-source-package sbcl-circular-streams))
4348
4349 (define-public sbcl-lack-request
4350   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4351         (revision "1"))
4352     (package
4353      (name "sbcl-lack-request")
4354      (version (git-version "0.1.0" revision commit))
4355      (source
4356       (origin
4357        (method git-fetch)
4358        (uri (git-reference
4359              (url "https://github.com/fukamachi/lack.git")
4360              (commit commit)))
4361        (file-name (git-file-name "lack-request" version))
4362        (sha256
4363         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4364      (build-system asdf-build-system/sbcl)
4365      (arguments
4366       '(#:asd-file "lack-request.asd"
4367         #:asd-system-name "lack-request"
4368         #:test-asd-file "t-lack-request.asd"
4369         ;; XXX: Component :CLACK-TEST not found
4370         #:tests? #f))
4371      (native-inputs
4372       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4373         ("sbcl-prove" ,sbcl-prove)))
4374      (inputs
4375       `(("sbcl-quri" ,sbcl-quri)
4376         ("sbcl-http-body" ,sbcl-http-body)
4377         ("sbcl-circular-streams" ,sbcl-circular-streams)))
4378      (home-page "https://github.com/fukamachi/lack")
4379      (synopsis "Lack, the core of Clack")
4380      (description
4381       "Lack is a Common Lisp library which allows web applications to be
4382 constructed of modular components.  It was originally a part of Clack, however
4383 it's going to be rewritten as an individual project since Clack v2 with
4384 performance and simplicity in mind.")
4385      (license license:llgpl))))
4386
4387 (define-public cl-lack-request
4388   (sbcl-package->cl-source-package sbcl-lack-request))
4389
4390 (define-public sbcl-local-time
4391   (let ((commit "beac054eef428552b63d4ae7820c32ffef9a3015")
4392         (revision "1"))
4393     (package
4394      (name "sbcl-local-time")
4395      (version (git-version "1.0.6" revision commit))
4396      (source
4397       (origin
4398        (method git-fetch)
4399        (uri (git-reference
4400              (url "https://github.com/dlowe-net/local-time.git")
4401              (commit commit)))
4402        (file-name (git-file-name name version))
4403        (sha256
4404         (base32 "0xhkmgxh41dg2wwlsp0h2l41jp144xn4gpxhh0lna6kh0560w2cc"))))
4405      (build-system asdf-build-system/sbcl)
4406      (arguments
4407       ;; TODO: Component :STEFIL not found, required by #<SYSTEM
4408       ;; "local-time/test">
4409       '(#:tests? #f))
4410      (native-inputs
4411       `(("stefil" ,sbcl-hu.dwim.stefil)))
4412      (inputs
4413       `(("sbcl-cl-fad" ,sbcl-cl-fad)))
4414      (home-page "https://common-lisp.net/project/local-time/")
4415      (synopsis "Time manipulation library for Common Lisp")
4416      (description
4417       "The LOCAL-TIME library is a Common Lisp library for the manipulation of
4418 dates and times.  It is based almost entirely upon Erik Naggum's paper \"The
4419 Long Painful History of Time\".")
4420      (license license:expat))))
4421
4422 (define-public cl-local-time
4423   (sbcl-package->cl-source-package sbcl-local-time))
4424
4425 (define-public sbcl-lack-response
4426   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4427         (revision "1"))
4428     (package
4429      (name "sbcl-lack-response")
4430      (version (git-version "0.1.0" revision commit))
4431      (source
4432       (origin
4433        (method git-fetch)
4434        (uri (git-reference
4435              (url "https://github.com/fukamachi/lack.git")
4436              (commit commit)))
4437        (file-name (git-file-name name version))
4438        (sha256
4439         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4440      (build-system asdf-build-system/sbcl)
4441      (arguments
4442       '(#:asd-file "lack-response.asd"
4443         #:asd-system-name "lack-response"
4444         ;; XXX: no tests for lack-response.
4445         #:tests? #f))
4446      (native-inputs
4447       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4448         ("sbcl-prove" ,sbcl-prove)))
4449      (inputs
4450       `(("sbcl-quri" ,sbcl-quri)
4451         ("sbcl-http-body" ,sbcl-http-body)
4452         ("sbcl-circular-streams" ,sbcl-circular-streams)
4453         ("sbcl-local-time" ,sbcl-local-time)))
4454      (home-page "https://github.com/fukamachi/lack")
4455      (synopsis "Lack, the core of Clack")
4456      (description
4457       "Lack is a Common Lisp library which allows web applications to be
4458 constructed of modular components.  It was originally a part of Clack, however
4459 it's going to be rewritten as an individual project since Clack v2 with
4460 performance and simplicity in mind.")
4461      (license license:llgpl))))
4462
4463 (define-public cl-lack-response
4464   (sbcl-package->cl-source-package sbcl-lack-response))
4465
4466 (define-public sbcl-lack-component
4467   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4468         (revision "1"))
4469     (package
4470      (name "sbcl-lack-component")
4471      (version (git-version "0.0.0" revision commit))
4472      (source
4473       (origin
4474        (method git-fetch)
4475        (uri (git-reference
4476              (url "https://github.com/fukamachi/lack.git")
4477              (commit commit)))
4478        (file-name (git-file-name "lack-component" version))
4479        (sha256
4480         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4481      (build-system asdf-build-system/sbcl)
4482      (arguments
4483       '(#:asd-file "lack-component.asd"
4484         #:asd-system-name "lack-component"
4485         #:test-asd-file "t-lack-component.asd"
4486         ;; XXX: Component :LACK-TEST not found
4487         #:tests? #f))
4488      (native-inputs
4489       `(("prove-asdf" ,sbcl-prove-asdf)))
4490      (home-page "https://github.com/fukamachi/lack")
4491      (synopsis "Lack, the core of Clack")
4492      (description
4493       "Lack is a Common Lisp library which allows web applications to be
4494 constructed of modular components.  It was originally a part of Clack, however
4495 it's going to be rewritten as an individual project since Clack v2 with
4496 performance and simplicity in mind.")
4497      (license license:llgpl))))
4498
4499 (define-public cl-lack-component
4500   (sbcl-package->cl-source-package sbcl-lack-component))
4501
4502 (define-public sbcl-lack-util
4503   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4504         (revision "1"))
4505     (package
4506      (name "sbcl-lack-util")
4507      (version (git-version "0.1.0" revision commit))
4508      (source
4509       (origin
4510        (method git-fetch)
4511        (uri (git-reference
4512              (url "https://github.com/fukamachi/lack.git")
4513              (commit commit)))
4514        (file-name (git-file-name "lack-util" version))
4515        (sha256
4516         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4517      (build-system asdf-build-system/sbcl)
4518      (arguments
4519       '(#:asd-file "lack-util.asd"
4520         #:asd-system-name "lack-util"
4521         #:test-asd-file "t-lack-util.asd"
4522         ;; XXX: Component :LACK-TEST not found
4523         #:tests? #f))
4524      (native-inputs
4525       `(("prove-asdf" ,sbcl-prove-asdf)))
4526      (inputs
4527       `(("sbcl-ironclad" ,sbcl-ironclad)))
4528      (home-page "https://github.com/fukamachi/lack")
4529      (synopsis "Lack, the core of Clack")
4530      (description
4531       "Lack is a Common Lisp library which allows web applications to be
4532 constructed of modular components.  It was originally a part of Clack, however
4533 it's going to be rewritten as an individual project since Clack v2 with
4534 performance and simplicity in mind.")
4535      (license license:llgpl))))
4536
4537 (define-public cl-lack-util
4538   (sbcl-package->cl-source-package sbcl-lack-util))
4539
4540 (define-public sbcl-lack-middleware-backtrace
4541   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4542         (revision "1"))
4543     (package
4544      (name "sbcl-lack-middleware-backtrace")
4545      (version (git-version "0.1.0" revision commit))
4546      (source
4547       (origin
4548        (method git-fetch)
4549        (uri (git-reference
4550              (url "https://github.com/fukamachi/lack.git")
4551              (commit commit)))
4552        (file-name (git-file-name "lack-middleware-backtrace" version))
4553        (sha256
4554         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4555      (build-system asdf-build-system/sbcl)
4556      (arguments
4557       '(#:asd-file "lack-middleware-backtrace.asd"
4558         #:asd-system-name "lack-middleware-backtrace"
4559         #:test-asd-file "t-lack-middleware-backtrace.asd"
4560         ;; XXX: Component :LACK not found
4561         #:tests? #f))
4562      (native-inputs
4563       `(("prove-asdf" ,sbcl-prove-asdf)))
4564      (home-page "https://github.com/fukamachi/lack")
4565      (synopsis "Lack, the core of Clack")
4566      (description
4567       "Lack is a Common Lisp library which allows web applications to be
4568 constructed of modular components.  It was originally a part of Clack, however
4569 it's going to be rewritten as an individual project since Clack v2 with
4570 performance and simplicity in mind.")
4571      (license license:llgpl))))
4572
4573 (define-public cl-lack-middleware-backtrace
4574   (sbcl-package->cl-source-package sbcl-lack-middleware-backtrace))
4575
4576 (define-public sbcl-trivial-mimes
4577   (let ((commit "303f8ac0aa6ca0bc139aa3c34822e623c3723fab")
4578         (revision "1"))
4579     (package
4580       (name "sbcl-trivial-mimes")
4581       (version (git-version "1.1.0" revision commit))
4582       (source
4583        (origin
4584          (method git-fetch)
4585          (uri (git-reference
4586                (url "https://github.com/Shinmera/trivial-mimes.git")
4587                (commit commit)))
4588          (file-name (git-file-name name version))
4589          (sha256
4590           (base32 "17jxgl47r695bvsb7wi3n2ws5rp1zzgvw0zii8cy5ggw4b4ayv6m"))))
4591       (build-system asdf-build-system/sbcl)
4592       (arguments
4593        '(#:phases
4594          (modify-phases %standard-phases
4595            (add-after
4596                'unpack 'fix-paths
4597              (lambda* (#:key inputs #:allow-other-keys)
4598                (let ((anchor "#p\"/etc/mime.types\""))
4599                  (substitute* "mime-types.lisp"
4600                    ((anchor all)
4601                     (string-append
4602                      anchor "\n"
4603                      "(asdf:system-relative-pathname :trivial-mimes "
4604                      "\"../../share/common-lisp/" (%lisp-type)
4605                      "-source/trivial-mimes/mime.types\")")))))))))
4606       (native-inputs
4607        `(("stefil" ,sbcl-hu.dwim.stefil)))
4608       (inputs
4609        `(("sbcl-cl-fad" ,sbcl-cl-fad)))
4610       (home-page "http://shinmera.github.io/trivial-mimes/")
4611       (synopsis "Tiny Common Lisp library to detect mime types in files")
4612       (description
4613        "This is a teensy library that provides some functions to determine the
4614 mime-type of a file.")
4615       (license license:artistic2.0))))
4616
4617 (define-public cl-trivial-mimes
4618   (sbcl-package->cl-source-package sbcl-trivial-mimes))
4619
4620 (define-public ecl-trivial-mimes
4621   (sbcl-package->ecl-package sbcl-trivial-mimes))
4622
4623 (define-public sbcl-lack-middleware-static
4624   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4625         (revision "1"))
4626     (package
4627      (name "sbcl-lack-middleware-static")
4628      (version (git-version "0.1.0" revision commit))
4629      (source
4630       (origin
4631        (method git-fetch)
4632        (uri (git-reference
4633              (url "https://github.com/fukamachi/lack.git")
4634              (commit commit)))
4635        (file-name (git-file-name "lack-middleware-static" version))
4636        (sha256
4637         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4638      (build-system asdf-build-system/sbcl)
4639      (arguments
4640       '(#:asd-file "lack-middleware-static.asd"
4641         #:asd-system-name "lack-middleware-static"
4642         #:test-asd-file "t-lack-middleware-static.asd"
4643         ;; XXX: Component :LACK not found
4644         #:tests? #f))
4645      (native-inputs
4646       `(("prove-asdf" ,sbcl-prove-asdf)))
4647      (inputs
4648       `(("sbcl-ironclad" ,sbcl-ironclad)
4649         ("sbcl-trivial-mimes" ,sbcl-trivial-mimes)
4650         ("sbcl-local-time" ,sbcl-local-time)))
4651      (home-page "https://github.com/fukamachi/lack")
4652      (synopsis "Lack, the core of Clack")
4653      (description
4654       "Lack is a Common Lisp library which allows web applications to be
4655 constructed of modular components.  It was originally a part of Clack, however
4656 it's going to be rewritten as an individual project since Clack v2 with
4657 performance and simplicity in mind.")
4658      (license license:llgpl))))
4659
4660 (define-public cl-lack-middleware-static
4661   (sbcl-package->cl-source-package sbcl-lack-middleware-static))
4662
4663 (define-public sbcl-lack
4664   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4665         (revision "1"))
4666     (package
4667      (name "sbcl-lack")
4668      (version (git-version "0.1.0" revision commit))
4669      (source
4670       (origin
4671        (method git-fetch)
4672        (uri (git-reference
4673              (url "https://github.com/fukamachi/lack.git")
4674              (commit commit)))
4675        (file-name (git-file-name "lack" version))
4676        (sha256
4677         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4678      (build-system asdf-build-system/sbcl)
4679      (arguments
4680       '(#:test-asd-file "t-lack.asd"
4681         ;; XXX: Component :CLACK not found
4682         #:tests? #f))
4683      (native-inputs
4684       `(("prove-asdf" ,sbcl-prove-asdf)))
4685      (inputs
4686       `(("sbcl-lack-component" ,sbcl-lack-component)
4687         ("sbcl-lack-util" ,sbcl-lack-util)))
4688      (home-page "https://github.com/fukamachi/lack")
4689      (synopsis "Lack, the core of Clack")
4690      (description
4691       "Lack is a Common Lisp library which allows web applications to be
4692 constructed of modular components.  It was originally a part of Clack, however
4693 it's going to be rewritten as an individual project since Clack v2 with
4694 performance and simplicity in mind.")
4695      (license license:llgpl))))
4696
4697 (define-public cl-lack
4698   (sbcl-package->cl-source-package sbcl-lack))
4699
4700 (define-public sbcl-ningle
4701   (let ((commit "50bd4f09b5a03a7249bd4d78265d6451563b25ad")
4702         (revision "1"))
4703     (package
4704       (name "sbcl-ningle")
4705       (version (git-version "0.3.0" revision commit))
4706       (source
4707        (origin
4708          (method git-fetch)
4709          (uri (git-reference
4710                (url "https://github.com/fukamachi/ningle.git")
4711                (commit commit)))
4712          (file-name (git-file-name name version))
4713          (sha256
4714           (base32 "1bsl8cnxhacb8p92z9n89vhk1ikmij5zavk0m2zvmj7iqm79jzgw"))))
4715       (build-system asdf-build-system/sbcl)
4716       (arguments
4717        ;; TODO: pull in clack-test
4718        '(#:tests? #f
4719          #:phases
4720          (modify-phases %standard-phases
4721            (delete 'cleanup-files)
4722            (delete 'cleanup)
4723            (add-before 'cleanup 'combine-fasls
4724              (lambda* (#:key outputs #:allow-other-keys)
4725                (let* ((out (assoc-ref outputs "out"))
4726                       (lib (string-append out "/lib/sbcl"))
4727                       (ningle-path (string-append lib "/ningle"))
4728                       (fasl-files (find-files out "\\.fasl$")))
4729                  (mkdir-p ningle-path)
4730                  (let ((fasl-path (lambda (name)
4731                                     (string-append ningle-path
4732                                                    "/"
4733                                                    (basename name)
4734                                                    "--system.fasl"))))
4735                    (for-each (lambda (file)
4736                                (rename-file file
4737                                             (fasl-path
4738                                              (basename file ".fasl"))))
4739                              fasl-files))
4740                  fasl-files)
4741                #t)))))
4742       (native-inputs
4743        `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4744          ("sbcl-prove" ,sbcl-prove)))
4745       (inputs
4746        `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
4747          ("sbcl-cl-syntax-annot" ,sbcl-cl-syntax-annot)
4748          ("sbcl-myway" ,sbcl-myway)
4749          ("sbcl-lack-request" ,sbcl-lack-request)
4750          ("sbcl-lack-response" ,sbcl-lack-response)
4751          ("sbcl-lack-component" ,sbcl-lack-component)
4752          ("sbcl-alexandria" ,sbcl-alexandria)
4753          ("sbcl-babel" ,sbcl-babel)))
4754       (home-page "http://8arrow.org/ningle/")
4755       (synopsis "Super micro framework for Common Lisp")
4756       (description
4757        "Ningle is a lightweight web application framework for Common Lisp.")
4758       (license license:llgpl))))
4759
4760 (define-public cl-ningle
4761   (sbcl-package->cl-source-package sbcl-ningle))
4762
4763 (define-public sbcl-clack
4764   (let ((commit "e3e032843bb1220ab96263c411aa7f2feb4746e0")
4765         (revision "1"))
4766     (package
4767      (name "sbcl-clack")
4768      (version (git-version "2.0.0" revision commit))
4769      (source
4770       (origin
4771        (method git-fetch)
4772        (uri (git-reference
4773              (url "https://github.com/fukamachi/clack.git")
4774              (commit commit)))
4775        (file-name (git-file-name name version))
4776        (sha256
4777         (base32 "1ymzs6qyrwhlj6cgqsnpyn6g5cbp7a3s1vgxwna20y2q7y4iacy0"))))
4778      (build-system asdf-build-system/sbcl)
4779      (inputs
4780       `(("sbcl-lack" ,sbcl-lack)
4781         ("sbcl-lack-middleware-backtrace" ,sbcl-lack-middleware-backtrace)
4782         ("sbcl-bordeaux-threads" ,sbcl-bordeaux-threads)))
4783      (home-page "https://github.com/fukamachi/clack")
4784      (synopsis "Web Application Environment for Common Lisp")
4785      (description
4786       "Clack is a web application environment for Common Lisp inspired by
4787 Python's WSGI and Ruby's Rack.")
4788      (license license:llgpl))))
4789
4790 (define-public cl-clack
4791   (sbcl-package->cl-source-package sbcl-clack))
4792
4793 (define-public sbcl-log4cl
4794   (let ((commit "611e094458504b938d49de904eab141285328c7c")
4795         (revision "1"))
4796     (package
4797       (name "sbcl-log4cl")
4798       (build-system asdf-build-system/sbcl)
4799       (version "1.1.2")
4800       (source
4801        (origin
4802          (method git-fetch)
4803          (uri (git-reference
4804                (url "https://github.com/sharplispers/log4cl")
4805                (commit commit)))
4806          (file-name (git-file-name name version))
4807          (sha256
4808           (base32
4809            "08jly0s0g26b56hhpfizxsb4j0yvbh946sd205gr42dkzv8l7dsc"))))
4810       ;; FIXME: tests require stefil, sbcl-hu.dwim.stefil wont work
4811       (arguments
4812        `(#:tests? #f))
4813       (inputs `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
4814       (synopsis "Common Lisp logging framework, modeled after Log4J")
4815       (home-page "https://github.com/7max/log4cl")
4816       (description "This is a Common Lisp logging framework that can log at
4817 various levels and mix text with expressions.")
4818       (license license:asl2.0))))
4819
4820 (define-public cl-log4cl
4821   (sbcl-package->cl-source-package sbcl-log4cl))
4822
4823 (define-public ecl-log4cl
4824   (sbcl-package->ecl-package sbcl-log4cl))
4825
4826 (define-public sbcl-find-port
4827   (let ((commit "00c96a25af93a0f8681d34ec548861f2d7485478")
4828         (revision "1"))
4829     (package
4830       (name "sbcl-find-port")
4831       (build-system asdf-build-system/sbcl)
4832       (version "0.1")
4833       (home-page "https://github.com/eudoxia0/find-port")
4834       (source
4835        (origin
4836          (method git-fetch)
4837          (uri (git-reference
4838                (url home-page)
4839                (commit commit)))
4840          (file-name (git-file-name name version))
4841          (sha256
4842           (base32
4843            "0d6dzbb45jh0rx90wgs6v020k2xa87mvzas3mvfzvivjvqqlpryq"))))
4844       (native-inputs
4845        `(("fiveam" ,sbcl-fiveam)))
4846       (inputs
4847        `(("sbcl-usocket" ,sbcl-usocket)))
4848       (synopsis "Find open ports programmatically in Common Lisp")
4849       (description "This is a small Common Lisp library that finds an open
4850 port within a range.")
4851       (license license:expat))))
4852
4853 (define-public cl-find-port
4854   (sbcl-package->cl-source-package sbcl-find-port))
4855
4856 (define-public ecl-find-port
4857   (sbcl-package->ecl-package sbcl-find-port))
4858
4859 (define-public sbcl-clunit
4860   (let ((commit "6f6d72873f0e1207f037470105969384f8380628")
4861         (revision "1"))
4862     (package
4863       (name "sbcl-clunit")
4864       (version (git-version "0.2.3" revision commit))
4865       (source
4866        (origin
4867          (method git-fetch)
4868          (uri (git-reference
4869                (url "https://github.com/tgutu/clunit.git")
4870                (commit commit)))
4871          (file-name (git-file-name name version))
4872          (sha256
4873           (base32
4874            "1idf2xnqzlhi8rbrqmzpmb3i1l6pbdzhhajkmhwbp6qjkmxa4h85"))))
4875       (build-system asdf-build-system/sbcl)
4876       (synopsis "CLUnit is a Common Lisp unit testing framework")
4877       (description
4878        "CLUnit is a Common Lisp unit testing framework.  It is designed
4879 to be easy to use so that you can quickly start testing.  CLUnit
4880 provides a rich set of features aimed at improving your unit testing
4881 experience.")
4882       (home-page "http://tgutu.github.io/clunit/")
4883       ;; MIT License
4884       (license license:expat))))
4885
4886 (define-public cl-clunit
4887   (sbcl-package->cl-source-package sbcl-clunit))
4888
4889 (define-public ecl-clunit
4890   (sbcl-package->ecl-package sbcl-clunit))
4891
4892 (define-public sbcl-py4cl
4893   (let ((commit "4c8a2b0814fd311f978964f825ce012290f60136")
4894         (revision "1"))
4895     (package
4896       (name "sbcl-py4cl")
4897       (version (git-version "0.0.0" revision commit))
4898       (source
4899        (origin
4900          (method git-fetch)
4901          (uri (git-reference
4902                (url "https://github.com/bendudson/py4cl.git")
4903                (commit commit)))
4904          (file-name (git-file-name name version))
4905          (sha256
4906           (base32
4907            "15mk7qdqjkj56gdnbyrdyz6r7m1h26ldvn6ch96pmvg5vmr1m45r"))
4908          (modules '((guix build utils)))))
4909       (build-system asdf-build-system/sbcl)
4910       (native-inputs
4911        `(("sbcl-clunit" ,sbcl-clunit)))
4912       (inputs
4913        `(("sbcl-trivial-garbage" ,sbcl-trivial-garbage)))
4914       (propagated-inputs
4915        ;; This package doesn't do anything without python available
4916        `(("python" ,python)
4917          ;; For multi-dimensional array support
4918          ("python-numpy" ,python-numpy)))
4919       (arguments
4920        '(#:phases
4921          (modify-phases %standard-phases
4922            (add-after 'unpack 'replace-*base-directory*-var
4923              (lambda* (#:key outputs #:allow-other-keys)
4924                ;; In the ASD, the author makes an attempt to
4925                ;; programatically determine the location of the
4926                ;; source-code so lisp can call into "py4cl.py". We can
4927                ;; hard-code this since we know where this file will
4928                ;; reside.
4929                (substitute* "src/callpython.lisp"
4930                  (("py4cl/config:\\*base-directory\\*")
4931                   (string-append
4932                    "\""
4933                    (assoc-ref outputs "out")
4934                    "/share/common-lisp/sbcl-source/py4cl/"
4935                    "\""))))))))
4936       (synopsis "Call python from Common Lisp")
4937       (description
4938        "Py4CL is a bridge between Common Lisp and Python, which enables Common
4939 Lisp to interact with Python code.  It uses streams to communicate with a
4940 separate python process, the approach taken by cl4py.  This is different to
4941 the CFFI approach used by burgled-batteries, but has the same goal.")
4942       (home-page "https://github.com/bendudson/py4cl")
4943       ;; MIT License
4944       (license license:expat))))
4945
4946 (define-public cl-py4cl
4947   (sbcl-package->cl-source-package sbcl-py4cl))
4948
4949 (define-public ecl-py4cl
4950   (sbcl-package->ecl-package sbcl-py4cl))
4951
4952 (define-public sbcl-parse-declarations
4953   (package
4954     (name "sbcl-parse-declarations")
4955     (version "1.0.0")
4956     (source
4957      (origin
4958        (method url-fetch)
4959        (uri (string-append
4960              "http://beta.quicklisp.org/archive/parse-declarations/"
4961              "2010-10-06/parse-declarations-20101006-darcs.tgz"))
4962        (sha256
4963         (base32
4964          "0r85b0jfacd28kr65kw9c13dx4i6id1dpmby68zjy63mqbnyawrd"))))
4965     (build-system asdf-build-system/sbcl)
4966     (arguments
4967      `(#:asd-file "parse-declarations-1.0.asd"
4968        #:asd-system-name "parse-declarations-1.0"))
4969     (home-page "https://common-lisp.net/project/parse-declarations/")
4970     (synopsis "Parse, filter, and build declarations")
4971     (description
4972      "Parse-Declarations is a Common Lisp library to help writing
4973 macros which establish bindings.  To be semantically correct, such
4974 macros must take user declarations into account, as these may affect
4975 the bindings they establish.  Yet the ANSI standard of Common Lisp does
4976 not provide any operators to work with declarations in a convenient,
4977 high-level way.  This library provides such operators.")
4978     ;; MIT License
4979     (license license:expat)))
4980
4981 (define-public cl-parse-declarations
4982   (sbcl-package->cl-source-package sbcl-parse-declarations))
4983
4984 (define-public ecl-parse-declarations
4985   (sbcl-package->ecl-package sbcl-parse-declarations))
4986
4987 (define-public sbcl-cl-quickcheck
4988   (let ((commit "807b2792a30c883a2fbecea8e7db355b50ba662f")
4989         (revision "1"))
4990     (package
4991       (name "sbcl-cl-quickcheck")
4992       (version (git-version "0.0.4" revision commit))
4993       (source
4994        (origin
4995          (method git-fetch)
4996          (uri (git-reference
4997                (url "https://github.com/mcandre/cl-quickcheck.git")
4998                (commit commit)))
4999          (file-name (git-file-name name version))
5000          (sha256
5001           (base32
5002            "165lhypq5xkcys6hvzb3jq7ywnmqvzaflda29qk2cbs3ggas4767"))))
5003       (build-system asdf-build-system/sbcl)
5004       (synopsis
5005        "Common Lisp port of the QuickCheck unit test framework")
5006       (description
5007        "Common Lisp port of the QuickCheck unit test framework")
5008       (home-page "https://github.com/mcandre/cl-quickcheck")
5009       ;; MIT
5010       (license license:expat))))
5011
5012 (define-public cl-cl-quickcheck
5013   (sbcl-package->cl-source-package sbcl-cl-quickcheck))
5014
5015 (define-public ecl-cl-quickcheck
5016   (sbcl-package->ecl-package sbcl-cl-quickcheck))
5017
5018 (define-public sbcl-burgled-batteries3
5019   (let ((commit "9c0f6667e1a71ddf77e21793a0bea524710fef6e")
5020         (revision "1"))
5021     (package
5022       (name "sbcl-burgled-batteries3")
5023       (version (git-version "0.0.0" revision commit))
5024       (source
5025        (origin
5026          (method git-fetch)
5027          (uri (git-reference
5028                (url "https://github.com/snmsts/burgled-batteries3.git")
5029                (commit commit)))
5030          (file-name (git-file-name name version))
5031          (sha256
5032           (base32
5033            "0b726kz2xxcg5l930gz035rsdvhxrzmp05iwfwympnb4z4ammicb"))))
5034       (build-system asdf-build-system/sbcl)
5035       (arguments
5036        '(#:tests? #f
5037          #:phases
5038          (modify-phases %standard-phases
5039            (add-after 'unpack 'set-*cpython-include-dir*-var
5040              (lambda* (#:key inputs #:allow-other-keys)
5041                (substitute* "grovel-include-dir.lisp"
5042                  (("\\(defparameter \\*cpython-include-dir\\* \\(detect-python\\)\\)")
5043                   (string-append
5044                    "(defparameter *cpython-include-dir* \""
5045                    (assoc-ref inputs "python")
5046                    "/include/python3.7m"
5047                    "\")")))
5048                (substitute* "ffi-interface.lisp"
5049                  (("\\*cpython-lib\\*")
5050                   (format #f "'(\"~a/lib/libpython3.so\")"
5051                           (assoc-ref inputs "python"))))
5052                #t)))))
5053       (native-inputs
5054        `(("python" ,python)
5055          ("sbcl-cl-fad" ,sbcl-cl-fad)
5056          ("sbcl-lift" ,sbcl-lift)
5057          ("sbcl-cl-quickcheck" ,sbcl-cl-quickcheck)))
5058       (inputs
5059        `(("sbcl-cffi" ,sbcl-cffi)
5060          ("sbcl-cffi-grovel" ,sbcl-cffi-grovel)
5061          ("sbcl-alexandria" , sbcl-alexandria)
5062          ("sbcl-parse-declarations-1.0" ,sbcl-parse-declarations)
5063          ("sbcl-trivial-garbage" ,sbcl-trivial-garbage)))
5064       (synopsis "Bridge between Python and Lisp (FFI bindings, etc.)")
5065       (description
5066        "This package provides a shim between Python3 (specifically, the
5067 CPython implementation of Python) and Common Lisp.")
5068       (home-page "https://github.com/snmsts/burgled-batteries3")
5069       ;; MIT
5070       (license license:expat))))
5071
5072 (define-public cl-burgled-batteries3
5073   (sbcl-package->cl-source-package sbcl-burgled-batteries3))
5074
5075 (define-public ecl-burgled-batteries3
5076   (sbcl-package->ecl-package sbcl-burgled-batteries3))
5077
5078 (define-public sbcl-metabang-bind
5079   (let ((commit "c93b7f7e1c18c954c2283efd6a7fdab36746ab5e")
5080         (revision "1"))
5081     (package
5082       (name "sbcl-metabang-bind")
5083       (version (git-version "0.8.0" revision commit))
5084       (source
5085        (origin
5086          (method git-fetch)
5087          (uri (git-reference
5088                (url "https://github.com/gwkkwg/metabang-bind.git")
5089                (commit commit)))
5090          (file-name (git-file-name name version))
5091          (sha256
5092           (base32
5093            "0hd0kr91795v77akpbcyqiss9p0p7ypa9dznrllincnmgvsxlmf0"))))
5094       (build-system asdf-build-system/sbcl)
5095       (native-inputs
5096        `(("sbcl-lift" ,sbcl-lift)))
5097       (synopsis "Macro that generalizes @code{multiple-value-bind} etc.")
5098       (description
5099        "Bind extends the idea of of let and destructing to provide a uniform
5100 syntax for all your accessor needs.  It combines @code{let},
5101 @code{destructuring-bind}, @code{with-slots}, @code{with-accessors}, structure
5102 editing, property or association-lists, and @code{multiple-value-bind} and a
5103 whole lot more into a single form.")
5104       (home-page "https://common-lisp.net/project/metabang-bind/")
5105       ;; MIT License
5106       (license license:expat))))
5107
5108 (define-public cl-metabang-bind
5109   (sbcl-package->cl-source-package sbcl-metabang-bind))
5110
5111 (define-public ecl-metabang-bind
5112   (sbcl-package->ecl-package sbcl-metabang-bind))
5113
5114 (define-public sbcl-fare-utils
5115   (let ((commit "66e9c6f1499140bc00ccc22febf2aa528cbb5724")
5116         (revision "1"))
5117     (package
5118       (name "sbcl-fare-utils")
5119       (version (git-version "1.0.0.5" revision commit))
5120       (source
5121        (origin
5122          (method git-fetch)
5123          (uri
5124           (git-reference
5125            (url
5126             "https://gitlab.common-lisp.net/frideau/fare-utils.git")
5127            (commit commit)))
5128          (file-name (git-file-name name version))
5129          (sha256
5130           (base32
5131            "01wsr1aap3jdzhn4hrqjbhsjx6qci9dbd3gh4gayv1p49rbg8aqr"))))
5132       (build-system asdf-build-system/sbcl)
5133       (arguments
5134        `(#:test-asd-file "test/fare-utils-test.asd"))
5135       (native-inputs
5136        `(("sbcl-hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
5137       (synopsis "Collection of utilities and data structures")
5138       (description
5139        "fare-utils is a small collection of utilities.  It contains a lot of
5140 basic everyday functions and macros.")
5141       (home-page "https://gitlab.common-lisp.net/frideau/fare-utils")
5142       ;; MIT License
5143       (license license:expat))))
5144
5145 (define-public cl-fare-utils
5146   (sbcl-package->cl-source-package sbcl-fare-utils))
5147
5148 (define-public ecl-fare-utils
5149   (sbcl-package->ecl-package sbcl-fare-utils))
5150
5151 (define-public sbcl-trivial-utf-8
5152   (let ((commit "4d427cfbb1c452436a0efb71c3205c9da67f718f")
5153         (revision "1"))
5154     (package
5155       (name "sbcl-trivial-utf-8")
5156       (version (git-version "0.0.0" revision commit))
5157       (source
5158        (origin
5159          (method git-fetch)
5160          (uri
5161           (git-reference
5162            (url (string-append "https://gitlab.common-lisp.net/"
5163                                "trivial-utf-8/trivial-utf-8.git"))
5164            (commit commit)))
5165          (file-name (git-file-name name version))
5166          (sha256
5167           (base32
5168            "1jz27gz8gvqdmvp3k9bxschs6d5b3qgk94qp2bj6nv1d0jc3m1l1"))))
5169       (arguments
5170        ;; Guix incorrectly assumes the "8" is part of the version
5171        ;; number and lobs it off.
5172        `(#:asd-file "trivial-utf-8.asd"
5173          #:asd-system-name "trivial-utf-8"))
5174       (build-system asdf-build-system/sbcl)
5175       (synopsis "UTF-8 input/output library")
5176       (description
5177        "The Babel library solves a similar problem while understanding more
5178 encodings.  Trivial UTF-8 was written before Babel existed, but for new
5179 projects you might be better off going with Babel.  The one plus that Trivial
5180 UTF-8 has is that it doesn't depend on any other libraries.")
5181       (home-page "https://common-lisp.net/project/trivial-utf-8/")
5182       (license license:bsd-3))))
5183
5184 (define-public cl-trivial-utf-8
5185   (sbcl-package->cl-source-package sbcl-trivial-utf-8))
5186
5187 (define-public ecl-trivial-utf-8
5188   (sbcl-package->ecl-package sbcl-trivial-utf-8))
5189
5190 (define-public sbcl-idna
5191   (package
5192     (name "sbcl-idna")
5193     (build-system asdf-build-system/sbcl)
5194     (version "0.2.2")
5195     (home-page "https://github.com/antifuchs/idna")
5196     (source
5197      (origin
5198        (method git-fetch)
5199        (uri (git-reference
5200              (url home-page)
5201              (commit version)))
5202        (file-name (git-file-name name version))
5203        (sha256
5204         (base32
5205          "00nbr3mffxhlq14gg9d16pa6691s4qh35inyw76v906s77khm5a2"))))
5206     (inputs
5207      `(("split-sequence" ,sbcl-split-sequence)))
5208     (synopsis "IDNA string encoding and decoding routines for Common Lisp")
5209     (description "This Common Lisp library provides string encoding and
5210 decoding routines for IDNA, the International Domain Names in Applications.")
5211     (license license:expat)))
5212
5213 (define-public cl-idna
5214   (sbcl-package->cl-source-package sbcl-idna))
5215
5216 (define-public ecl-idna
5217   (sbcl-package->ecl-package sbcl-idna))
5218
5219 (define-public sbcl-swap-bytes
5220   (package
5221     (name "sbcl-swap-bytes")
5222     (build-system asdf-build-system/sbcl)
5223     (version "1.2")
5224     (home-page "https://github.com/sionescu/swap-bytes")
5225     (source
5226      (origin
5227        (method git-fetch)
5228        (uri (git-reference
5229              (url home-page)
5230              (commit (string-append "v" version))))
5231        (file-name (git-file-name name version))
5232        (sha256
5233         (base32
5234          "1hw1v1lw26rifyznpnj1csphha9jgzwpiic16ni3pvs6hcsni9rz"))))
5235     (inputs
5236      `(("trivial-features" ,sbcl-trivial-features)))
5237     (native-inputs
5238      `(("fiveam" ,sbcl-fiveam)))
5239     (synopsis "Efficient endianness conversion for Common Lisp")
5240     (description "This Common Lisp library provides optimized byte-swapping
5241 primitives.  The library can change endianness of unsigned integers of length
5242 1/2/4/8.  Very useful in implementing various network protocols and file
5243 formats.")
5244     (license license:expat)))
5245
5246 (define-public cl-swap-bytes
5247   (sbcl-package->cl-source-package sbcl-swap-bytes))
5248
5249 (define-public ecl-swap-bytes
5250   (sbcl-package->ecl-package sbcl-swap-bytes))
5251
5252 (define-public sbcl-iolib.asdf
5253   ;; Latest release is from June 2017.
5254   (let ((commit "81e20614c0d27f9605bf9766214e236fd31b99b4")
5255         (revision "1"))
5256     (package
5257       (name "sbcl-iolib.asdf")
5258       (build-system asdf-build-system/sbcl)
5259       (version "0.8.3")
5260       (home-page "https://github.com/sionescu/iolib")
5261       (source
5262        (origin
5263          (method git-fetch)
5264          (uri (git-reference
5265                (url home-page)
5266                (commit commit)))
5267          (file-name (git-file-name name version))
5268          (sha256
5269           (base32
5270            "1j81r0wm7nfbwl991f26s4npcy7kybzybd3m47rbxy31h0cfcmdm"))))
5271       (inputs
5272        `(("alexandria" ,sbcl-alexandria)))
5273       (arguments
5274        '(#:asd-file "iolib.asdf.asd"))
5275       (synopsis "ASDF component classes for IOLib, a Common Lisp I/O library")
5276       (description "IOlib is to be a better and more modern I/O library than
5277 the standard Common Lisp library.  It contains a socket library, a DNS
5278 resolver, an I/O multiplexer(which supports @code{select(2)}, @code{epoll(4)}
5279 and @code{kqueue(2)}), a pathname library and file-system utilities.")
5280       (license license:expat))))
5281
5282 (define-public sbcl-iolib.conf
5283   (package
5284     (inherit sbcl-iolib.asdf)
5285     (name "sbcl-iolib.conf")
5286     (inputs
5287      `(("iolib.asdf" ,sbcl-iolib.asdf)))
5288     (arguments
5289      '(#:asd-file "iolib.conf.asd"))
5290     (synopsis "Compile-time configuration for IOLib, a Common Lisp I/O library")))
5291
5292 (define-public sbcl-iolib.common-lisp
5293   (package
5294     (inherit sbcl-iolib.asdf)
5295     (name "sbcl-iolib.common-lisp")
5296     (inputs
5297      `(("iolib.asdf" ,sbcl-iolib.asdf)
5298        ("iolib.conf" ,sbcl-iolib.conf)))
5299     (arguments
5300      '(#:asd-file "iolib.common-lisp.asd"))
5301     (synopsis "Slightly modified Common Lisp for IOLib, a Common Lisp I/O library")))
5302
5303 (define-public sbcl-iolib.base
5304   (package
5305     (inherit sbcl-iolib.asdf)
5306     (name "sbcl-iolib.base")
5307     (inputs
5308      `(("iolib.asdf" ,sbcl-iolib.asdf)
5309        ("iolib.conf" ,sbcl-iolib.conf)
5310        ("iolib.common-lisp" ,sbcl-iolib.common-lisp)
5311        ("split-sequence" ,sbcl-split-sequence)))
5312     (arguments
5313      '(#:asd-file "iolib.base.asd"))
5314     (synopsis "Base package for IOLib, a Common Lisp I/O library")))
5315
5316 (define-public sbcl-iolib.grovel
5317   (package
5318     (inherit sbcl-iolib.asdf)
5319     (name "sbcl-iolib.grovel")
5320     (inputs
5321      `(("iolib.asdf" ,sbcl-iolib.asdf)
5322        ("iolib.conf" ,sbcl-iolib.conf)
5323        ("iolib.base", sbcl-iolib.base)
5324        ("cffi", sbcl-cffi)))
5325     (arguments
5326      '(#:asd-file "iolib.grovel.asd"
5327        #:phases
5328        (modify-phases %standard-phases
5329          (add-after 'install 'install-header
5330            (lambda* (#:key outputs #:allow-other-keys)
5331              ;; This header is required by sbcl-iolib.
5332              (install-file "src/grovel/grovel-common.h"
5333                            (string-append (assoc-ref outputs "out")
5334                                           "/lib/sbcl"))
5335              #t)))))
5336     (synopsis "CFFI Groveller for IOLib, a Common Lisp I/O library")))
5337
5338 (define-public sbcl-iolib
5339   (package
5340     (inherit sbcl-iolib.asdf)
5341     (name "sbcl-iolib")
5342     (inputs
5343      `(("iolib.asdf" ,sbcl-iolib.asdf)
5344        ("iolib.conf" ,sbcl-iolib.conf)
5345        ("iolib.grovel" ,sbcl-iolib.grovel)
5346        ("iolib.base" ,sbcl-iolib.base)
5347        ("bordeaux-threads" ,sbcl-bordeaux-threads)
5348        ("idna" ,sbcl-idna)
5349        ("swap-bytes" ,sbcl-swap-bytes)
5350        ("libfixposix" ,libfixposix)
5351        ("cffi" ,sbcl-cffi)))
5352     (native-inputs
5353      `(("fiveam" ,sbcl-fiveam)))
5354     (arguments
5355      '(#:asd-file "iolib.asd"
5356        #:asd-system-name "iolib"
5357        #:test-asd-file "iolib.tests.asd"
5358        #:phases
5359        (modify-phases %standard-phases
5360          (add-after 'unpack 'fix-paths
5361            (lambda* (#:key inputs #:allow-other-keys)
5362              (substitute* "src/syscalls/ffi-functions-unix.lisp"
5363                (("\\(:default \"libfixposix\"\\)")
5364                 (string-append
5365                  "(:default \""
5366                  (assoc-ref inputs "libfixposix") "/lib/libfixposix\")")))
5367              ;; Socket tests need Internet access, disable them.
5368              (substitute* "iolib.tests.asd"
5369                (("\\(:file \"sockets\" :depends-on \\(\"pkgdcl\" \"defsuites\"\\)\\)")
5370                 "")))))))
5371     (synopsis "Common Lisp I/O library")))
5372
5373 (define-public cl-iolib
5374   (sbcl-package->cl-source-package sbcl-iolib))
5375
5376 (define sbcl-iolib+multiplex
5377   (package
5378     (inherit sbcl-iolib)
5379     (name "sbcl-iolib+multiplex")
5380     (arguments
5381      (substitute-keyword-arguments (package-arguments sbcl-iolib)
5382        ((#:asd-system-name _) "iolib/multiplex")))))
5383
5384 (define sbcl-iolib+syscalls
5385   (package
5386     (inherit sbcl-iolib)
5387     (name "sbcl-iolib+syscalls")
5388     (arguments
5389      (substitute-keyword-arguments (package-arguments sbcl-iolib)
5390        ((#:asd-system-name _) "iolib/syscalls")))))
5391
5392 (define sbcl-iolib+streams
5393   (package
5394     (inherit sbcl-iolib)
5395     (name "sbcl-iolib+streams")
5396     (arguments
5397      (substitute-keyword-arguments (package-arguments sbcl-iolib)
5398        ((#:asd-system-name _) "iolib/streams")))))
5399
5400 (define sbcl-iolib+sockets
5401   (package
5402     (inherit sbcl-iolib)
5403     (name "sbcl-iolib+sockets")
5404     (arguments
5405      (substitute-keyword-arguments (package-arguments sbcl-iolib)
5406        ((#:asd-system-name _) "iolib/sockets")))))
5407
5408 (define-public sbcl-ieee-floats
5409   (let ((commit "566b51a005e81ff618554b9b2f0b795d3b29398d")
5410         (revision "1"))
5411     (package
5412       (name "sbcl-ieee-floats")
5413       (build-system asdf-build-system/sbcl)
5414       (version (git-version "20170924" revision commit))
5415       (home-page "https://github.com/marijnh/ieee-floats/")
5416       (source
5417        (origin
5418          (method git-fetch)
5419          (uri (git-reference
5420                (url home-page)
5421                (commit commit)))
5422          (file-name (git-file-name name version))
5423          (sha256
5424           (base32
5425            "1xyj49j9x3lc84cv3dhbf9ja34ywjk1c46dklx425fxw9mkwm83m"))))
5426       (native-inputs
5427        `(("fiveam" ,sbcl-fiveam)))
5428       (synopsis "IEEE 754 binary representation for floats in Common Lisp")
5429       (description "This is a Common Lisp library that allows to convert
5430 floating point values to IEEE 754 binary representation.")
5431       (license license:bsd-3))))
5432
5433 (define-public cl-ieee-floats
5434   (sbcl-package->cl-source-package sbcl-ieee-floats))
5435
5436 (define sbcl-closure-common
5437   (let ((commit "e3c5f5f454b72b01b89115e581c3c52a7e201e5c")
5438         (revision "1"))
5439     (package
5440       (name "sbcl-closure-common")
5441       (build-system asdf-build-system/sbcl)
5442       (version (git-version "20101006" revision commit))
5443       (home-page "https://common-lisp.net/project/cxml/")
5444       (source
5445        (origin
5446          (method git-fetch)
5447          (uri (git-reference
5448                (url "https://github.com/sharplispers/closure-common")
5449                (commit commit)))
5450          (file-name (git-file-name name version))
5451          (sha256
5452           (base32
5453            "0k5r2qxn122pxi301ijir3nayi9sg4d7yiy276l36qmzwhp4mg5n"))))
5454       (inputs
5455        `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)
5456          ("babel" ,sbcl-babel)))
5457       (synopsis "Support Common Lisp library for CXML")
5458       (description "Closure-common is an internal helper library.  The name
5459 Closure is a reference to the web browser it was originally written for.")
5460       ;; TODO: License?
5461       (license #f))))
5462
5463 (define-public sbcl-cxml+xml
5464   (let ((commit "00b22bf4c4cf11c993d5866fae284f95ab18e6bf")
5465         (revision "1"))
5466     (package
5467       (name "sbcl-cxml+xml")
5468       (build-system asdf-build-system/sbcl)
5469       (version (git-version "0.0.0" revision commit))
5470       (home-page "https://common-lisp.net/project/cxml/")
5471       (source
5472        (origin
5473          (method git-fetch)
5474          (uri (git-reference
5475                (url "https://github.com/sharplispers/cxml")
5476                (commit commit)))
5477          (file-name (git-file-name name version))
5478          (sha256
5479           (base32
5480            "13kif7rf3gqdycsk9zq0d7y0g9y81krkl0z87k0p2fkbjfgrph37"))))
5481       (inputs
5482        `(("closure-common" ,sbcl-closure-common)
5483          ("puri" ,sbcl-puri)
5484          ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
5485       (arguments
5486        `(#:asd-file "cxml.asd"
5487          #:asd-system-name "cxml/xml"))
5488       (synopsis "Common Lisp XML parser")
5489       (description "CXML implements a namespace-aware, validating XML 1.0
5490 parser as well as the DOM Level 2 Core interfaces.  Two parser interfaces are
5491 offered, one SAX-like, the other similar to StAX.")
5492       (license license:llgpl))))
5493
5494 (define sbcl-cxml+dom
5495   (package
5496     (inherit sbcl-cxml+xml)
5497     (name "sbcl-cxml+dom")
5498     (inputs
5499      `(("closure-common" ,sbcl-closure-common)
5500        ("puri" ,sbcl-puri)
5501        ("cxml+xml" ,sbcl-cxml+xml)))
5502     (arguments
5503      `(#:asd-file "cxml.asd"
5504        #:asd-system-name "cxml/dom"))))
5505
5506 (define sbcl-cxml+klacks
5507   (package
5508     (inherit sbcl-cxml+xml)
5509     (name "sbcl-cxml+klacks")
5510     (inputs
5511      `(("closure-common" ,sbcl-closure-common)
5512        ("puri" ,sbcl-puri)
5513        ("cxml+xml" ,sbcl-cxml+xml)))
5514     (arguments
5515      `(#:asd-file "cxml.asd"
5516        #:asd-system-name "cxml/klacks"))))
5517
5518 (define sbcl-cxml+test
5519   (package
5520     (inherit sbcl-cxml+xml)
5521     (name "sbcl-cxml+test")
5522     (inputs
5523      `(("closure-common" ,sbcl-closure-common)
5524        ("puri" ,sbcl-puri)
5525        ("cxml+xml" ,sbcl-cxml+xml)))
5526     (arguments
5527      `(#:asd-file "cxml.asd"
5528        #:asd-system-name "cxml/test"))))
5529
5530 (define-public sbcl-cxml
5531   (package
5532     (inherit sbcl-cxml+xml)
5533     (name "sbcl-cxml")
5534     (inputs
5535      `(("closure-common" ,sbcl-closure-common)
5536        ("puri" ,sbcl-puri)
5537        ("trivial-gray-streams" ,sbcl-trivial-gray-streams)
5538        ("cxml+dom" ,sbcl-cxml+dom)
5539        ("cxml+klacks" ,sbcl-cxml+klacks)
5540        ("cxml+test" ,sbcl-cxml+test)))
5541     (arguments
5542      `(#:asd-file "cxml.asd"
5543        #:asd-system-name "cxml"
5544        #:phases
5545        (modify-phases %standard-phases
5546          (add-after 'build 'install-dtd
5547            (lambda* (#:key outputs #:allow-other-keys)
5548              (install-file "catalog.dtd"
5549                            (string-append
5550                             (assoc-ref outputs "out")
5551                             "/lib/" (%lisp-type)))))
5552          (add-after 'create-asd 'remove-component
5553            ;; XXX: The original .asd has no components, but our build system
5554            ;; creates an entry nonetheless.  We need to remove it for the
5555            ;; generated .asd to load properly.  See trivia.trivial for a
5556            ;; similar problem.
5557            (lambda* (#:key outputs #:allow-other-keys)
5558              (let* ((out (assoc-ref outputs "out"))
5559                     (asd (string-append out "/lib/sbcl/cxml.asd")))
5560                (substitute* asd
5561                  (("  :components
5562 ")
5563                   ""))
5564                (substitute* asd
5565                  ((" *\\(\\(:compiled-file \"cxml--system\"\\)\\)")
5566                   ""))))))))))
5567
5568 (define-public cl-cxml
5569   (sbcl-package->cl-source-package sbcl-cxml))
5570
5571 (define-public sbcl-cl-reexport
5572   (let ((commit "312f3661bbe187b5f28536cd7ec2956e91366c3b")
5573         (revision "1"))
5574     (package
5575       (name "sbcl-cl-reexport")
5576       (build-system asdf-build-system/sbcl)
5577       (version (git-version "0.1" revision commit))
5578       (home-page "https://github.com/takagi/cl-reexport")
5579       (source
5580        (origin
5581          (method git-fetch)
5582          (uri (git-reference
5583                (url home-page)
5584                (commit commit)))
5585          (file-name (git-file-name name version))
5586          (sha256
5587           (base32
5588            "1cwpn1m3wrl0fl9plznn7p464db646gnfc8zkyk97dyxski2aq0x"))))
5589       (inputs
5590        `(("alexandria" ,sbcl-alexandria)))
5591       (arguments
5592        ;; TODO: Tests fail because cl-test-more is missing, but I can't find it online.
5593        `(#:tests? #f))
5594       (synopsis "HTTP cookie manager for Common Lisp")
5595       (description "cl-cookie is a Common Lisp library featuring parsing of
5596 cookie headers, cookie creation, cookie jar creation and more.")
5597       (license license:llgpl))))
5598
5599 (define-public cl-reexport
5600   (sbcl-package->cl-source-package sbcl-cl-reexport))
5601
5602 (define-public sbcl-cl-cookie
5603   (let ((commit "cea55aed8b9ad25fafd13defbcb9fe8f41b29546")
5604         (revision "1"))
5605     (package
5606       (name "sbcl-cl-cookie")
5607       (build-system asdf-build-system/sbcl)
5608       (version (git-version "0.9.10" revision commit))
5609       (home-page "https://github.com/fukamachi/cl-cookie")
5610       (source
5611        (origin
5612          (method git-fetch)
5613          (uri (git-reference
5614                (url home-page)
5615                (commit commit)))
5616          (file-name (git-file-name name version))
5617          (sha256
5618           (base32
5619            "090g7z75h98zvc1ldx0vh4jn4086dhjm2w30jcwkq553qmyxwl8h"))))
5620       (inputs
5621        `(("proc-parse" ,sbcl-proc-parse)
5622          ("alexandria" ,sbcl-alexandria)
5623          ("quri" ,sbcl-quri)
5624          ("cl-ppcre" ,sbcl-cl-ppcre)
5625          ("local-time" ,sbcl-local-time)))
5626       (native-inputs
5627        `(("prove-asdf" ,sbcl-prove-asdf)
5628          ("prove" ,sbcl-prove)))
5629       (arguments
5630        ;; TODO: Tests fail because cl-cookie depends on cl-cookie-test.
5631        `(#:tests? #f))
5632       (synopsis "HTTP cookie manager for Common Lisp")
5633       (description "cl-cookie is a Common Lisp library featuring parsing of
5634 cookie headers, cookie creation, cookie jar creation and more.")
5635       (license license:bsd-2))))
5636
5637 (define-public cl-cookie
5638   (sbcl-package->cl-source-package sbcl-cl-cookie))
5639
5640 (define-public sbcl-dexador
5641   (let ((commit "a2714d126cc94bc7a9a6e1e3c08de455b3a66378")
5642         (revision "1"))
5643     (package
5644       (name "sbcl-dexador")
5645       (build-system asdf-build-system/sbcl)
5646       (version (git-version "0.9.10" revision commit))
5647       (home-page "https://github.com/fukamachi/dexador")
5648       (source
5649        (origin
5650          (method git-fetch)
5651          (uri (git-reference
5652                (url home-page)
5653                (commit commit)))
5654          (file-name (git-file-name name version))
5655          (sha256
5656           (base32
5657            "0nbqgn4v3l2z6m1k1bdxfnqpfrk84nxdmz7csz11zzcfs4flkv79"))))
5658       (inputs
5659        `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)
5660          ("babel" ,sbcl-babel)
5661          ("usocket" ,sbcl-usocket)
5662          ("fast-http" ,sbcl-fast-http)
5663          ("quri" ,sbcl-quri)
5664          ("fast-io" ,sbcl-fast-io)
5665          ("chunga" ,sbcl-chunga)
5666          ("cl-ppcre" ,sbcl-cl-ppcre)
5667          ("cl-cookie" ,sbcl-cl-cookie)
5668          ("trivial-mimes" ,sbcl-trivial-mimes)
5669          ("chipz" ,sbcl-chipz)
5670          ("cl-base64" ,sbcl-cl-base64)
5671          ("cl-reexport" ,sbcl-cl-reexport)
5672          ("cl+ssl" ,sbcl-cl+ssl)
5673          ("bordeaux-threads" ,sbcl-bordeaux-threads)
5674          ("alexandria" ,sbcl-alexandria)))
5675       (native-inputs
5676        `(("prove" ,sbcl-prove)
5677          ("prove-asdf" ,sbcl-prove-asdf)
5678          ("lack-request" ,sbcl-lack-request)
5679          ("clack" ,sbcl-clack)
5680          ("babel" ,sbcl-babel)
5681          ("alexandria" ,sbcl-alexandria)
5682          ("cl-ppcre" ,sbcl-cl-ppcre)
5683          ("local-time" ,sbcl-local-time)))
5684       (arguments
5685        ;; TODO: Circular dependency: tests depend on clack-test which depends on dexador.
5686        `(#:tests? #f
5687          #:phases
5688          (modify-phases %standard-phases
5689            (add-after 'unpack 'fix-permissions
5690              (lambda _ (make-file-writable "t/data/test.gz") #t)))))
5691       (synopsis "Yet another HTTP client for Common Lisp")
5692       (description "Dexador is yet another HTTP client for Common Lisp with
5693 neat APIs and connection-pooling.  It is meant to supersede Drakma.")
5694       (license license:expat))))
5695
5696 (define-public cl-dexador
5697   (package
5698     (inherit (sbcl-package->cl-source-package sbcl-dexador))
5699     (arguments
5700      `(#:phases
5701        ;; asdf-build-system/source has its own phases and does not inherit
5702        ;; from asdf-build-system/sbcl phases.
5703        (modify-phases %standard-phases/source
5704          (add-after 'unpack 'fix-permissions
5705            (lambda _ (make-file-writable "t/data/test.gz") #t)))))))
5706
5707 (define-public ecl-dexador
5708   (sbcl-package->ecl-package sbcl-dexador))
5709
5710 (define-public sbcl-lisp-namespace
5711   (let ((commit "28107cafe34e4c1c67490fde60c7f92dc610b2e0")
5712         (revision "1"))
5713     (package
5714       (name "sbcl-lisp-namespace")
5715       (build-system asdf-build-system/sbcl)
5716       (version (git-version "0.1" revision commit))
5717       (home-page "https://github.com/guicho271828/lisp-namespace")
5718       (source
5719        (origin
5720          (method git-fetch)
5721          (uri (git-reference
5722                (url home-page)
5723                (commit commit)))
5724          (file-name (git-file-name name version))
5725          (sha256
5726           (base32
5727            "1jw2wykp06z2afb9nm1lgfzll5cjlj36pnknjx614057zkkxq4iy"))))
5728       (inputs
5729        `(("alexandria" ,sbcl-alexandria)))
5730       (native-inputs
5731        `(("fiveam" ,sbcl-fiveam)))
5732       (arguments
5733        `(#:test-asd-file "lisp-namespace.test.asd"
5734         ;; XXX: Component LISP-NAMESPACE-ASD::LISP-NAMESPACE.TEST not found
5735          #:tests? #f))
5736       (synopsis "LISP-N, or extensible namespaces in Common Lisp")
5737       (description "Common Lisp already has major 2 namespaces, function
5738 namespace and value namespace (or variable namespace), but there are actually
5739 more — e.g., class namespace.
5740 This library offers macros to deal with symbols from any namespace.")
5741       (license license:llgpl))))
5742
5743 (define-public cl-lisp-namespace
5744   (sbcl-package->cl-source-package sbcl-lisp-namespace))
5745
5746 (define-public sbcl-trivial-cltl2
5747   (let ((commit "8eec8407df833e8f27df8a388bc10913f16d9e83")
5748         (revision "1"))
5749     (package
5750       (name "sbcl-trivial-cltl2")
5751       (build-system asdf-build-system/sbcl)
5752       (version (git-version "0.1.1" revision commit))
5753       (home-page "https://github.com/Zulu-Inuoe/trivial-cltl2")
5754       (source
5755        (origin
5756          (method git-fetch)
5757          (uri (git-reference
5758                (url home-page)
5759                (commit commit)))
5760          (file-name (git-file-name name version))
5761          (sha256
5762           (base32
5763            "1dyyxz17vqv8hlfwq287gl8xxbvcnq798ajb7p5jdjz91wqf4bgk"))))
5764       (synopsis "Simple CLtL2 compatibility layer for Common Lisp")
5765       (description "This library is a portable compatibility layer around
5766 \"Common Lisp the Language, 2nd
5767 Edition\" (@url{https://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node102.html})
5768 and it exports symbols from implementation-specific packages.")
5769       (license license:llgpl))))
5770
5771 (define-public cl-trivial-cltl2
5772   (sbcl-package->cl-source-package sbcl-trivial-cltl2))
5773
5774 (define-public sbcl-introspect-environment
5775   (let ((commit "fff42f8f8fd0d99db5ad6c5812e53de7d660020b")
5776         (revision "1"))
5777     (package
5778       (name "sbcl-introspect-environment")
5779       (build-system asdf-build-system/sbcl)
5780       (version (git-version "0.1" revision commit))
5781       (home-page "https://github.com/Bike/introspect-environment")
5782       (source
5783        (origin
5784          (method git-fetch)
5785          (uri (git-reference
5786                (url home-page)
5787                (commit commit)))
5788          (file-name (git-file-name name version))
5789          (sha256
5790           (base32
5791            "1i305n0wfmpac63ni4i3vixnnkl8daw5ncxy0k3dv92krgx6qzhp"))))
5792       (native-inputs
5793        `(("fiveam" ,sbcl-fiveam)))
5794       (synopsis "Common Lisp environment introspection portability layer")
5795       (description "This library is a small interface to portable but
5796 nonstandard introspection of Common Lisp environments.  It is intended to
5797 allow a bit more compile-time introspection of environments in Common Lisp.
5798
5799 Quite a bit of information is available at the time a macro or compiler-macro
5800 runs; inlining info, type declarations, that sort of thing.  This information
5801 is all standard - any Common Lisp program can @code{(declare (integer x))} and
5802 such.
5803
5804 This info ought to be accessible through the standard @code{&environment}
5805 parameters, but it is not.  Several implementations keep the information for
5806 their own purposes but do not make it available to user programs, because
5807 there is no standard mechanism to do so.
5808
5809 This library uses implementation-specific hooks to make information available
5810 to users.  This is currently supported on SBCL, CCL, and CMUCL.  Other
5811 implementations have implementations of the functions that do as much as they
5812 can and/or provide reasonable defaults.")
5813       (license license:wtfpl2))))
5814
5815 (define-public cl-introspect-environment
5816   (sbcl-package->cl-source-package sbcl-introspect-environment))
5817
5818 (define-public sbcl-type-i
5819   (let ((commit "dea233f45f94064105ec09f0767de338f67dcbe2")
5820         (revision "1"))
5821     (package
5822       (name "sbcl-type-i")
5823       (build-system asdf-build-system/sbcl)
5824       (version (git-version "0.1" revision commit))
5825       (home-page "https://github.com/guicho271828/type-i")
5826       (source
5827        (origin
5828          (method git-fetch)
5829          (uri (git-reference
5830                (url home-page)
5831                (commit commit)))
5832          (file-name (git-file-name name version))
5833          (sha256
5834           (base32
5835            "039g5pbrhh65s0bhr9314gmd2nwc2y5lp2377c5qrc2lxky89qs3"))))
5836       (inputs
5837        `(("alexandria" ,sbcl-alexandria)
5838          ("introspect-environment" ,sbcl-introspect-environment)
5839          ("trivia.trivial" ,sbcl-trivia.trivial)))
5840       (native-inputs
5841        `(("fiveam" ,sbcl-fiveam)))
5842       (arguments
5843        `(#:test-asd-file "type-i.test.asd"))
5844       (synopsis "Type inference utility on unary predicates for Common Lisp")
5845       (description "This library tries to provide a way to detect what kind of
5846 type the given predicate is trying to check.  This is different from inferring
5847 the return type of a function.")
5848       (license license:llgpl))))
5849
5850 (define-public cl-type-i
5851   (sbcl-package->cl-source-package sbcl-type-i))
5852
5853 (define-public sbcl-optima
5854   (let ((commit "373b245b928c1a5cce91a6cb5bfe5dd77eb36195")
5855         (revision "1"))
5856     (package
5857       (name "sbcl-optima")
5858       (build-system asdf-build-system/sbcl)
5859       (version (git-version "1.0" revision commit))
5860       (home-page "https://github.com/m2ym/optima")
5861       (source
5862        (origin
5863          (method git-fetch)
5864          (uri (git-reference
5865                (url home-page)
5866                (commit commit)))
5867          (file-name (git-file-name name version))
5868          (sha256
5869           (base32
5870            "1yw4ymq7ms89342kkvb3aqxgv0w38m9kd8ikdqxxzyybnkjhndal"))))
5871       (inputs
5872        `(("alexandria" ,sbcl-alexandria)
5873          ("closer-mop" ,sbcl-closer-mop)))
5874       (native-inputs
5875        `(("eos" ,sbcl-eos)))
5876       (arguments
5877        ;; XXX: Circular dependencies: tests depend on optima.ppcre which depends on optima.
5878        `(#:tests? #f
5879          #:test-asd-file "optima.test.asd"))
5880       (synopsis "Optimized pattern matching library for Common Lisp")
5881       (description "Optima is a fast pattern matching library which uses
5882 optimizing techniques widely used in the functional programming world.")
5883       (license license:expat))))
5884
5885 (define-public cl-optima
5886   (sbcl-package->cl-source-package sbcl-optima))
5887
5888 (define-public sbcl-fare-quasiquote
5889   (package
5890     (name "sbcl-fare-quasiquote")
5891     (build-system asdf-build-system/sbcl)
5892     (version "20171130")
5893     (home-page "http://common-lisp.net/project/fare-quasiquote")
5894     (source
5895      (origin
5896        (method url-fetch)
5897        (uri (string-append "http://beta.quicklisp.org/archive/fare-quasiquote/"
5898                            (date->string (string->date version "~Y~m~d") "~Y-~m-~d")
5899                            "/fare-quasiquote-"
5900                            version
5901                            "-git.tgz"))
5902        (sha256
5903         (base32
5904          "00brmh7ndsi0c97nibi8cy10j3l4gmkyrfrr5jr5lzkfb7ngyfqa"))))
5905     (inputs
5906      `(("fare-utils" ,sbcl-fare-utils)))
5907     (arguments
5908      ;; XXX: Circular dependencies: Tests depend on subsystems, which depend on the main systems.
5909      `(#:tests? #f
5910        #:phases
5911        (modify-phases %standard-phases
5912          ;; XXX: Require 1.0.0 version of fare-utils, and we package some
5913          ;; commits after 1.0.0.5, but ASDF fails to read the
5914          ;; "-REVISION-COMMIT" part generated by Guix.
5915          (add-after 'unpack 'patch-requirement
5916            (lambda _
5917              (substitute* "fare-quasiquote.asd"
5918                (("\\(:version \"fare-utils\" \"1.0.0\"\\)") "\"fare-utils\"")))))))
5919     (synopsis "Pattern-matching friendly implementation of quasiquote for Common Lisp")
5920     (description "The main purpose of this n+2nd reimplementation of
5921 quasiquote is enable matching of quasiquoted patterns, using Optima or
5922 Trivia.")
5923     (license license:expat)))
5924
5925 (define-public cl-fare-quasiquote
5926   (sbcl-package->cl-source-package sbcl-fare-quasiquote))
5927
5928 (define-public sbcl-fare-quasiquote-optima
5929   (package
5930     (inherit sbcl-fare-quasiquote)
5931     (name "sbcl-fare-quasiquote-optima")
5932     (inputs
5933      `(("optima" ,sbcl-optima)
5934        ("fare-quasiquote" ,sbcl-fare-quasiquote)))
5935     (arguments
5936      '(#:phases
5937        (modify-phases %standard-phases
5938          (add-after 'unpack 'patch-requirement
5939            (lambda _
5940              (substitute* "fare-quasiquote-optima.asd"
5941                (("\\(:version \"optima\" \"1\\.0\"\\)")
5942                 "\"optima\""))
5943              #t)))))))
5944
5945 (define-public cl-fare-quasiquote-optima
5946   (sbcl-package->cl-source-package sbcl-fare-quasiquote-optima))
5947
5948 (define-public sbcl-fare-quasiquote-readtable
5949   (package
5950     (inherit sbcl-fare-quasiquote)
5951     (name "sbcl-fare-quasiquote-readtable")
5952     (inputs
5953      `(("fare-quasiquote" ,sbcl-fare-quasiquote)
5954        ("named-readtables" ,sbcl-named-readtables)))
5955     (description "The main purpose of this n+2nd reimplementation of
5956 quasiquote is enable matching of quasiquoted patterns, using Optima or
5957 Trivia.
5958
5959 This package uses fare-quasiquote with named-readtable.")))
5960
5961 (define-public cl-fare-quasiquote-readtable
5962   (sbcl-package->cl-source-package sbcl-fare-quasiquote-readtable))
5963
5964 ;; TODO: Add support for component-less system in asdf-build-system/sbcl.
5965 (define-public cl-fare-quasiquote-extras
5966   (package
5967     (inherit cl-fare-quasiquote)
5968     (name "cl-fare-quasiquote-extras")
5969     (build-system asdf-build-system/source)
5970     (propagated-inputs
5971      `(("fare-quasiquote" ,cl-fare-quasiquote)
5972        ("fare-quasiquote-optima" ,cl-fare-quasiquote-optima)
5973        ("fare-quasiquote-readtable" ,cl-fare-quasiquote-readtable)))
5974     (description "This library combines @code{fare-quasiquote-readtable} and
5975 @code{fare-quasiquote-optima}.")))
5976
5977 (define-public sbcl-trivia.level0
5978   (let ((commit "902e0c65602bbfe96ae82e679330b3771ddc7603")
5979         (revision "1"))
5980     (package
5981       (name "sbcl-trivia.level0")
5982       (build-system asdf-build-system/sbcl)
5983       (version (git-version "0.0.0" revision commit))
5984       (home-page "https://github.com/guicho271828/trivia")
5985       (source
5986        (origin
5987          (method git-fetch)
5988          (uri (git-reference
5989                (url home-page)
5990                (commit commit)))
5991          (file-name (git-file-name name version))
5992          (sha256
5993           (base32
5994            "11qbab30qqnfy9mx3x9fvgcw1jbvh1qn2cqv3p8xdn2m8981jvhr"))))
5995       (inputs
5996        `(("alexandria" ,sbcl-alexandria)))
5997       (synopsis "Pattern matching in Common Lisp")
5998       (description "Trivia is a pattern matching compiler that is compatible
5999 with Optima, another pattern matching library for Common Lisp.  It is meant to
6000 be faster and more extensible than Optima.")
6001       (license license:llgpl))))
6002
6003 (define-public sbcl-trivia.level1
6004   (package
6005     (inherit sbcl-trivia.level0)
6006     (name "sbcl-trivia.level1")
6007     (inputs
6008      `(("trivia.level0" ,sbcl-trivia.level0)))
6009     (description "Trivia is a pattern matching compiler that is compatible
6010 with Optima, another pattern matching library for Common Lisp.  It is meant to
6011 be faster and more extensible than Optima.
6012
6013 This system contains the core patterns of Trivia.")))
6014
6015 (define-public sbcl-trivia.level2
6016   (package
6017     (inherit sbcl-trivia.level0)
6018     (name "sbcl-trivia.level2")
6019     (inputs
6020      `(("trivia.level1" ,sbcl-trivia.level1)
6021        ("lisp-namespace" ,sbcl-lisp-namespace)
6022        ("trivial-cltl2" ,sbcl-trivial-cltl2)
6023        ("closer-mop" ,sbcl-closer-mop)))
6024     (description "Trivia is a pattern matching compiler that is compatible
6025 with Optima, another pattern matching library for Common Lisp.  It is meant to
6026 be faster and more extensible than Optima.
6027
6028 This system contains a non-optimized pattern matcher compatible with Optima,
6029 with extensible optimizer interface.")))
6030
6031 (define-public sbcl-trivia.trivial
6032   (package
6033     (inherit sbcl-trivia.level0)
6034     (name "sbcl-trivia.trivial")
6035     (inputs
6036      `(("trivia.level2" ,sbcl-trivia.level2)))
6037     (arguments
6038      `(#:phases
6039        (modify-phases %standard-phases
6040          (replace 'create-asd-file
6041            (lambda* (#:key outputs inputs #:allow-other-keys)
6042              (let* ((out (assoc-ref outputs "out"))
6043                     (lib (string-append out "/lib/" (%lisp-type)))
6044                     (level2 (assoc-ref inputs "trivia.level2")))
6045                (mkdir-p lib)
6046                (install-file "trivia.trivial.asd" lib)
6047                ;; XXX: This .asd does not have any component and the build
6048                ;; system fails to work in this case.  We should update the
6049                ;; build system to handle component-less .asd.
6050                ;; TODO: How do we append to file in Guile?  It seems that
6051                ;; (open-file ... "a") gets a "Permission denied".
6052                (substitute* (string-append lib "/trivia.trivial.asd")
6053                  (("\"\\)")
6054                   (string-append "\")
6055
6056 (progn (asdf/source-registry:ensure-source-registry)
6057        (setf (gethash
6058                \"trivia.level2\"
6059                asdf/source-registry:*source-registry*)
6060              #p\""
6061                                  level2
6062                                  "/share/common-lisp/sbcl-bundle-systems/trivia.level2.asd\"))")))))))))
6063     (description "Trivia is a pattern matching compiler that is compatible
6064 with Optima, another pattern matching library for Common Lisp.  It is meant to
6065 be faster and more extensible than Optima.
6066
6067 This system contains the base level system of Trivia with a trivial optimizer.")))
6068
6069 (define-public sbcl-trivia.balland2006
6070   (package
6071     (inherit sbcl-trivia.level0)
6072     (name "sbcl-trivia.balland2006")
6073     (inputs
6074      `(("trivia.trivial" ,sbcl-trivia.trivial)
6075        ("iterate" ,sbcl-iterate)
6076        ("type-i" ,sbcl-type-i)
6077        ("alexandria" ,sbcl-alexandria)))
6078     (arguments
6079      ;; Tests are done in trivia itself.
6080      `(#:tests? #f))
6081     (description "Trivia is a pattern matching compiler that is compatible
6082 with Optima, another pattern matching library for Common Lisp.  It is meant to
6083 be faster and more extensible than Optima.
6084
6085 This system contains the base level system of Trivia with a trivial optimizer.")))
6086
6087 (define-public sbcl-trivia.ppcre
6088   (package
6089     (inherit sbcl-trivia.level0)
6090     (name "sbcl-trivia.ppcre")
6091     (inputs
6092      `(("trivia.trivial" ,sbcl-trivia.trivial)
6093        ("cl-ppcre" ,sbcl-cl-ppcre)))
6094     (description "Trivia is a pattern matching compiler that is compatible
6095 with Optima, another pattern matching library for Common Lisp.  It is meant to
6096 be faster and more extensible than Optima.
6097
6098 This system contains the PPCRE extension.")))
6099
6100 (define-public sbcl-trivia.quasiquote
6101   (package
6102     (inherit sbcl-trivia.level0)
6103     (name "sbcl-trivia.quasiquote")
6104     (inputs
6105      `(("trivia.trivial" ,sbcl-trivia.trivial)
6106        ("fare-quasiquote" ,sbcl-fare-quasiquote)
6107        ("fare-quasiquote-readtable" ,sbcl-fare-quasiquote-readtable)))
6108     (description "Trivia is a pattern matching compiler that is compatible
6109 with Optima, another pattern matching library for Common Lisp.  It is meant to
6110 be faster and more extensible than Optima.
6111
6112 This system contains the fare-quasiquote extension.")))
6113
6114 (define-public sbcl-trivia.cffi
6115   (package
6116     (inherit sbcl-trivia.level0)
6117     (name "sbcl-trivia.cffi")
6118     (inputs
6119      `(("cffi" ,sbcl-cffi)
6120        ("trivia.trivial" ,sbcl-trivia.trivial)))
6121     (description "Trivia is a pattern matching compiler that is compatible
6122 with Optima, another pattern matching library for Common Lisp.  It is meant to
6123 be faster and more extensible than Optima.
6124
6125 This system contains the CFFI foreign slot access extension.")))
6126
6127 (define-public sbcl-trivia
6128   (package
6129     (inherit sbcl-trivia.level0)
6130     (name "sbcl-trivia")
6131     (inputs
6132      `(("trivia.balland2006" ,sbcl-trivia.balland2006)))
6133     (native-inputs
6134      `(("fiveam" ,sbcl-fiveam)
6135        ("trivia.ppcre" ,sbcl-trivia.ppcre)
6136        ("trivia.quasiquote" ,sbcl-trivia.quasiquote)
6137        ("trivia.cffi" ,sbcl-trivia.cffi)
6138        ("optima" ,sbcl-optima)))
6139     (arguments
6140      `(#:test-asd-file "trivia.test.asd"
6141        #:phases
6142        (modify-phases %standard-phases
6143          (add-after 'create-asd 'remove-component
6144            ;; XXX: The original .asd has no components, but our build system
6145            ;; creates an entry nonetheless.  We need to remove it for the
6146            ;; generated .asd to load properly.  See trivia.trivial for a
6147            ;; similar problem.
6148            (lambda* (#:key outputs #:allow-other-keys)
6149              (let* ((out (assoc-ref outputs "out"))
6150                     (asd (string-append out "/lib/" (%lisp-type) "/trivia.asd")))
6151                (substitute* asd
6152                  (("  :components
6153 ")
6154                   ""))
6155                (substitute* asd
6156                  ((" *\\(\\(:compiled-file \"trivia--system\"\\)\\)")
6157                   ""))))))))
6158     (description "Trivia is a pattern matching compiler that is compatible
6159 with Optima, another pattern matching library for Common Lisp.  It is meant to
6160 be faster and more extensible than Optima.")))
6161
6162 (define-public cl-trivia
6163   (sbcl-package->cl-source-package sbcl-trivia))
6164
6165 (define-public sbcl-mk-string-metrics
6166   (package
6167     (name "sbcl-mk-string-metrics")
6168     (version "0.1.2")
6169     (home-page "https://github.com/cbaggers/mk-string-metrics/")
6170     (source (origin
6171               (method git-fetch)
6172               (uri (git-reference
6173                     (url home-page)
6174                     (commit version)))
6175               (sha256
6176                (base32 "0bg0bv2mfd4k0g3x72x563hvmrx18xavaffr6xk5rh4if5j7kcf6"))
6177               (file-name (git-file-name name version))))
6178     (build-system asdf-build-system/sbcl)
6179     (synopsis "Calculate various string metrics efficiently in Common Lisp")
6180     (description "This library implements efficient algorithms that calculate
6181 various string metrics in Common Lisp:
6182
6183 @itemize
6184 @item Damerau-Levenshtein distance
6185 @item Hamming distance
6186 @item Jaccard similarity coefficient
6187 @item Jaro distance
6188 @item Jaro-Winkler distance
6189 @item Levenshtein distance
6190 @item Normalized Damerau-Levenshtein distance
6191 @item Normalized Levenshtein distance
6192 @item Overlap coefficient
6193 @end itemize\n")
6194     (license license:x11)))
6195
6196 (define-public cl-mk-string-metrics
6197   (sbcl-package->cl-source-package sbcl-mk-string-metrics))
6198
6199 (define-public sbcl-cl-str
6200   (let ((commit "3d5ec86e3a0199e5973aacde951086dfd754b5e5"))
6201     (package
6202       (name "sbcl-cl-str")
6203       (version (git-version "0.8" "1" commit))
6204       (home-page "https://github.com/vindarel/cl-str")
6205       (source (origin
6206                 (method git-fetch)
6207                 (uri (git-reference
6208                       (url home-page)
6209                       (commit commit)))
6210                 (sha256
6211                  (base32 "0szzzbygw9h985yxz909vvqrp69pmpcpahn7hn350lnyjislk9ga"))
6212                 (file-name (git-file-name name version))))
6213       (build-system asdf-build-system/sbcl)
6214       (inputs
6215        `(("cl-ppcre" ,sbcl-cl-ppcre)
6216          ("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)))
6217       (native-inputs
6218        `(("prove" ,sbcl-prove)
6219          ("prove-asdf" ,sbcl-prove-asdf)))
6220       (arguments
6221        `(#:asd-file "str.asd"
6222          #:asd-system-name "str"
6223          #:test-asd-file "str.test.asd"))
6224       (synopsis "Modern, consistent and terse Common Lisp string manipulation library")
6225       (description "A modern and consistent Common Lisp string manipulation
6226 library that focuses on modernity, simplicity and discoverability:
6227 @code{(str:trim s)} instead of @code{(string-trim '(#\\Space ...) s)}), or
6228 @code{str:concat strings} instead of an unusual format construct; one
6229 discoverable library instead of many; consistency and composability, where
6230 @code{s} is always the last argument, which makes it easier to feed pipes and
6231 arrows.")
6232       (license license:expat))))
6233
6234 (define-public cl-str
6235   (sbcl-package->cl-source-package sbcl-cl-str))
6236
6237 (define-public sbcl-cl-xmlspam
6238   (let ((commit "ea06abcca2a73a9779bcfb09081e56665f94e22a"))
6239     (package
6240       (name "sbcl-cl-xmlspam")
6241       (build-system asdf-build-system/sbcl)
6242       (version (git-version "0.0.0" "1" commit))
6243       (home-page "https://github.com/rogpeppe/cl-xmlspam")
6244       (source
6245        (origin
6246          (method git-fetch)
6247          (uri (git-reference
6248                (url home-page)
6249                (commit commit)))
6250          (file-name (string-append name "-" version))
6251          (sha256
6252           (base32
6253            "0w4rqvrgdgk3fwfq3kx4r7wwdr2bv3b6n3bdqwsiriw9psqzpz2s"))))
6254       (inputs
6255        `(("cxml" ,sbcl-cxml)
6256          ("cl-ppcre" ,sbcl-cl-ppcre)))
6257       (synopsis "Concise, regexp-like pattern matching on streaming XML for Common Lisp")
6258       (description "CXML does an excellent job at parsing XML elements, but what
6259 do you do when you have a XML file that's larger than you want to fit in
6260 memory, and you want to extract some information from it?  Writing code to deal
6261 with SAX events, or even using Klacks, quickly becomes tedious.
6262 @code{cl-xmlspam} (for XML Stream PAttern Matcher) is designed to make it easy
6263 to write code that mirrors the structure of the XML that it's parsing.  It
6264 also makes it easy to shift paradigms when necessary - the usual Lisp control
6265 constructs can be used interchangeably with pattern matching, and the full
6266 power of CXML is available when necessary.")
6267       (license license:bsd-3))))
6268
6269 ;; TODO: dbus uses ASDF's package-inferred-system which is not supported by
6270 ;; asdf-build-system/sbcl as of 2019-08-02.  We should fix
6271 ;; asdf-build-system/sbcl.
6272 (define-public cl-dbus
6273   (let ((commit "24b452df3a45ca5dc95015500f34baad175c981a")
6274         (revision "1"))
6275     (package
6276       (name "cl-dbus")
6277       (build-system asdf-build-system/source)
6278       (version (git-version "20190408" revision commit))
6279       (home-page "https://github.com/death/dbus")
6280       (source
6281        (origin
6282          (method git-fetch)
6283          (uri (git-reference
6284                (url home-page)
6285                (commit commit)))
6286          (file-name (git-file-name name version))
6287          (sha256
6288           (base32
6289            "0fw2q866yddbf23nk9pxphm9gsasx35vjyss82xzvndnjmzlqfl5"))))
6290       ;; Inputs must be propagated or else packages depending on this won't have the necessary packages.
6291       (propagated-inputs
6292        `(("alexandria" ,sbcl-alexandria)
6293          ("trivial-garbage" ,sbcl-trivial-garbage)
6294          ("babel" ,sbcl-babel)
6295          ("iolib" ,sbcl-iolib)
6296          ("iolib+multiplex" ,(@@ (gnu packages lisp-xyz) sbcl-iolib+multiplex))
6297          ("iolib+syscalls" ,(@@ (gnu packages lisp-xyz) sbcl-iolib+syscalls))
6298          ("iolib+streams" ,(@@ (gnu packages lisp-xyz) sbcl-iolib+streams))
6299          ("iolib+sockets" ,(@@ (gnu packages lisp-xyz) sbcl-iolib+sockets))
6300          ("ieee-floats" ,sbcl-ieee-floats)
6301          ("flexi-streams" ,sbcl-flexi-streams)
6302          ("cl-xmlspam" ,sbcl-cl-xmlspam)
6303          ("ironclad" ,sbcl-ironclad)))
6304       (synopsis "D-Bus client library for Common Lisp")
6305       (description "This is a Common Lisp library that allows to publish D-Bus
6306 objects as well as send and notify other objects connected to a bus.")
6307       (license license:bsd-2))))
6308
6309 (define-public sbcl-cl-hooks
6310   (let ((commit "5b638083f3b4f1221a52631d9c8a0a265565cac7")
6311         (revision "1"))
6312     (package
6313       (name "sbcl-cl-hooks")
6314       (build-system asdf-build-system/sbcl)
6315       (version (git-version "0.2.1" revision commit))
6316       (home-page "https://github.com/scymtym/architecture.hooks")
6317       (source
6318        (origin
6319          (method git-fetch)
6320          (uri (git-reference
6321                (url home-page)
6322                (commit commit)))
6323          (file-name (git-file-name name version))
6324          (sha256
6325           (base32
6326            "0bg3l0a28lw5gqqjp6p6b5nhwqk46sgkb7184w5qbfngw1hk8x9y"))))
6327       (inputs
6328        `(("alexandria" ,sbcl-alexandria)
6329          ("let-plus" ,sbcl-let-plus)
6330          ("trivial-garbage" ,sbcl-trivial-garbage)
6331          ("closer-mop" ,sbcl-closer-mop)))
6332       (native-inputs
6333        `(("fiveam" ,sbcl-fiveam)))
6334       (synopsis "Hooks extension point mechanism (as in Emacs) for Common Lisp")
6335       (description "A hook, in the present context, is a certain kind of
6336 extension point in a program that allows interleaving the execution of
6337 arbitrary code with the execution of a the program without introducing any
6338 coupling between the two.  Hooks are used extensively in the extensible editor
6339 Emacs.
6340
6341 In the Common LISP Object System (CLOS), a similar kind of extensibility is
6342 possible using the flexible multi-method dispatch mechanism.  It may even seem
6343 that the concept of hooks does not provide any benefits over the possibilities
6344 of CLOS.  However, there are some differences:
6345
6346 @itemize
6347
6348 @item There can be only one method for each combination of specializers and
6349 qualifiers.  As a result this kind of extension point cannot be used by
6350 multiple extensions independently.
6351 @item Removing code previously attached via a @code{:before}, @code{:after} or
6352 @code{:around} method can be cumbersome.
6353 @item There could be other or even multiple extension points besides @code{:before}
6354 and @code{:after} in a single method.
6355 @item Attaching codes to individual objects using eql specializers can be
6356 cumbersome.
6357 @item Introspection of code attached a particular extension point is
6358 cumbersome since this requires enumerating and inspecting the methods of a
6359 generic function.
6360 @end itemize
6361
6362 This library tries to complement some of these weaknesses of method-based
6363 extension-points via the concept of hooks.")
6364       (license license:llgpl))))
6365
6366 (define-public cl-hooks
6367   (sbcl-package->cl-source-package sbcl-cl-hooks))
6368
6369 (define-public ecl-cl-hooks
6370   (sbcl-package->ecl-package sbcl-cl-hooks))
6371
6372 (define-public sbcl-s-sysdeps
6373   (let ((commit "d28246b5dffef9e73a0e0e6cfbc4e878006fe34d")
6374         (revision "1"))
6375     (package
6376       (name "sbcl-s-sysdeps")
6377       (build-system asdf-build-system/sbcl)
6378       (version (git-version "1" revision commit))
6379       (home-page "https://github.com/svenvc/s-sysdeps")
6380       (source
6381        (origin
6382          (method git-fetch)
6383          (uri (git-reference
6384                (url home-page)
6385                (commit commit)))
6386          (file-name (git-file-name name version))
6387          (sha256
6388           (base32
6389            "14b69b81yrxmjlvmm3lfxk04x5v7hqz4fql121334wh72czznfh9"))))
6390       (synopsis "Common Lisp abstraction layer over platform dependent functionality")
6391       (description "@code{s-sysdeps} is an abstraction layer over platform
6392 dependent functionality.  This simple package is used as a building block in a
6393 number of other open source projects.
6394
6395 @code{s-sysdeps} abstracts:
6396
6397 @itemize
6398 @item managing processes,
6399 @item implementing a standard TCP/IP server,
6400 @item opening a client TCP/IP socket stream,
6401 @item working with process locks.
6402 @end itemize\n")
6403       (license license:llgpl))))
6404
6405 (define-public cl-s-sysdeps
6406   (sbcl-package->cl-source-package sbcl-s-sysdeps))
6407
6408 (define-public ecl-s-sysdeps
6409   (sbcl-package->ecl-package sbcl-s-sysdeps))
6410
6411 (define-public sbcl-cl-prevalence
6412   (let ((commit "c163c227ed85d430b82cb1e3502f72d4f88e3cfa")
6413         (revision "1"))
6414     (package
6415       (name "sbcl-cl-prevalence")
6416       (build-system asdf-build-system/sbcl)
6417       (version (git-version "5" revision commit))
6418       (home-page "https://github.com/40ants/cl-prevalence")
6419       (source
6420        (origin
6421          (method git-fetch)
6422          (uri (git-reference
6423                (url home-page)
6424                (commit commit)))
6425          (file-name (git-file-name name version))
6426          (sha256
6427           (base32
6428            "1i9zj1q2ahgwch56an21yzbgkynz0kab9fyxkq9mg8p3xrv38jjn"))))
6429       (inputs
6430        `(("s-sysdeps" ,sbcl-s-sysdeps)
6431          ("s-xml" ,sbcl-s-xml)))
6432       (synopsis "Implementation of object prevalence for Common Lisp")
6433       (description "This Common Lisp library implements object prevalence (see
6434 @url{https://en.wikipedia.org/wiki/System_prevalence}).  It allows
6435 for (de)serializing to and from s-exps as well as XML.  Serialization of arbitrary
6436 classes and cyclic data structures are supported.")
6437       (license license:llgpl))))
6438
6439 (define-public cl-prevalence
6440   (sbcl-package->cl-source-package sbcl-cl-prevalence))
6441
6442 (define-public ecl-cl-prevalence
6443   (sbcl-package->ecl-package sbcl-cl-prevalence))
6444
6445 (define-public sbcl-series
6446   (let ((commit "da9061b336119d1e5214aff9117171d494d5a58a")
6447         (revision "1"))
6448     (package
6449       (name "sbcl-series")
6450       (version (git-version "2.2.11" revision commit))
6451       (source
6452        (origin
6453          (method git-fetch)
6454          (uri (git-reference
6455                (url "git://git.code.sf.net/p/series/series")
6456                (commit commit)))
6457          (file-name (git-file-name name version))
6458          (sha256
6459           (base32
6460            "07hk2lhfx42zk018pxqvn4gs77vd4n4g8m4xxbqaxgca76mifwfw"))))
6461       (build-system asdf-build-system/sbcl)
6462       (arguments
6463        ;; Disable the tests, they are apparently buggy and I didn't find
6464        ;; a simple way to make them run and pass.
6465        '(#:tests? #f))
6466       (synopsis "Series data structure for Common Lisp")
6467       (description
6468        "This Common Lisp library provides a series data structure much like
6469 a sequence, with similar kinds of operations.  The difference is that in many
6470 situations, operations on series may be composed functionally and yet execute
6471 iteratively, without the need to construct intermediate series values
6472 explicitly.  In this manner, series provide both the clarity of a functional
6473 programming style and the efficiency of an iterative programming style.")
6474       (home-page "http://series.sourceforge.net/")
6475       (license license:expat))))
6476
6477 (define-public cl-series
6478   (sbcl-package->cl-source-package sbcl-series))
6479
6480 (define-public ecl-series
6481   (sbcl-package->ecl-package sbcl-series))
6482
6483 (define-public sbcl-periods
6484   (let ((commit "983d4a57325db3c8def942f163133cec5391ec28")
6485         (revision "1"))
6486     (package
6487       (name "sbcl-periods")
6488       (version (git-version "0.0.2" revision commit))
6489       (source
6490        (origin
6491          (method git-fetch)
6492          (uri (git-reference
6493                (url "https://github.com/jwiegley/periods.git")
6494                (commit commit)))
6495          (file-name (git-file-name name version))
6496          (sha256
6497           (base32
6498            "0z30jr3lxz3cmi019fsl4lgcgwf0yqpn95v9zkkkwgymdrkd4lga"))))
6499       (build-system asdf-build-system/sbcl)
6500       (inputs
6501        `(("local-time" ,sbcl-local-time)))
6502       (synopsis "Common Lisp library for manipulating date/time objects")
6503       (description
6504        "Periods is a Common Lisp library providing a set of utilities for
6505 manipulating times, distances between times, and both contiguous and
6506 discontiguous ranges of time.")
6507       (home-page "https://github.com/jwiegley/periods")
6508       (license license:bsd-3))))
6509
6510 (define-public cl-periods
6511   (sbcl-package->cl-source-package sbcl-periods))
6512
6513 (define-public ecl-periods
6514   (sbcl-package->ecl-package sbcl-periods))
6515
6516 (define-public sbcl-periods-series
6517   (package
6518     (inherit sbcl-periods)
6519     (name "sbcl-periods-series")
6520     (inputs
6521      `(("periods" ,sbcl-periods)
6522        ("series" ,sbcl-series)))
6523     (arguments
6524      '(#:asd-file "periods-series.asd"
6525        #:asd-system-name "periods-series"))
6526     (description
6527      "Periods-series is an extension of the periods Common Lisp library
6528 providing functions compatible with the series Common Lisp library.")))
6529
6530 (define-public cl-periods-series
6531   (sbcl-package->cl-source-package sbcl-periods-series))
6532
6533 (define-public ecl-periods-series
6534   (sbcl-package->ecl-package sbcl-periods-series))
6535
6536 (define-public sbcl-metatilities-base
6537   (let ((commit "6eaa9e3ff0939a93a92109dd0fcd218de85417d5")
6538         (revision "1"))
6539     (package
6540       (name "sbcl-metatilities-base")
6541       (version (git-version "0.6.6" revision commit))
6542       (source
6543        (origin
6544          (method git-fetch)
6545          (uri (git-reference
6546                (url "https://github.com/gwkkwg/metatilities-base.git")
6547                (commit commit)))
6548          (file-name (git-file-name name version))
6549          (sha256
6550           (base32
6551            "0xpa86pdzlnf4v5g64j3ifaplx71sx2ha8b7vvakswi652679ma0"))))
6552       (build-system asdf-build-system/sbcl)
6553       (native-inputs
6554        `(("lift" ,sbcl-lift)))
6555       (synopsis "Core of the metatilities Common Lisp library")
6556       (description
6557        "Metatilities-base is the core of the metatilities Common Lisp library
6558 which implements a set of utilities.")
6559       (home-page "https://common-lisp.net/project/metatilities-base/")
6560       (license license:expat))))
6561
6562 (define-public cl-metatilities-base
6563   (sbcl-package->cl-source-package sbcl-metatilities-base))
6564
6565 (define-public ecl-metatilities-base
6566   (sbcl-package->ecl-package sbcl-metatilities-base))
6567
6568 (define-public sbcl-cl-containers
6569   (let ((commit "810927e19d933bcf38ffeb7a23ce521efc432d45")
6570         (revision "1"))
6571     (package
6572       (name "sbcl-cl-containers")
6573       (version (git-version "0.12.1" revision commit))
6574       (source
6575        (origin
6576          (method git-fetch)
6577          (uri (git-reference
6578                (url "https://github.com/gwkkwg/cl-containers.git")
6579                (commit commit)))
6580          (file-name (git-file-name name version))
6581          (sha256
6582           (base32
6583            "1s9faxw7svhbjpkhfrz2qxgjm3cvyjb8wpyb4m8dx4i5g7vvprkv"))))
6584       (build-system asdf-build-system/sbcl)
6585       (native-inputs
6586        `(("lift" ,sbcl-lift)))
6587       (inputs
6588        `(("metatilities-base" ,sbcl-metatilities-base)))
6589       (arguments
6590        '(#:phases
6591          (modify-phases %standard-phases
6592            (add-after 'unpack 'relax-version-checks
6593              (lambda _
6594                (substitute* "cl-containers.asd"
6595                  (("\\(:version \"metatilities-base\" \"0\\.6\\.6\"\\)")
6596                   "\"metatilities-base\""))
6597                (substitute* "cl-containers-test.asd"
6598                  (("\\(:version \"lift\" \"1\\.7\\.0\"\\)")
6599                   "\"lift\""))
6600                #t)))))
6601       (synopsis "Container library for Common Lisp")
6602       (description
6603        "Common Lisp ships with a set of powerful built in data structures
6604 including the venerable list, full featured arrays, and hash-tables.
6605 CL-containers enhances and builds on these structures by adding containers
6606 that are not available in native Lisp (for example: binary search trees,
6607 red-black trees, sparse arrays and so on), and by providing a standard
6608 interface so that they are simpler to use and so that changing design
6609 decisions becomes significantly easier.")
6610       (home-page "https://common-lisp.net/project/cl-containers/")
6611       (license license:expat))))
6612
6613 (define-public cl-containers
6614   (sbcl-package->cl-source-package sbcl-cl-containers))
6615
6616 (define-public ecl-cl-containers
6617   (sbcl-package->ecl-package sbcl-cl-containers))
6618
6619 (define-public sbcl-xlunit
6620   (let ((commit "3805d34b1d8dc77f7e0ee527a2490194292dd0fc")
6621         (revision "1"))
6622     (package
6623       (name "sbcl-xlunit")
6624       (version (git-version "0.6.3" revision commit))
6625       (source
6626        (origin
6627          (method git-fetch)
6628          (uri (git-reference
6629                (url "http://git.kpe.io/xlunit.git")
6630                (commit commit)))
6631          (file-name (git-file-name name version))
6632          (sha256
6633           (base32
6634            "0argfmp9nghs4sihyj3f8ch9qfib2b7ll07v5m9ziajgzsfl5xw3"))))
6635       (build-system asdf-build-system/sbcl)
6636       (arguments
6637        '(#:phases
6638          (modify-phases %standard-phases
6639            (add-after 'unpack 'fix-tests
6640              (lambda _
6641                (substitute* "xlunit.asd"
6642                  ((" :force t") ""))
6643                #t)))))
6644       (synopsis "Unit testing package for Common Lisp")
6645       (description
6646        "The XLUnit package is a toolkit for building test suites.  It is based
6647 on the XPTest package by Craig Brozensky and the JUnit package by Kent Beck.")
6648       (home-page "http://quickdocs.org/xlunit/")
6649       (license license:bsd-3))))
6650
6651 (define-public cl-xlunit
6652   (sbcl-package->cl-source-package sbcl-xlunit))
6653
6654 (define-public ecl-xlunit
6655   (sbcl-package->ecl-package sbcl-xlunit))
6656
6657 (define-public sbcl-fprog
6658   (let ((commit "7016d1a98215f82605d1c158e7a16504ca1f4636")
6659         (revision "1"))
6660     (package
6661       (name "sbcl-fprog")
6662       (version (git-version "1.0.0" revision commit))
6663       (source
6664        (origin
6665          (method git-fetch)
6666          (uri (git-reference
6667                (url "https://github.com/jwiegley/cambl.git")
6668                (commit commit)))
6669          (file-name (git-file-name name version))
6670          (sha256
6671           (base32
6672            "103mry04j2k9vznsxm7wcvccgxkil92cdrv52miwcmxl8daa4jiz"))))
6673       (build-system asdf-build-system/sbcl)
6674       (synopsis "Functional programming utilities for Common Lisp")
6675       (description
6676        "@code{fprog} is a Common Lisp library allowing iteration over
6677 immutable lists sharing identical sublists.")
6678       (home-page "https://github.com/jwiegley/cambl")
6679       (license license:bsd-3))))
6680
6681 (define-public cl-fprog
6682   (sbcl-package->cl-source-package sbcl-fprog))
6683
6684 (define-public ecl-fprog
6685   (sbcl-package->ecl-package sbcl-fprog))
6686
6687 (define-public sbcl-cambl
6688   (let ((commit "7016d1a98215f82605d1c158e7a16504ca1f4636")
6689         (revision "1"))
6690     (package
6691       (inherit sbcl-fprog)
6692       (name "sbcl-cambl")
6693       (version (git-version "4.0.0" revision commit))
6694       (native-inputs
6695        `(("xlunit" ,sbcl-xlunit)))
6696       (inputs
6697        `(("alexandria" ,sbcl-alexandria)
6698          ("cl-containers" ,sbcl-cl-containers)
6699          ("local-time" ,sbcl-local-time)
6700          ("periods" ,sbcl-periods)
6701          ("fprog" ,sbcl-fprog)))
6702       (synopsis "Commoditized amounts and balances for Common Lisp")
6703       (description
6704        "CAMBL is a Common Lisp library providing a convenient facility for
6705 working with commoditized values.  It does not allow compound units (and so is
6706 not suited for scientific operations) but does work rather nicely for the
6707 purpose of financial calculations."))))
6708
6709 (define-public cl-cambl
6710   (sbcl-package->cl-source-package sbcl-cambl))
6711
6712 (define-public ecl-cambl
6713   (sbcl-package->ecl-package sbcl-cambl))
6714
6715 (define-public sbcl-cl-ledger
6716   (let ((commit "08e0be41795e804cd36142e51756ad0b1caa377b")
6717         (revision "1"))
6718     (package
6719       (name "sbcl-cl-ledger")
6720       (version (git-version "4.0.0" revision commit))
6721       (source
6722        (origin
6723          (method git-fetch)
6724          (uri (git-reference
6725                (url "https://github.com/ledger/cl-ledger.git")
6726                (commit commit)))
6727          (file-name (git-file-name name version))
6728          (sha256
6729           (base32
6730            "1via0qf6wjcyxnfbmfxjvms0ik9j8rqbifgpmnhrzvkhrq9pv8h1"))))
6731       (build-system asdf-build-system/sbcl)
6732       (inputs
6733        `(("cambl" ,sbcl-cambl)
6734          ("cl-ppcre" ,sbcl-cl-ppcre)
6735          ("local-time" ,sbcl-local-time)
6736          ("periods-series" ,sbcl-periods-series)))
6737       (arguments
6738        '(#:phases
6739          (modify-phases %standard-phases
6740            (add-after 'unpack 'fix-system-definition
6741              (lambda _
6742                (substitute* "cl-ledger.asd"
6743                  (("  :build-operation program-op") "")
6744                  (("  :build-pathname \"cl-ledger\"") "")
6745                  (("  :entry-point \"ledger::main\"") ""))
6746                #t)))))
6747       (synopsis "Common Lisp port of the Ledger accounting system")
6748       (description
6749        "CL-Ledger is a Common Lisp port of the Ledger double-entry accounting
6750 system.")
6751       (home-page "https://github.com/ledger/cl-ledger")
6752       (license license:bsd-3))))
6753
6754 (define-public cl-ledger
6755   (sbcl-package->cl-source-package sbcl-cl-ledger))
6756
6757 (define-public ecl-cl-ledger
6758   (sbcl-package->ecl-package sbcl-cl-ledger))
6759
6760 (define-public sbcl-bst
6761   (let ((commit "34f9c7e8e0a9f2c952fe310ab36cb630d5d9c15a")
6762         (revision "1"))
6763     (package
6764       (name "sbcl-bst")
6765       (version (git-version "1.1" revision commit))
6766       (source
6767        (origin
6768          (method git-fetch)
6769          (uri (git-reference
6770                (url "https://github.com/glv2/bst.git")
6771                (commit commit)))
6772          (file-name (git-file-name name version))
6773          (sha256
6774           (base32
6775            "1amxns7hvvh4arwbh8ciwfzplg127vh37dnbamv1m1kmmnmihfc8"))))
6776       (build-system asdf-build-system/sbcl)
6777       (native-inputs
6778        `(("alexandria" ,sbcl-alexandria)
6779          ("fiveam" ,sbcl-fiveam)))
6780       (synopsis "Binary search tree for Common Lisp")
6781       (description
6782        "BST is a Common Lisp library for working with binary search trees that
6783 can contain any kind of values.")
6784       (home-page "https://github.com/glv2/bst")
6785       (license license:gpl3))))
6786
6787 (define-public cl-bst
6788   (sbcl-package->cl-source-package sbcl-bst))
6789
6790 (define-public ecl-bst
6791   (sbcl-package->ecl-package sbcl-bst))
6792
6793 (define-public sbcl-cl-octet-streams
6794   (package
6795     (name "sbcl-cl-octet-streams")
6796     (version "1.0")
6797     (source
6798      (origin
6799        (method git-fetch)
6800        (uri (git-reference
6801              (url "https://github.com/glv2/cl-octet-streams.git")
6802              (commit (string-append "v" version))))
6803        (file-name (git-file-name name version))
6804        (sha256
6805         (base32
6806          "1d7mn6ydv0j2x4r7clpc9ijjwrnfpxmvhifv8n5j7jh7s744sf8d"))))
6807     (build-system asdf-build-system/sbcl)
6808     (native-inputs
6809      `(("fiveam" ,sbcl-fiveam)))
6810     (inputs
6811      `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
6812     (synopsis "In-memory octet streams for Common Lisp")
6813     (description
6814      "CL-octet-streams is a library implementing in-memory octet
6815 streams for Common Lisp.  It was inspired by the trivial-octet-streams and
6816 cl-plumbing libraries.")
6817     (home-page "https://github.com/glv2/cl-octet-streams")
6818     (license license:gpl3+)))
6819
6820 (define-public cl-octet-streams
6821   (sbcl-package->cl-source-package sbcl-cl-octet-streams))
6822
6823 (define-public ecl-cl-octet-streams
6824   (sbcl-package->ecl-package sbcl-cl-octet-streams))
6825
6826 (define-public sbcl-lzlib
6827   (let ((commit "0de1db7129fef9a58a059d35a2fa2ecfc5b47b47")
6828         (revision "1"))
6829     (package
6830       (name "sbcl-lzlib")
6831       (version (git-version "1.0" revision commit))
6832       (source
6833        (origin
6834          (method git-fetch)
6835          (uri (git-reference
6836                (url "https://github.com/glv2/cl-lzlib.git")
6837                (commit commit)))
6838          (file-name (git-file-name name version))
6839          (sha256
6840           (base32
6841            "12ny7vj52fgnd8hb8fc8mry92vq4c1x72x2350191m4476j95clz"))))
6842       (build-system asdf-build-system/sbcl)
6843       (native-inputs
6844        `(("fiveam" ,sbcl-fiveam)))
6845       (inputs
6846        `(("cffi" ,sbcl-cffi)
6847          ("cl-octet-streams" ,sbcl-cl-octet-streams)
6848          ("lzlib" ,lzlib)))
6849       (arguments
6850        '(#:phases
6851          (modify-phases %standard-phases
6852            (add-after 'unpack 'fix-paths
6853              (lambda* (#:key inputs #:allow-other-keys)
6854                (substitute* "src/lzlib.lisp"
6855                  (("liblz\\.so")
6856                   (string-append (assoc-ref inputs "lzlib") "/lib/liblz.so")))
6857                #t)))))
6858       (synopsis "Common Lisp library for lzip (de)compression")
6859       (description
6860        "This Common Lisp library provides functions for lzip (LZMA)
6861 compression/decompression using bindings to the lzlib C library.")
6862       (home-page "https://github.com/glv2/cl-lzlib")
6863       (license license:gpl3+))))
6864
6865 (define-public cl-lzlib
6866   (sbcl-package->cl-source-package sbcl-lzlib))
6867
6868 (define-public ecl-lzlib
6869   (sbcl-package->ecl-package sbcl-lzlib))
6870
6871 (define-public sbcl-chanl
6872   (let ((commit "2362b57550c2c9238cc882d03553aaa1040b7340")
6873         (revision "0"))
6874     (package
6875       (name "sbcl-chanl")
6876       (version (git-version "0.4.1" revision commit))
6877       (source
6878        (origin
6879          (method git-fetch)
6880          (uri (git-reference
6881                (url "https://github.com/zkat/chanl.git")
6882                (commit commit)))
6883          (file-name (git-file-name name version))
6884          (sha256
6885           (base32
6886            "0ag3wz7yrqwp0s5069wwda98z3rrqd25spg8sa8rdqghj084w28w"))))
6887       (build-system asdf-build-system/sbcl)
6888       (native-inputs
6889        `(("fiveam" ,sbcl-fiveam)))
6890       (inputs
6891        `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
6892       (synopsis "Portable channel-based concurrency for Common Lisp")
6893       (description "Common Lisp library for channel-based concurrency.  In
6894 a nutshell, you create various threads sequentially executing tasks you need
6895 done, and use channel objects to communicate and synchronize the state of these
6896 threads.")
6897       (home-page "https://github.com/zkat/chanl")
6898       (license (list license:expat license:bsd-3)))))
6899
6900 (define-public cl-chanl
6901   (sbcl-package->cl-source-package sbcl-chanl))
6902
6903 (define-public ecl-chanl
6904   (let ((base (sbcl-package->ecl-package sbcl-chanl)))
6905     (package
6906       (inherit base)
6907       (arguments
6908        (substitute-keyword-arguments (package-arguments base)
6909          ;; The CHANL.ACTORS package uses the :ARGUMENTS option of
6910          ;; DEFINE-METHOD-COMBINATION, which is not implemented in ECL yet
6911          ;; (see https://gitlab.com/embeddable-common-lisp/ecl/issues/305).
6912          ;; So let's disable it for now, as it allows compiling the library
6913          ;; and using the rest of it.
6914          ((#:phases phases '%standard-phases)
6915           `(modify-phases ,phases
6916              (add-after 'unpack 'disable-chanl-actors
6917                (lambda _
6918                  (substitute* "chanl.asd"
6919                    (("\\(:file \"actors\"\\)") ""))
6920                  #t))))
6921          ;; Disable the tests for now, as the SEND-SEQUENCE test seems to
6922          ;; never end.
6923          ((#:tests? _ #f) #f))))))
6924
6925 (define-public sbcl-cl-store
6926   (let ((commit "c787337a16ea8cf8a06227f35933a4ec774746b3")
6927         (revision "1"))
6928     (package
6929       (name "sbcl-cl-store")
6930       (version (git-version "0.8.11" revision commit))
6931       (source
6932        (origin
6933          (method git-fetch)
6934          (uri (git-reference
6935                (url "https://github.com/skypher/cl-store.git")
6936                (commit commit)))
6937          (file-name (git-file-name name version))
6938          (sha256
6939           (base32
6940            "194srkg8nrym19c6i7zbnkzshc1qhqa82m53qnkirz9fw928bqxr"))))
6941       (build-system asdf-build-system/sbcl)
6942       (native-inputs
6943        `(("rt" ,sbcl-rt)))
6944       (synopsis "Common Lisp library to serialize data")
6945       (description
6946        "CL-STORE is a portable serialization package which should give you the
6947 ability to store all Common Lisp data types into streams.")
6948       (home-page "https://www.common-lisp.net/project/cl-store/")
6949       (license license:expat))))
6950
6951 (define-public cl-store
6952   (sbcl-package->cl-source-package sbcl-cl-store))
6953
6954 (define-public ecl-cl-store
6955   (sbcl-package->ecl-package sbcl-cl-store))
6956
6957 (define-public sbcl-cl-gobject-introspection
6958   (let ((commit "7b703e2384945ea0ac39d9b766de434a08d81560")
6959         (revision "0"))
6960     (package
6961       (name "sbcl-cl-gobject-introspection")
6962       (version (git-version "0.3" revision commit))
6963       (home-page "https://github.com/andy128k/cl-gobject-introspection")
6964       (source
6965        (origin
6966          (method git-fetch)
6967          (uri (git-reference
6968                (url home-page)
6969                (commit commit)))
6970          (file-name (git-file-name name version))
6971          (sha256
6972           (base32
6973            "1zcqd2qj14f6b38vys8gr89s6cijsp9r8j43xa8lynilwva7bwyh"))))
6974       (build-system asdf-build-system/sbcl)
6975       (inputs
6976        `(("alexandria" ,sbcl-alexandria)
6977          ("cffi" ,sbcl-cffi)
6978          ("iterate" ,sbcl-iterate)
6979          ("trivial-garbage" ,sbcl-trivial-garbage)
6980          ("glib" ,glib)
6981          ("gobject-introspection" ,gobject-introspection)))
6982       (native-inputs
6983        `(("fiveam" ,sbcl-fiveam)))
6984       (arguments
6985        ;; TODO: Tests fail, see
6986        ;; https://github.com/andy128k/cl-gobject-introspection/issues/70.
6987        '(#:tests? #f
6988          #:phases
6989          (modify-phases %standard-phases
6990            (add-after (quote unpack) (quote fix-paths)
6991              (lambda* (#:key inputs #:allow-other-keys)
6992                (substitute* "src/init.lisp"
6993                  (("libgobject-2\\.0\\.so")
6994                   (string-append (assoc-ref inputs "glib") "/lib/libgobject-2.0.so"))
6995                  (("libgirepository-1\\.0\\.so")
6996                   (string-append (assoc-ref inputs "gobject-introspection")
6997                                  "/lib/libgirepository-1.0.so")))
6998                #t)))))
6999       (synopsis "Common Lisp bindings to GObject Introspection")
7000       (description
7001        "This library is a bridge between Common Lisp and GObject
7002 Introspection, which enables Common Lisp programs to access the full interface
7003 of C+GObject libraries without the need of writing dedicated bindings.")
7004       (license (list license:bsd-3
7005                      ;; Tests are under a different license.
7006                      license:llgpl)))))
7007
7008 (define-public cl-gobject-introspection
7009   (sbcl-package->cl-source-package sbcl-cl-gobject-introspection))
7010
7011 (define-public sbcl-string-case
7012   (let ((commit "718c761e33749e297cd2809c7ba3ade1985c49f7")
7013         (revision "0"))
7014     (package
7015       (name "sbcl-string-case")
7016       (version (git-version "0.0.2" revision commit))
7017       (home-page "https://github.com/pkhuong/string-case")
7018       (source
7019        (origin
7020          (method git-fetch)
7021          (uri (git-reference
7022                (url home-page)
7023                (commit commit)))
7024          (file-name (git-file-name name version))
7025          (sha256
7026           (base32
7027            "1n5i3yh0h5s636rcnwn7jwqy3rjflikra04lymimhpcshhjsk0md"))))
7028       (build-system asdf-build-system/sbcl)
7029       (synopsis "Efficient string= case in Common Lisp")
7030       (description
7031        "@code{string-case} is a Common Lisp macro that generates specialised decision
7032 trees to dispatch on string equality.")
7033       (license license:bsd-3))))
7034
7035 (define-public cl-string-case
7036   (sbcl-package->cl-source-package sbcl-string-case))
7037
7038 (define-public ecl-string-case
7039   (sbcl-package->ecl-package sbcl-string-case))
7040
7041 (define-public sbcl-global-vars
7042   (let ((commit "c749f32c9b606a1457daa47d59630708ac0c266e")
7043         (revision "0"))
7044     (package
7045       (name "sbcl-global-vars")
7046       (version (git-version "1.0.0" revision commit))
7047       (home-page "https://github.com/lmj/global-vars")
7048       (source
7049        (origin
7050          (method git-fetch)
7051          (uri (git-reference
7052                (url home-page)
7053                (commit commit)))
7054          (file-name (git-file-name name version))
7055          (sha256
7056           (base32
7057            "06m3xc8l3pgsapl8fvsi9wf6y46zs75cp9zn7zh6dc65v4s5wz3d"))))
7058       (build-system asdf-build-system/sbcl)
7059       (synopsis "Efficient global variables in Common Lisp")
7060       (description
7061        "In Common Lisp, a special variable that is never dynamically bound
7062 typically serves as a stand-in for a global variable.  The @code{global-vars}
7063 library provides true global variables that are implemented by some compilers.
7064 An attempt to rebind a global variable properly results in a compiler error.
7065 That is, a global variable cannot be dynamically bound.
7066
7067 Global variables therefore allow us to communicate an intended usage that
7068 differs from special variables.  Global variables are also more efficient than
7069 special variables, especially in the presence of threads.")
7070       (license license:expat))))
7071
7072 (define-public cl-global-vars
7073   (sbcl-package->cl-source-package sbcl-global-vars))
7074
7075 (define-public ecl-global-vars
7076   (sbcl-package->ecl-package sbcl-global-vars))
7077
7078 (define-public sbcl-trivial-file-size
7079   (let ((commit "1c1d672a01a446ba0391dbb4ffc40be3b0476f23")
7080         (revision "0"))
7081     (package
7082       (name "sbcl-trivial-file-size")
7083       (version (git-version "0.0.0" revision commit))
7084       (home-page "https://github.com/ruricolist/trivial-file-size")
7085       (source
7086        (origin
7087          (method git-fetch)
7088          (uri (git-reference
7089                (url home-page)
7090                (commit commit)))
7091          (file-name (git-file-name name version))
7092          (sha256
7093           (base32
7094            "17pp86c9zs4y7i1sh7q9gbfw9iqv6655k7fz8qbj9ly1ypgxp4qs"))))
7095       (build-system asdf-build-system/sbcl)
7096       (native-inputs
7097        `(("fiveam" ,sbcl-fiveam)))
7098       (synopsis "Size of a file in bytes in Common Lisp")
7099       (description
7100        "The canonical way to determine the size of a file in bytes, using Common Lisp,
7101 is to open the file with an element type of (unsigned-byte 8) and then
7102 calculate the length of the stream.  This is less than ideal.  In most cases
7103 it is better to get the size of the file from its metadata, using a system
7104 call.
7105
7106 This library exports a single function, file-size-in-octets.  It returns the
7107 size of a file in bytes, using system calls when possible.")
7108       (license license:expat))))
7109
7110 (define-public cl-trivial-file-size
7111   (sbcl-package->cl-source-package sbcl-trivial-file-size))
7112
7113 (define-public ecl-trivial-file-size
7114   (sbcl-package->ecl-package sbcl-trivial-file-size))
7115
7116 (define-public sbcl-trivial-macroexpand-all
7117   (let ((commit "933270ac7107477de1bc92c1fd641fe646a7a8a9")
7118         (revision "0"))
7119     (package
7120       (name "sbcl-trivial-macroexpand-all")
7121       (version (git-version "0.0.0" revision commit))
7122       (home-page "https://github.com/cbaggers/trivial-macroexpand-all")
7123       (source
7124        (origin
7125          (method git-fetch)
7126          (uri (git-reference
7127                (url home-page)
7128                (commit commit)))
7129          (file-name (git-file-name name version))
7130          (sha256
7131           (base32
7132            "191hnn4b5j4i3crydmlzbm231kj0h7l8zj6mzj69r1npbzkas4bd"))))
7133       (build-system asdf-build-system/sbcl)
7134       (native-inputs
7135        `(("fiveam" ,sbcl-fiveam)))
7136       (synopsis "Portable macroexpand-all for Common Lisp")
7137       (description
7138        "This library provides a macroexpand-all function that calls the
7139 implementation specific equivalent.")
7140       (license license:unlicense))))
7141
7142 (define-public cl-trivial-macroexpand-all
7143   (sbcl-package->cl-source-package sbcl-trivial-macroexpand-all))
7144
7145 (define-public ecl-trivial-macroexpand-all
7146   (sbcl-package->ecl-package sbcl-trivial-macroexpand-all))
7147
7148 (define-public sbcl-serapeum
7149   (let ((commit "65837f8a0d65b36369ec8d000fff5c29a395b5fe")
7150         (revision "0"))
7151     (package
7152       (name "sbcl-serapeum")
7153       (version (git-version "0.0.0" revision commit))
7154       (home-page "https://github.com/ruricolist/serapeum")
7155       (source
7156        (origin
7157          (method git-fetch)
7158          (uri (git-reference
7159                (url home-page)
7160                (commit commit)))
7161          (file-name (git-file-name name version))
7162          (sha256
7163           (base32
7164            "0clwf81r2lvk1rbfvk91s9zmbkas9imf57ilqclw12mxaxlfsnbw"))))
7165       (build-system asdf-build-system/sbcl)
7166       (inputs
7167        `(("alexandria" ,sbcl-alexandria)
7168          ("trivia" ,sbcl-trivia)
7169          ("trivia.quasiquote" ,sbcl-trivia.quasiquote)
7170          ("split-sequence" ,sbcl-split-sequence)
7171          ("string-case" ,sbcl-string-case)
7172          ("parse-number" ,sbcl-parse-number)
7173          ("trivial-garbage" ,sbcl-trivial-garbage)
7174          ("bordeaux-threads" ,sbcl-bordeaux-threads)
7175          ("named-readtables" ,sbcl-named-readtables)
7176          ("fare-quasiquote-extras" ,cl-fare-quasiquote-extras)
7177          ("parse-declarations-1.0" ,sbcl-parse-declarations)
7178          ("global-vars" ,sbcl-global-vars)
7179          ("trivial-file-size" ,sbcl-trivial-file-size)
7180          ("trivial-macroexpand-all" ,sbcl-trivial-macroexpand-all)))
7181       (native-inputs
7182        `(("fiveam" ,sbcl-fiveam)
7183          ("local-time" ,sbcl-local-time)))
7184       (arguments
7185        '(#:phases
7186          (modify-phases %standard-phases
7187            (add-after 'unpack 'disable-failing-tests
7188              (lambda* (#:key inputs #:allow-other-keys)
7189                (substitute* "serapeum.asd"
7190                  ;; Guix does not have Quicklisp, and probably never will.
7191                  (("\\(:file \"quicklisp\"\\)") ""))
7192                #t)))))
7193       (synopsis "Common Lisp utility library beyond Alexandria")
7194       (description
7195        "Serapeum is a conservative library of Common Lisp utilities.  It is a
7196 supplement, not a competitor, to Alexandria.")
7197       (license license:expat))))
7198
7199 (define-public cl-serapeum
7200   (sbcl-package->cl-source-package sbcl-serapeum))
7201
7202 (define-public sbcl-arrows
7203   (let ((commit "df7cf0067e0132d9697ac8b1a4f1b9c88d4f5382")
7204         (revision "0"))
7205     (package
7206       (name "sbcl-arrows")
7207       (version (git-version "0.2.0" revision commit))
7208       (source
7209        (origin
7210          (method git-fetch)
7211          (uri (git-reference
7212                (url "https://gitlab.com/Harleqin/arrows.git")
7213                (commit commit)))
7214          (file-name (git-file-name name version))
7215          (sha256
7216           (base32
7217            "042k9vkssrqx9nhp14wdzm942zgdxvp35mba0p2syz98i75im2yy"))))
7218       (build-system asdf-build-system/sbcl)
7219       (native-inputs
7220        `(("hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
7221       (synopsis "Clojure-like arrow macros for Common Lisp")
7222       (description
7223        "This library implements the @code{->} and @code{->>} macros from
7224 Clojure, as well as several expansions on the idea.")
7225       (home-page "https://gitlab.com/Harleqin/arrows")
7226       (license license:public-domain))))
7227
7228 (define-public cl-arrows
7229   (sbcl-package->cl-source-package sbcl-arrows))
7230
7231 (define-public ecl-arrows
7232   (sbcl-package->ecl-package sbcl-arrows))
7233
7234 (define-public sbcl-simple-parallel-tasks
7235   (let ((commit "db460f7a3f7bbfe2d3a2223ed21e162068d04dda")
7236         (revision "0"))
7237     (package
7238       (name "sbcl-simple-parallel-tasks")
7239       (version (git-version "1.0" revision commit))
7240       (source
7241        (origin
7242          (method git-fetch)
7243          (uri (git-reference
7244                (url "https://github.com/glv2/simple-parallel-tasks.git")
7245                (commit commit)))
7246          (file-name (git-file-name name version))
7247          (sha256
7248           (base32
7249            "0amw3qk23wnlyrsgzszs6rs7y4zvxv8dr03rnqhc60mnm8ds4dd5"))))
7250       (build-system asdf-build-system/sbcl)
7251       (native-inputs
7252        `(("fiveam" ,sbcl-fiveam)))
7253       (inputs
7254        `(("chanl" ,sbcl-chanl)))
7255       (synopsis "Common Lisp library to evaluate some forms in parallel")
7256       (description "This is a simple Common Lisp library to evaluate some
7257 forms in parallel.")
7258       (home-page "https://github.com/glv2/simple-parallel-tasks")
7259       (license license:gpl3))))
7260
7261 (define-public cl-simple-parallel-tasks
7262   (sbcl-package->cl-source-package sbcl-simple-parallel-tasks))
7263
7264 (define-public ecl-simple-parallel-tasks
7265   (sbcl-package->ecl-package sbcl-simple-parallel-tasks))
7266
7267 (define-public sbcl-cl-heap
7268   (package
7269     (name "sbcl-cl-heap")
7270     (version "0.1.6")
7271     (source
7272      (origin
7273        (method url-fetch)
7274        (uri (string-append "https://common-lisp.net/project/cl-heap/releases/"
7275                            "cl-heap_" version ".tar.gz"))
7276        (sha256
7277         (base32
7278          "163hb07p2nxz126rpq3cj5dyala24n0by5i5786n2qcr1w0bak4i"))))
7279     (build-system asdf-build-system/sbcl)
7280     (native-inputs
7281      `(("xlunit" ,sbcl-xlunit)))
7282     (arguments
7283      `(#:test-asd-file "cl-heap-tests.asd"))
7284     (synopsis "Heap and priority queue data structures for Common Lisp")
7285     (description
7286      "CL-HEAP provides various implementations of heap data structures (a
7287 binary heap and a Fibonacci heap) as well as an efficient priority queue.")
7288     (home-page "https://common-lisp.net/project/cl-heap/")
7289     (license license:gpl3+)))
7290
7291 (define-public cl-heap
7292   (sbcl-package->cl-source-package sbcl-cl-heap))
7293
7294 (define-public ecl-cl-heap
7295   (sbcl-package->ecl-package sbcl-cl-heap))
7296
7297 (define-public sbcl-curry-compose-reader-macros
7298   (let ((commit "beaa92dedf392726c042184bfd6149fa8d9e6ac2")
7299         (revision "0"))
7300     (package
7301       (name "sbcl-curry-compose-reader-macros")
7302       (version (git-version "1.0.0" revision commit))
7303       (source
7304        (origin
7305          (method git-fetch)
7306          (uri
7307           (git-reference
7308            (url "https://github.com/eschulte/curry-compose-reader-macros.git")
7309            (commit commit)))
7310          (file-name (git-file-name name version))
7311          (sha256
7312           (base32
7313            "0rv9bl8xrad5wfcg5zs1dazvnpmvqz6297lbn8bywsrcfnlf7h98"))))
7314       (build-system asdf-build-system/sbcl)
7315       (inputs
7316        `(("alexandria" ,sbcl-alexandria)
7317          ("named-readtables" ,sbcl-named-readtables)))
7318       (synopsis "Reader macros for partial application and composition")
7319       (description
7320        "This Common Lisp library provides reader macros for concise expression
7321 of function partial application and composition.")
7322       (home-page "https://eschulte.github.io/curry-compose-reader-macros/")
7323       (license license:public-domain))))
7324
7325 (define-public cl-curry-compose-reader-macros
7326   (sbcl-package->cl-source-package sbcl-curry-compose-reader-macros))
7327
7328 (define-public ecl-curry-compose-reader-macros
7329   (sbcl-package->ecl-package sbcl-curry-compose-reader-macros))
7330
7331 (define-public sbcl-yason
7332   (package
7333     (name "sbcl-yason")
7334     (version "0.7.7")
7335     (source
7336      (origin
7337        (method git-fetch)
7338        (uri (git-reference
7339              (url "https://github.com/phmarek/yason.git")
7340              (commit (string-append "v" version))))
7341        (file-name (git-file-name name version))
7342        (sha256
7343         (base32
7344          "0479rbjgbj80jpk5bby18inlv1kfp771a82rlcq5psrz65qqa9bj"))))
7345     (build-system asdf-build-system/sbcl)
7346     (inputs
7347      `(("alexandria" ,sbcl-alexandria)
7348        ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
7349     (synopsis "Common Lisp JSON parser/encoder")
7350     (description
7351      "YASON is a Common Lisp library for encoding and decoding data in the
7352 JSON interchange format.")
7353     (home-page "https://github.com/phmarek/yason")
7354     (license license:bsd-3)))
7355
7356 (define-public cl-yason
7357   (sbcl-package->cl-source-package sbcl-yason))
7358
7359 (define-public ecl-yason
7360   (sbcl-package->ecl-package sbcl-yason))
7361
7362 (define-public sbcl-stefil
7363   (let ((commit "0398548ec95dceb50fc2c2c03e5fb0ce49b86c7a")
7364         (revision "0"))
7365     (package
7366       (name "sbcl-stefil")
7367       (version (git-version "0.1" revision commit))
7368       (source
7369        (origin
7370          (method git-fetch)
7371          (uri (git-reference
7372                (url "https://gitlab.common-lisp.net/stefil/stefil.git")
7373                (commit commit)))
7374          (file-name (git-file-name name version))
7375          (sha256
7376           (base32
7377            "0bqz64q2szzhf91zyqyssmvrz7da6442rs01808pf3wrdq28bclh"))))
7378       (build-system asdf-build-system/sbcl)
7379       (inputs
7380        `(("alexandria" ,sbcl-alexandria)
7381          ("iterate" ,sbcl-iterate)
7382          ("metabang-bind" ,sbcl-metabang-bind)))
7383       (propagated-inputs
7384        ;; Swank doesn't have a pre-compiled package, therefore we must
7385        ;; propagate its sources.
7386        `(("swank" ,cl-slime-swank)))
7387       (arguments
7388        '(#:phases
7389          (modify-phases %standard-phases
7390            (add-after 'unpack 'drop-unnecessary-dependency
7391              (lambda _
7392                (substitute* "package.lisp"
7393                  ((":stefil-system") ""))
7394                #t)))))
7395       (home-page "https://common-lisp.net/project/stefil/index-old.shtml")
7396       (synopsis "Simple test framework")
7397       (description
7398        "Stefil is a simple test framework for Common Lisp, with a focus on
7399 interactive development.")
7400       (license license:public-domain))))
7401
7402 (define-public cl-stefil
7403   (sbcl-package->cl-source-package sbcl-stefil))
7404
7405 (define-public sbcl-graph
7406   (let ((commit "78bf9ec930d8eae4f0861b5be76765fb1e45e24f")
7407         (revision "0"))
7408     (package
7409       (name "sbcl-graph")
7410       (version (git-version "0.0.0" revision commit))
7411       (source
7412        (origin
7413          (method git-fetch)
7414          (uri
7415           (git-reference
7416            (url "https://github.com/eschulte/graph.git")
7417            (commit commit)))
7418          (file-name (git-file-name name version))
7419          (sha256
7420           (base32
7421            "1qpij4xh8bqwc2myahpilcbh916v7vg0acz2fij14d3y0jm02h0g"))
7422          (patches (search-patches "sbcl-graph-asdf-definitions.patch"))))
7423       (build-system asdf-build-system/sbcl)
7424       (native-inputs
7425        `(("stefil" ,sbcl-stefil)))
7426       (inputs
7427        `(("alexandria" ,sbcl-alexandria)
7428          ("cl-heap" ,sbcl-cl-heap)
7429          ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
7430          ("metabang-bind" ,sbcl-metabang-bind)
7431          ("named-readtables" ,sbcl-named-readtables)))
7432       (arguments
7433        '(#:test-asd-file "graph-test.asd"))
7434       (synopsis "Graph data structure and algorithms for Common Lisp")
7435       (description
7436        "The GRAPH Common Lisp library provides a data structures to represent
7437 graphs, as well as some graph manipulation and analysis algorithms (shortest
7438 path, maximum flow, minimum spanning tree, etc.).")
7439       (home-page "https://eschulte.github.io/graph/")
7440       (license license:gpl3+))))
7441
7442 (define-public cl-graph
7443   (sbcl-package->cl-source-package sbcl-graph))
7444
7445 (define-public sbcl-graph-dot
7446   (package
7447     (inherit sbcl-graph)
7448     (name "sbcl-graph-dot")
7449     (inputs
7450      `(("alexandria" ,sbcl-alexandria)
7451        ("cl-ppcre" ,sbcl-cl-ppcre)
7452        ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
7453        ("graph" ,sbcl-graph)
7454        ("metabang-bind" ,sbcl-metabang-bind)
7455        ("named-readtables" ,sbcl-named-readtables)))
7456     (arguments
7457      (substitute-keyword-arguments (package-arguments sbcl-graph)
7458        ((#:asd-file _ "") "graph-dot.asd")
7459        ((#:asd-system-name _ #f) "graph-dot")))
7460     (synopsis "Serialize graphs to and from DOT format")))
7461
7462 (define-public sbcl-graph-json
7463   (package
7464     (inherit sbcl-graph)
7465     (name "sbcl-graph-json")
7466     (inputs
7467      `(("alexandria" ,sbcl-alexandria)
7468        ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
7469        ("graph" ,sbcl-graph)
7470        ("metabang-bind" ,sbcl-metabang-bind)
7471        ("named-readtables" ,sbcl-named-readtables)
7472        ("yason" ,sbcl-yason)))
7473     (arguments
7474      (substitute-keyword-arguments (package-arguments sbcl-graph)
7475        ((#:asd-file _ "") "graph-json.asd")
7476        ((#:asd-system-name _ #f) "graph-json")))
7477     (synopsis "Serialize graphs to and from JSON format")))
7478
7479 (define-public sbcl-trivial-indent
7480   (let ((commit "2d016941751647c6cc5bd471751c2cf68861c94a")
7481         (revision "0"))
7482     (package
7483       (name "sbcl-trivial-indent")
7484       (version (git-version "1.0.0" revision commit))
7485       (source
7486        (origin
7487          (method git-fetch)
7488          (uri
7489           (git-reference
7490            (url "https://github.com/Shinmera/trivial-indent")
7491            (commit commit)))
7492          (file-name (git-file-name name version))
7493          (sha256
7494           (base32
7495            "1sj90nqz17w4jq0ixz00gb9g5g6d2s7l8r17zdby27gxxh51w266"))))
7496       (build-system asdf-build-system/sbcl)
7497       (synopsis "Simple Common Lisp library to allow indentation hints for SWANK")
7498       (description
7499        "This library allows you to define custom indentation hints for your
7500 macros if the one recognised by SLIME automatically produces unwanted
7501 results.")
7502       (home-page "https://shinmera.github.io/trivial-indent/")
7503       (license license:zlib))))
7504
7505 (define-public cl-trivial-indent
7506   (sbcl-package->cl-source-package sbcl-trivial-indent))
7507
7508 (define-public sbcl-documentation-utils
7509   (let ((commit "98630dd5f7e36ae057fa09da3523f42ccb5d1f55")
7510         (revision "0"))
7511     (package
7512       (name "sbcl-documentation-utils")
7513       (version (git-version "1.2.0" revision commit))
7514       (source
7515        (origin
7516          (method git-fetch)
7517          (uri
7518           (git-reference
7519            (url "https://github.com/Shinmera/documentation-utils.git")
7520            (commit commit)))
7521          (file-name (git-file-name name version))
7522          (sha256
7523           (base32
7524            "098qhkqskmmrh4wix34mawf7p5c87yql28r51r75yjxj577k5idq"))))
7525       (build-system asdf-build-system/sbcl)
7526       (inputs
7527        `(("trivial-indent" ,sbcl-trivial-indent)))
7528       (synopsis "Few simple tools to document Common Lisp libraries")
7529       (description
7530        "This is a small library to help you with managing the Common Lisp
7531 docstrings for your library.")
7532       (home-page "https://shinmera.github.io/documentation-utils/")
7533       (license license:zlib))))
7534
7535 (define-public cl-documentation-utils
7536   (sbcl-package->cl-source-package sbcl-documentation-utils))
7537
7538 (define-public sbcl-form-fiddle
7539   (let ((commit "e0c23599dbb8cff3e83e012f3d86d0764188ad18")
7540         (revision "0"))
7541     (package
7542       (name "sbcl-form-fiddle")
7543       (version (git-version "1.1.0" revision commit))
7544       (source
7545        (origin
7546          (method git-fetch)
7547          (uri
7548           (git-reference
7549            (url "https://github.com/Shinmera/form-fiddle")
7550            (commit commit)))
7551          (file-name (git-file-name name version))
7552          (sha256
7553           (base32
7554            "041iznc9mpfyrl0sv5893ys9pbb2pvbn9g3clarqi7gsfj483jln"))))
7555       (build-system asdf-build-system/sbcl)
7556       (inputs
7557        `(("documentation-utils" ,sbcl-documentation-utils)))
7558       (synopsis "Utilities to destructure Common Lisp lambda forms")
7559       (description
7560        "Often times we need to destructure a form definition in a Common Lisp
7561 macro.  This library provides a set of simple utilities to help with that.")
7562       (home-page "https://shinmera.github.io/form-fiddle/")
7563       (license license:zlib))))
7564
7565 (define-public cl-form-fiddle
7566   (sbcl-package->cl-source-package sbcl-form-fiddle))
7567
7568 (define-public sbcl-parachute
7569   (let ((commit "ca04dd8e43010a6dfffa26dbe1d62af86008d666")
7570         (revision "0"))
7571     (package
7572       (name "sbcl-parachute")
7573       (version (git-version "1.1.1" revision commit))
7574       (source
7575        (origin
7576          (method git-fetch)
7577          (uri
7578           (git-reference
7579            (url "https://github.com/Shinmera/parachute")
7580            (commit commit)))
7581          (file-name (git-file-name name version))
7582          (sha256
7583           (base32
7584            "1mvsm3r0r6a2bg75nw0q7n9vlby3ch45qjl7hnb5k1z2n5x5lh60"))))
7585       (build-system asdf-build-system/sbcl)
7586       (inputs
7587        `(("documentation-utils" ,sbcl-documentation-utils)
7588          ("form-fiddle" ,sbcl-form-fiddle)))
7589       (synopsis "Extensible and cross-compatible testing framework for Common Lisp")
7590       (description
7591        "Parachute is a simple-to-use and extensible testing framework.
7592 In Parachute, things are organised as a bunch of named tests within a package.
7593 Each test can contain a bunch of test forms that make up its body.")
7594       (home-page "https://shinmera.github.io/parachute/")
7595       (license license:zlib))))
7596
7597 (define-public cl-parachute
7598   (sbcl-package->cl-source-package sbcl-parachute))
7599
7600 (define-public sbcl-array-utils
7601   (let ((commit "f90eb9070d0b2205af51126a35033574725e5c56")
7602         (revision "0"))
7603     (package
7604       (name "sbcl-array-utils")
7605       (version (git-version "1.1.1" revision commit))
7606       (source
7607        (origin
7608          (method git-fetch)
7609          (uri
7610           (git-reference
7611            (url "https://github.com/Shinmera/array-utils")
7612            (commit commit)))
7613          (file-name (git-file-name name version))
7614          (sha256
7615           (base32
7616            "0zhwfbpr53vs1ii4sx75dz2k9yhh1xpwdqqpg8nmfndxkmhpbi3x"))))
7617       (build-system asdf-build-system/sbcl)
7618       (native-inputs
7619        `(("parachute" ,sbcl-parachute)))
7620       (inputs
7621        `(("documentation-utils" ,sbcl-documentation-utils)))
7622       (synopsis "Tiny collection of array and vector utilities for Common Lisp")
7623       (description
7624        "A miniature toolkit that contains some useful shifting/popping/pushing
7625 functions for arrays and vectors.  Originally from Plump.")
7626       (home-page "https://shinmera.github.io/array-utils/")
7627       (license license:zlib))))
7628
7629 (define-public cl-array-utils
7630   (sbcl-package->cl-source-package sbcl-array-utils))
7631
7632 (define-public sbcl-plump
7633   (let ((commit "16f1231bf706cfbc54d9e55a853ca945e4452a08")
7634         (revision "0"))
7635     (package
7636       (name "sbcl-plump")
7637       (version (git-version "2.0.0" revision commit))
7638       (source
7639        (origin
7640          (method git-fetch)
7641          (uri
7642           (git-reference
7643            (url "https://github.com/Shinmera/plump")
7644            (commit commit)))
7645          (file-name (git-file-name name version))
7646          (sha256
7647           (base32
7648            "0705k8pbip51v74rccgwscwph439f2pma9f915qf1h4bhjx999ip"))))
7649       (build-system asdf-build-system/sbcl)
7650       (inputs
7651        `(("array-utils" ,sbcl-array-utils)
7652          ("documentation-utils" ,sbcl-documentation-utils)))
7653       (synopsis "Lenient XML / XHTML / HTML parser for Common Lisp")
7654       (description
7655        "Plump is a parser for HTML/XML-like documents, focusing on being
7656 lenient towards invalid markup.  It can handle things like invalid attributes,
7657 bad closing tag order, unencoded entities, inexistent tag types, self-closing
7658 tags and so on.  It parses documents to a class representation and offers a
7659 small set of DOM functions to manipulate it.  It can be extended to parse to
7660 your own classes.")
7661       (home-page "https://shinmera.github.io/plump/")
7662       (license license:zlib))))
7663
7664 (define-public cl-plump
7665   (sbcl-package->cl-source-package sbcl-plump))
7666
7667 (define-public sbcl-antik-base
7668   (let ((commit "e4711a69b3d6bf37b5727af05c3cfd03e8428ba3")
7669         (revision "1"))
7670     (package
7671       (name "sbcl-antik-base")
7672       (version (git-version "0.0.0" revision commit))
7673       (source
7674        (origin
7675          (method git-fetch)
7676          (uri (git-reference
7677                (url "https://gitlab.common-lisp.net/antik/antik.git")
7678                (commit commit)))
7679          (file-name (git-file-name name version))
7680          (sha256
7681           (base32
7682            "047ga2c38par2xbgg4qx6hwv06qhf1c1f67as8xvir6s80lip1km"))))
7683       (build-system asdf-build-system/sbcl)
7684       (inputs
7685        `(("alexandria" ,sbcl-alexandria)
7686          ("cl-ppcre" ,sbcl-cl-ppcre)
7687          ("iterate" ,sbcl-iterate)
7688          ("metabang-bind" ,sbcl-metabang-bind)
7689          ("named-readtables" ,sbcl-named-readtables)
7690          ("split-sequence" ,sbcl-split-sequence)))
7691       (native-inputs
7692        `(("lisp-unit" ,sbcl-lisp-unit)))
7693       (synopsis "Scientific and engineering computation in Common Lisp")
7694       (description
7695        "Antik provides a foundation for scientific and engineering
7696 computation in Common Lisp.  It is designed not only to facilitate
7697 numerical computations, but to permit the use of numerical computation
7698 libraries and the interchange of data and procedures, whether
7699 foreign (non-Lisp) or Lisp libraries.  It is named after the
7700 Antikythera mechanism, one of the oldest examples of a scientific
7701 computer known.")
7702       (home-page "https://common-lisp.net/project/antik/")
7703       (license license:gpl3))))
7704
7705 (define-public cl-antik-base
7706   (sbcl-package->cl-source-package sbcl-antik-base))
7707
7708 (define-public ecl-antik-base
7709   (sbcl-package->ecl-package sbcl-antik-base))
7710
7711 (define-public sbcl-foreign-array
7712   (package
7713     (inherit sbcl-antik-base)
7714     (name "sbcl-foreign-array")
7715     (arguments
7716      (substitute-keyword-arguments (package-arguments sbcl-antik-base)
7717        ((#:asd-file _ "") "foreign-array.asd")
7718        ((#:asd-system-name _ #f) "foreign-array")))
7719     (inputs
7720      `(("antik-base" ,sbcl-antik-base)
7721        ("cffi" ,sbcl-cffi)
7722        ("trivial-garbage" ,sbcl-trivial-garbage)
7723        ("static-vectors" ,sbcl-static-vectors)))
7724     (synopsis "Common Lisp library providing access to foreign arrays")))
7725
7726 (define-public cl-foreign-array
7727   (sbcl-package->cl-source-package sbcl-foreign-array))
7728
7729 (define-public ecl-foreign-array
7730   (sbcl-package->ecl-package sbcl-foreign-array))
7731
7732 (define-public sbcl-physical-dimension
7733   (package
7734     (inherit sbcl-antik-base)
7735     (name "sbcl-physical-dimension")
7736     (inputs
7737      `(("fare-utils" ,sbcl-fare-utils)
7738        ("foreign-array" ,sbcl-foreign-array)
7739        ("trivial-utf-8" ,sbcl-trivial-utf-8)))
7740     (arguments
7741      (substitute-keyword-arguments (package-arguments sbcl-antik-base)
7742        ((#:asd-file _ "") "physical-dimension.asd")
7743        ((#:asd-system-name _ #f) "physical-dimension")))
7744     (synopsis
7745      "Common Lisp library providing computations with physical units")))
7746
7747 (define-public cl-physical-dimension
7748   (sbcl-package->cl-source-package sbcl-physical-dimension))
7749
7750 (define-public sbcl-science-data
7751   (package
7752     (inherit sbcl-antik-base)
7753     (name "sbcl-science-data")
7754     (inputs
7755      `(("physical-dimension" ,sbcl-physical-dimension)
7756        ("drakma" ,sbcl-drakma)))
7757     (arguments
7758      (substitute-keyword-arguments (package-arguments sbcl-antik-base)
7759        ((#:asd-file _ "") "science-data.asd")
7760        ((#:asd-system-name _ #f) "science-data")))
7761     (synopsis
7762      "Common Lisp library for scientific and engineering numerical data")))
7763
7764 (define-public cl-science-data
7765   (sbcl-package->cl-source-package sbcl-science-data))
7766
7767 (define-public sbcl-gsll
7768   (let ((commit "1a8ada22f9cf5ed7372d352b2317f4ccdb6ab308")
7769         (revision "1"))
7770     (package
7771       (name "sbcl-gsll")
7772       (version (git-version "0.0.0" revision commit))
7773       (source
7774        (origin
7775          (method git-fetch)
7776          (uri (git-reference
7777                (url "https://gitlab.common-lisp.net/antik/gsll.git")
7778                (commit commit)))
7779          (file-name (git-file-name name version))
7780          (sha256
7781           (base32
7782            "0z5nypfk26hxihb08p085644afawicrgb4xvadh3lmrn46qbjfn4"))))
7783       (build-system asdf-build-system/sbcl)
7784       (native-inputs
7785        `(("lisp-unit" ,sbcl-lisp-unit)))
7786       (inputs
7787        `(("alexandria" ,sbcl-alexandria)
7788          ("cffi-grovel" ,sbcl-cffi-grovel)
7789          ("cffi-libffi" ,sbcl-cffi-libffi)
7790          ("foreign-array" ,sbcl-foreign-array)
7791          ("gsl" ,gsl)
7792          ("metabang-bind" ,sbcl-metabang-bind)
7793          ("trivial-features" ,sbcl-trivial-features)
7794          ("trivial-garbage" ,sbcl-trivial-garbage)))
7795       (arguments
7796        `(#:tests? #f
7797          #:phases
7798          (modify-phases %standard-phases
7799            (add-after 'unpack 'fix-cffi-paths
7800              (lambda* (#:key inputs #:allow-other-keys)
7801                (substitute* "gsll.asd"
7802                  ((":depends-on \\(#:foreign-array")
7803                   ":depends-on (#:foreign-array #:cffi-libffi"))
7804                (substitute* "init/init.lisp"
7805                  (("libgslcblas.so" all)
7806                   (string-append
7807                    (assoc-ref inputs "gsl") "/lib/" all)))
7808                (substitute* "init/init.lisp"
7809                  (("libgsl.so" all)
7810                   (string-append
7811                    (assoc-ref inputs "gsl") "/lib/" all))))))))
7812       (synopsis "GNU Scientific Library for Lisp")
7813       (description
7814        "The GNU Scientific Library for Lisp (GSLL) allows the use of the
7815 GNU Scientific Library (GSL) from Common Lisp.  This library provides a
7816 full range of common mathematical operations useful to scientific and
7817 engineering applications.  The design of the GSLL interface is such
7818 that access to most of the GSL library is possible in a Lisp-natural
7819 way; the intent is that the user not be hampered by the restrictions
7820 of the C language in which GSL has been written.  GSLL thus provides
7821 interactive use of GSL for getting quick answers, even for someone not
7822 intending to program in Lisp.")
7823       (home-page "https://common-lisp.net/project/gsll/")
7824       (license license:gpl3))))
7825
7826 (define-public cl-gsll
7827   (sbcl-package->cl-source-package sbcl-gsll))
7828
7829 (define-public sbcl-antik
7830   (package
7831     (inherit sbcl-antik-base)
7832     (name "sbcl-antik")
7833     (inputs
7834      `(("gsll" ,sbcl-gsll)
7835        ("physical-dimension" ,sbcl-physical-dimension)))
7836     (arguments
7837      (substitute-keyword-arguments (package-arguments sbcl-antik-base)
7838        ((#:asd-file _ "") "antik.asd")
7839        ((#:asd-system-name _ #f) "antik")))))
7840
7841 (define-public cl-antik
7842   (sbcl-package->cl-source-package sbcl-antik))
7843
7844 (define-public sbcl-cl-interpol
7845   (let ((commit "1fd288d861db85bc4677cff3cdd6af75fda1afb4")
7846         (revision "1"))
7847     (package
7848       (name "sbcl-cl-interpol")
7849       (version (git-version "0.2.6" revision commit))
7850       (source
7851        (origin
7852          (method git-fetch)
7853          (uri (git-reference
7854                (url "https://github.com/edicl/cl-interpol.git")
7855                (commit commit)))
7856          (file-name (git-file-name name version))
7857          (sha256
7858           (base32
7859            "1hnikak52hmcq1r5f616m6qq1108qnkw80pja950nv1fq5p0ppjn"))))
7860       (build-system asdf-build-system/sbcl)
7861       (inputs
7862        `(("cl-unicode" ,sbcl-cl-unicode)
7863          ("named-readtables" ,sbcl-named-readtables)))
7864       (native-inputs
7865        `(("flexi-streams" ,sbcl-flexi-streams)))
7866       (synopsis "String interpolation for Common Lisp")
7867       (description
7868        "CL-INTERPOL is a library for Common Lisp which modifies the
7869 reader so that you can have interpolation within strings similar to
7870 Perl or Unix Shell scripts.  It also provides various ways to insert
7871 arbitrary characters into literal strings even if your editor/IDE
7872 doesn't support them.")
7873       (home-page "https://edicl.github.io/cl-interpol/")
7874       (license license:bsd-3))))
7875
7876 (define-public cl-interpol
7877   (sbcl-package->cl-source-package sbcl-cl-interpol))
7878
7879 (define-public ecl-cl-interpol
7880   (sbcl-package->ecl-package sbcl-cl-interpol))
7881
7882 (define sbcl-symbol-munger-boot0
7883   ;; There is a cyclical dependency between symbol-munger and lisp-unit2.
7884   ;; See https://github.com/AccelerationNet/symbol-munger/issues/4
7885   (let ((commit "cc2bb4b7acd454d756484aec81ba487648385fc3")
7886         (revision "1"))
7887     (package
7888       (name "sbcl-symbol-munger-boot0")
7889       (version (git-version "0.0.1" revision commit))
7890       (source
7891        (origin
7892          (method git-fetch)
7893          (uri (git-reference
7894                (url "https://github.com/AccelerationNet/symbol-munger.git")
7895                (commit commit)))
7896          (file-name (git-file-name name version))
7897          (sha256
7898           (base32
7899            "0diav5ricqsybqvbp4bkxyj3bn3v9n7xb2pqqc4vg1algsw2pyjl"))))
7900       (build-system asdf-build-system/sbcl)
7901       (arguments
7902        `(#:asd-file "symbol-munger.asd"
7903          #:asd-system-name "symbol-munger"))
7904       (inputs
7905        `(("iterate" ,sbcl-iterate)
7906          ("alexandria" ,sbcl-alexandria)))
7907       (native-inputs
7908        `(("lisp-unit" ,sbcl-lisp-unit)))
7909       (synopsis
7910        "Capitalization and spacing conversion functions for Common Lisp")
7911       (description
7912        "This is a Common Lisp library to change the capitalization and spacing
7913 of a string or a symbol.  It can convert to and from Lisp, english, underscore
7914 and camel-case rules.")
7915       (home-page "https://github.com/AccelerationNet/symbol-munger")
7916       ;; The package declares a BSD license, but all of the license
7917       ;; text is MIT.
7918       ;; See https://github.com/AccelerationNet/symbol-munger/issues/5
7919       (license license:expat))))
7920
7921 (define sbcl-lisp-unit2-boot0
7922   ;; There is a cyclical dependency between symbol-munger and lisp-unit2.
7923   ;; See https://github.com/AccelerationNet/symbol-munger/issues/4
7924   (let ((commit "fb9721524d1e4e73abb223ee036d74ce14a5505c")
7925         (revision "1"))
7926     (package
7927       (name "sbcl-lisp-unit2-boot0")
7928       (version (git-version "0.2.0" revision commit))
7929       (source
7930        (origin
7931          (method git-fetch)
7932          (uri (git-reference
7933                (url "https://github.com/AccelerationNet/lisp-unit2.git")
7934                (commit commit)))
7935          (file-name (git-file-name name version))
7936          (sha256
7937           (base32
7938            "1rsqy8y0jqll6xn9a593848f5wvd5ribv4csry1ly0hmdhfnqzlp"))))
7939       (build-system asdf-build-system/sbcl)
7940       (arguments
7941        `(#:asd-file "lisp-unit2.asd"
7942          #:asd-system-name "lisp-unit2"))
7943       (inputs
7944        `(("alexandria" ,sbcl-alexandria)
7945          ("cl-interpol" ,sbcl-cl-interpol)
7946          ("iterate" ,sbcl-iterate)
7947          ("symbol-munger-boot0" ,sbcl-symbol-munger-boot0)))
7948       (synopsis "Test Framework for Common Lisp")
7949       (description
7950        "LISP-UNIT2 is a Common Lisp library that supports unit testing in the
7951 style of JUnit for Java.  It is a new version of the lisp-unit library written
7952 by Chris Riesbeck.")
7953       (home-page "https://github.com/AccelerationNet/lisp-unit2")
7954       (license license:expat))))
7955
7956 (define-public sbcl-symbol-munger
7957   (let ((commit "97598d4c3c53fd5da72ab78908fbd5d8c7a13416")
7958         (revision "1"))
7959     (package
7960       (name "sbcl-symbol-munger")
7961       (version (git-version "0.0.1" revision commit))
7962       (source
7963        (origin
7964          (method git-fetch)
7965          (uri (git-reference
7966                (url "https://github.com/AccelerationNet/symbol-munger.git")
7967                (commit commit)))
7968          (file-name (git-file-name name version))
7969          (sha256
7970           (base32
7971            "0y8jywjy0ldyhp7bxf16fdvdd2qgqnd7nlhlqfpfnzxcqk4xy1km"))))
7972       (build-system asdf-build-system/sbcl)
7973       (inputs
7974        `(("alexandria" ,sbcl-alexandria)
7975          ("iterate" ,sbcl-iterate)))
7976       (native-inputs
7977        `(("lisp-unit2-boot0" ,sbcl-lisp-unit2-boot0)))
7978       (synopsis
7979        "Capitalization and spacing conversion functions for Common Lisp")
7980       (description
7981        "This is a Common Lisp library to change the capitalization and spacing
7982 of a string or a symbol.  It can convert to and from Lisp, english, underscore
7983 and camel-case rules.")
7984       (home-page "https://github.com/AccelerationNet/symbol-munger")
7985       ;; The package declares a BSD license, but all of the license
7986       ;; text is MIT.
7987       ;; See https://github.com/AccelerationNet/symbol-munger/issues/5
7988       (license license:expat))))
7989
7990 (define-public cl-symbol-munger
7991   (sbcl-package->cl-source-package sbcl-symbol-munger))
7992
7993 (define-public ecl-symbol-munger
7994   (sbcl-package->ecl-package sbcl-symbol-munger))
7995
7996 (define-public sbcl-lisp-unit2
7997   (package
7998     (inherit sbcl-lisp-unit2-boot0)
7999     (name "sbcl-lisp-unit2")
8000     (inputs
8001      `(("alexandria" ,sbcl-alexandria)
8002        ("cl-interpol" ,sbcl-cl-interpol)
8003        ("iterate" ,sbcl-iterate)
8004        ("symbol-munger" ,sbcl-symbol-munger)))))
8005
8006 (define-public cl-lisp-unit2
8007   (sbcl-package->cl-source-package sbcl-lisp-unit2))
8008
8009 (define-public ecl-lisp-unit2
8010   (sbcl-package->ecl-package sbcl-lisp-unit2))
8011
8012 (define-public sbcl-cl-csv
8013   (let ((commit "3eba29c8364b033fbe0d189c2500559278b6a362")
8014         (revision "1"))
8015     (package
8016       (name "sbcl-cl-csv")
8017       (version (git-version "1.0.6" revision commit))
8018       (source
8019        (origin
8020          (method git-fetch)
8021          (uri (git-reference
8022                (url "https://github.com/AccelerationNet/cl-csv.git")
8023                (commit commit)))
8024          (file-name (git-file-name name version))
8025          (sha256
8026           (base32
8027            "07h4ni89jzx93clx453hlnnb5g53hhlcmz5hghqv6ysam48lc8g6"))))
8028       (build-system asdf-build-system/sbcl)
8029       (arguments
8030        ;; See: https://github.com/AccelerationNet/cl-csv/pull/34
8031        `(#:tests? #f))
8032       (inputs
8033        `(("alexandria" ,sbcl-alexandria)
8034          ("cl-interpol" ,sbcl-cl-interpol)
8035          ("iterate" ,sbcl-iterate)))
8036       (native-inputs
8037        `(("lisp-unit2" ,sbcl-lisp-unit2)))
8038       (synopsis "Common lisp library for comma-separated values")
8039       (description
8040        "This is a Common Lisp library providing functions to read/write CSV
8041 from/to strings, streams and files.")
8042       (home-page "https://github.com/AccelerationNet/cl-csv")
8043       (license license:bsd-3))))
8044
8045 (define-public cl-csv
8046   (sbcl-package->cl-source-package sbcl-cl-csv))
8047
8048 (define-public ecl-cl-csv
8049   (sbcl-package->ecl-package sbcl-cl-csv))
8050
8051 (define-public sbcl-external-program
8052   (let ((commit "5888b8f1fd3953feeeacecbba4384ddda584a749")
8053         (revision "1"))
8054     (package
8055       (name "sbcl-external-program")
8056       (version (git-version "0.0.6" revision commit))
8057       (source
8058        (origin
8059          (method git-fetch)
8060          (uri (git-reference
8061                (url "https://github.com/sellout/external-program.git")
8062                (commit commit)))
8063          (file-name (git-file-name name version))
8064          (sha256
8065           (base32
8066            "0vww1x3yilb3bjwg6k184vaj4vxyxw4vralhnlm6lk4xac67kc9z"))))
8067       (build-system asdf-build-system/sbcl)
8068       (inputs
8069        `(("trivial-features" ,sbcl-trivial-features)))
8070       (native-inputs
8071        `(("fiveam" ,sbcl-fiveam)))
8072       (synopsis "Common Lisp library for running external programs")
8073       (description
8074        "EXTERNAL-PROGRAM enables running programs outside the Lisp
8075 process.  It is an attempt to make the RUN-PROGRAM functionality in
8076 implementations like SBCL and CCL as portable as possible without
8077 sacrificing much in the way of power.")
8078       (home-page "https://github.com/sellout/external-program")
8079       (license license:llgpl))))
8080
8081 (define-public cl-external-program
8082   (sbcl-package->cl-source-package sbcl-external-program))
8083
8084 (define-public ecl-external-program
8085   (sbcl-package->ecl-package sbcl-external-program))
8086
8087 (define sbcl-cl-ana-boot0
8088   (let ((commit "fa7cee4c50aa1c859652813049ba0da7c18a0df9")
8089         (revision "1"))
8090     (package
8091      (name "sbcl-cl-ana-boot0")
8092      (version (git-version "0.0.0" revision commit))
8093      (source
8094       (origin
8095        (method git-fetch)
8096        (uri (git-reference
8097              (url "https://github.com/ghollisjr/cl-ana.git")
8098              (commit commit)))
8099        (file-name (git-file-name name version))
8100        (sha256
8101         (base32
8102          "0mr47l57m276dbpap7irr4fcnk5fgknhf6mgv4043s8h73amk5qh"))))
8103      (build-system asdf-build-system/sbcl)
8104      (synopsis "Common Lisp data analysis library")
8105      (description
8106       "CL-ANA is a data analysis library in Common Lisp providing tabular and
8107 binned data analysis along with nonlinear least squares fitting and
8108 visualization.")
8109      (home-page "https://github.com/ghollisjr/cl-ana")
8110      (license license:gpl3))))
8111
8112 (define-public sbcl-cl-ana.pathname-utils
8113   (package
8114     (inherit sbcl-cl-ana-boot0)
8115     (name "sbcl-cl-ana.pathname-utils")
8116     (arguments
8117      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8118        ((#:asd-file _ "") "pathname-utils/cl-ana.pathname-utils.asd")
8119        ((#:asd-system-name _ #f) "cl-ana.pathname-utils")))))
8120
8121 (define-public cl-ana.pathname-utils
8122   (sbcl-package->cl-source-package sbcl-cl-ana.pathname-utils))
8123
8124 (define-public ecl-cl-ana.pathname-utils
8125   (sbcl-package->ecl-package sbcl-cl-ana.pathname-utils))
8126
8127 (define-public sbcl-cl-ana.package-utils
8128   (package
8129     (inherit sbcl-cl-ana-boot0)
8130     (name "sbcl-cl-ana.package-utils")
8131     (inputs
8132      `(("alexandria" ,sbcl-alexandria)))
8133     (arguments
8134      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8135        ((#:asd-file _ "") "package-utils/cl-ana.package-utils.asd")
8136        ((#:asd-system-name _ #f) "cl-ana.package-utils")))))
8137
8138 (define-public cl-ana.package-utils
8139   (sbcl-package->cl-source-package sbcl-cl-ana.package-utils))
8140
8141 (define-public ecl-cl-ana.package-utils
8142   (sbcl-package->ecl-package sbcl-cl-ana.package-utils))
8143
8144 (define-public sbcl-cl-ana.string-utils
8145   (package
8146     (inherit sbcl-cl-ana-boot0)
8147     (name "sbcl-cl-ana.string-utils")
8148     (inputs
8149      `(("split-sequence" ,sbcl-split-sequence)))
8150     (arguments
8151      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8152        ((#:asd-file _ "") "string-utils/cl-ana.string-utils.asd")
8153        ((#:asd-system-name _ #f) "cl-ana.string-utils")))))
8154
8155 (define-public cl-ana.string-utils
8156   (sbcl-package->cl-source-package sbcl-cl-ana.string-utils))
8157
8158 (define-public ecl-cl-ana.string-utils
8159   (sbcl-package->ecl-package sbcl-cl-ana.string-utils))
8160
8161 (define-public sbcl-cl-ana.functional-utils
8162   (package
8163     (inherit sbcl-cl-ana-boot0)
8164     (name "sbcl-cl-ana.functional-utils")
8165     (arguments
8166      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8167        ((#:asd-file _ "") "functional-utils/cl-ana.functional-utils.asd")
8168        ((#:asd-system-name _ #f) "cl-ana.functional-utils")))))
8169
8170 (define-public cl-ana.functional-utils
8171   (sbcl-package->cl-source-package sbcl-cl-ana.functional-utils))
8172
8173 (define-public ecl-cl-ana.functional-utils
8174   (sbcl-package->ecl-package sbcl-cl-ana.functional-utils))
8175
8176 (define-public sbcl-cl-ana.list-utils
8177   (package
8178     (inherit sbcl-cl-ana-boot0)
8179     (name "sbcl-cl-ana.list-utils")
8180     (inputs
8181      `(("alexandria" ,sbcl-alexandria)
8182        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
8183        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)))
8184     (arguments
8185      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8186        ((#:asd-file _ "") "list-utils/cl-ana.list-utils.asd")
8187        ((#:asd-system-name _ #f) "cl-ana.list-utils")))))
8188
8189 (define-public cl-ana.list-utils
8190   (sbcl-package->cl-source-package sbcl-cl-ana.list-utils))
8191
8192 (define-public ecl-cl-ana.list-utils
8193   (sbcl-package->ecl-package sbcl-cl-ana.list-utils))
8194
8195 (define-public sbcl-cl-ana.generic-math
8196   (package
8197     (inherit sbcl-cl-ana-boot0)
8198     (name "sbcl-cl-ana.generic-math")
8199     (inputs
8200      `(("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8201        ("cl-ana.package-utils" ,sbcl-cl-ana.package-utils)))
8202     (arguments
8203      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8204        ((#:asd-file _ "") "generic-math/cl-ana.generic-math.asd")
8205        ((#:asd-system-name _ #f) "cl-ana.generic-math")))))
8206
8207 (define-public cl-ana.generic-math
8208   (sbcl-package->cl-source-package sbcl-cl-ana.generic-math))
8209
8210 (define-public ecl-cl-ana.generic-math
8211   (sbcl-package->ecl-package sbcl-cl-ana.generic-math))
8212
8213 (define-public sbcl-cl-ana.math-functions
8214   (package
8215     (inherit sbcl-cl-ana-boot0)
8216     (name "sbcl-cl-ana.math-functions")
8217     (inputs
8218      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8219        ("gsll" ,sbcl-gsll)))
8220     (arguments
8221      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8222        ((#:asd-file _ "") "math-functions/cl-ana.math-functions.asd")
8223        ((#:asd-system-name _ #f) "cl-ana.math-functions")))))
8224
8225 (define-public cl-ana.math-functions
8226   (sbcl-package->cl-source-package sbcl-cl-ana.math-functions))
8227
8228 (define-public sbcl-cl-ana.calculus
8229   (package
8230     (inherit sbcl-cl-ana-boot0)
8231     (name "sbcl-cl-ana.calculus")
8232     (inputs
8233      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)))
8234     (arguments
8235      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8236        ((#:asd-file _ "") "calculus/cl-ana.calculus.asd")
8237        ((#:asd-system-name _ #f) "cl-ana.calculus")))))
8238
8239 (define-public cl-ana.calculus
8240   (sbcl-package->cl-source-package sbcl-cl-ana.calculus))
8241
8242 (define-public ecl-cl-ana.calculus
8243   (sbcl-package->ecl-package sbcl-cl-ana.calculus))
8244
8245 (define-public sbcl-cl-ana.symbol-utils
8246   (package
8247     (inherit sbcl-cl-ana-boot0)
8248     (name "sbcl-cl-ana.symbol-utils")
8249     (inputs
8250      `(("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)))
8251     (arguments
8252      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8253        ((#:asd-file _ "") "symbol-utils/cl-ana.symbol-utils.asd")
8254        ((#:asd-system-name _ #f) "cl-ana.symbol-utils")))))
8255
8256 (define-public cl-ana.symbol-utils
8257   (sbcl-package->cl-source-package sbcl-cl-ana.symbol-utils))
8258
8259 (define-public ecl-cl-ana.symbol-utils
8260   (sbcl-package->ecl-package sbcl-cl-ana.symbol-utils))
8261
8262 (define-public sbcl-cl-ana.macro-utils
8263   (package
8264     (inherit sbcl-cl-ana-boot0)
8265     (name "sbcl-cl-ana.macro-utils")
8266     (inputs
8267      `(("alexandria" ,sbcl-alexandria)
8268        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8269        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8270        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8271        ("split-sequence" ,sbcl-split-sequence)))
8272     (arguments
8273      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8274        ((#:asd-file _ "") "macro-utils/cl-ana.macro-utils.asd")
8275        ((#:asd-system-name _ #f) "cl-ana.macro-utils")))))
8276
8277 (define-public cl-ana.macro-utils
8278   (sbcl-package->cl-source-package sbcl-cl-ana.macro-utils))
8279
8280 (define-public ecl-cl-ana.macro-utils
8281   (sbcl-package->ecl-package sbcl-cl-ana.macro-utils))
8282
8283 (define-public sbcl-cl-ana.binary-tree
8284   (package
8285     (inherit sbcl-cl-ana-boot0)
8286     (name "sbcl-cl-ana.binary-tree")
8287     (inputs
8288      `(("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
8289        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8290        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)))
8291     (arguments
8292      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8293        ((#:asd-file _ "") "binary-tree/cl-ana.binary-tree.asd")
8294        ((#:asd-system-name _ #f) "cl-ana.binary-tree")))))
8295
8296 (define-public cl-ana.binary-tree
8297   (sbcl-package->cl-source-package sbcl-cl-ana.binary-tree))
8298
8299 (define-public ecl-cl-ana.binary-tree
8300   (sbcl-package->ecl-package sbcl-cl-ana.binary-tree))
8301
8302 (define-public sbcl-cl-ana.tensor
8303   (package
8304     (inherit sbcl-cl-ana-boot0)
8305     (name "sbcl-cl-ana.tensor")
8306     (inputs
8307      `(("alexandria" ,sbcl-alexandria)
8308        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8309        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8310        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8311        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)))
8312     (arguments
8313      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8314        ((#:asd-file _ "") "tensor/cl-ana.tensor.asd")
8315        ((#:asd-system-name _ #f) "cl-ana.tensor")))))
8316
8317 (define-public cl-ana.tensor
8318   (sbcl-package->cl-source-package sbcl-cl-ana.tensor))
8319
8320 (define-public ecl-cl-ana.tensor
8321   (sbcl-package->ecl-package sbcl-cl-ana.tensor))
8322
8323 (define-public sbcl-cl-ana.error-propogation
8324   (package
8325     (inherit sbcl-cl-ana-boot0)
8326     (name "sbcl-cl-ana.error-propogation")
8327     (inputs
8328      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8329        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)))
8330     (arguments
8331      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8332        ((#:asd-file _ "") "error-propogation/cl-ana.error-propogation.asd")
8333        ((#:asd-system-name _ #f) "cl-ana.error-propogation")))))
8334
8335 (define-public cl-ana.error-propogation
8336   (sbcl-package->cl-source-package sbcl-cl-ana.error-propogation))
8337
8338 (define-public sbcl-cl-ana.quantity
8339   (package
8340     (inherit sbcl-cl-ana-boot0)
8341     (name "sbcl-cl-ana.quantity")
8342     (inputs
8343      `(("alexandria" ,sbcl-alexandria)
8344        ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
8345        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8346        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8347        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8348        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)))
8349     (arguments
8350      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8351        ((#:asd-file _ "") "quantity/cl-ana.quantity.asd")
8352        ((#:asd-system-name _ #f) "cl-ana.quantity")))))
8353
8354 (define-public cl-ana.quantity
8355   (sbcl-package->cl-source-package sbcl-cl-ana.quantity))
8356
8357 (define-public sbcl-cl-ana.table
8358   (package
8359     (inherit sbcl-cl-ana-boot0)
8360     (name "sbcl-cl-ana.table")
8361     (inputs
8362      `(("alexandria" ,sbcl-alexandria)
8363        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
8364        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8365        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8366        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8367        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)))
8368     (arguments
8369      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8370        ((#:asd-file _ "") "table/cl-ana.table.asd")
8371        ((#:asd-system-name _ #f) "cl-ana.table")))))
8372
8373 (define-public cl-ana.table
8374   (sbcl-package->cl-source-package sbcl-cl-ana.table))
8375
8376 (define-public ecl-cl-ana.table
8377   (sbcl-package->ecl-package sbcl-cl-ana.table))
8378
8379 (define-public sbcl-cl-ana.table-utils
8380   (package
8381     (inherit sbcl-cl-ana-boot0)
8382     (name "sbcl-cl-ana.table-utils")
8383     (inputs
8384      `(("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8385        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8386        ("cl-ana.table" ,sbcl-cl-ana.table)))
8387     (arguments
8388      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8389        ((#:asd-file _ "") "table-utils/cl-ana.table-utils.asd")
8390        ((#:asd-system-name _ #f) "cl-ana.table-utils")))))
8391
8392 (define-public cl-ana.table-utils
8393   (sbcl-package->cl-source-package sbcl-cl-ana.table-utils))
8394
8395 (define-public ecl-cl-ana.table-utils
8396   (sbcl-package->ecl-package sbcl-cl-ana.table-utils))
8397
8398 (define-public sbcl-cl-ana.hdf-cffi
8399   (package
8400     (inherit sbcl-cl-ana-boot0)
8401     (name "sbcl-cl-ana.hdf-cffi")
8402     (inputs
8403      `(("cffi" ,sbcl-cffi)
8404        ("hdf5" ,hdf5-parallel-openmpi)))
8405     (arguments
8406      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8407        ((#:asd-file _ "") "hdf-cffi/cl-ana.hdf-cffi.asd")
8408        ((#:asd-system-name _ #f) "cl-ana.hdf-cffi")
8409        ((#:phases phases '%standard-phases)
8410         `(modify-phases ,phases
8411            (add-after 'unpack 'fix-paths
8412              (lambda* (#:key inputs #:allow-other-keys)
8413                (substitute* "hdf-cffi/hdf-cffi.lisp"
8414                  (("/usr/lib/i386-linux-gnu/hdf5/serial/libhdf5.so")
8415                   (string-append
8416                    (assoc-ref inputs "hdf5")
8417                    "/lib/libhdf5.so")))))))))))
8418
8419 (define-public cl-ana.hdf-cffi
8420   (sbcl-package->cl-source-package sbcl-cl-ana.hdf-cffi))
8421
8422 (define-public ecl-cl-ana.hdf-cffi
8423   (sbcl-package->ecl-package sbcl-cl-ana.hdf-cffi))
8424
8425 (define-public sbcl-cl-ana.int-char
8426   (package
8427     (inherit sbcl-cl-ana-boot0)
8428     (name "sbcl-cl-ana.int-char")
8429     (arguments
8430      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8431        ((#:asd-file _ "") "int-char/cl-ana.int-char.asd")
8432        ((#:asd-system-name _ #f) "cl-ana.int-char")))))
8433
8434 (define-public cl-ana.int-char
8435   (sbcl-package->cl-source-package sbcl-cl-ana.int-char))
8436
8437 (define-public ecl-cl-ana.int-char
8438   (sbcl-package->ecl-package sbcl-cl-ana.int-char))
8439
8440 (define-public sbcl-cl-ana.memoization
8441   (package
8442     (inherit sbcl-cl-ana-boot0)
8443     (name "sbcl-cl-ana.memoization")
8444     (inputs
8445      `(("alexandria" ,sbcl-alexandria)))
8446     (arguments
8447      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8448        ((#:asd-file _ "") "memoization/cl-ana.memoization.asd")
8449        ((#:asd-system-name _ #f) "cl-ana.memoization")))))
8450
8451 (define-public cl-ana.memoization
8452   (sbcl-package->cl-source-package sbcl-cl-ana.memoization))
8453
8454 (define-public ecl-cl-ana.memoization
8455   (sbcl-package->ecl-package sbcl-cl-ana.memoization))
8456
8457 (define-public sbcl-cl-ana.typespec
8458   (package
8459     (inherit sbcl-cl-ana-boot0)
8460     (name "sbcl-cl-ana.typespec")
8461     (inputs
8462      `(("alexandria" ,sbcl-alexandria)
8463        ("cffi" ,sbcl-cffi)
8464        ("cl-ana.int-char" ,sbcl-cl-ana.int-char)
8465        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8466        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
8467        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8468        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8469        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)))
8470     (arguments
8471      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8472        ((#:asd-file _ "") "typespec/cl-ana.typespec.asd")
8473        ((#:asd-system-name _ #f) "cl-ana.typespec")))))
8474
8475 (define-public cl-ana.typespec
8476   (sbcl-package->cl-source-package sbcl-cl-ana.typespec))
8477
8478 (define-public ecl-cl-ana.typespec
8479   (sbcl-package->ecl-package sbcl-cl-ana.typespec))
8480
8481 (define-public sbcl-cl-ana.hdf-typespec
8482   (package
8483     (inherit sbcl-cl-ana-boot0)
8484     (name "sbcl-cl-ana.hdf-typespec")
8485     (inputs
8486      `(("alexandria" ,sbcl-alexandria)
8487        ("cffi" ,sbcl-cffi)
8488        ("cl-ana.hdf-cffi" ,sbcl-cl-ana.hdf-cffi)
8489        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8490        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
8491        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8492        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8493        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
8494     (arguments
8495      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8496        ((#:asd-file _ "") "hdf-typespec/cl-ana.hdf-typespec.asd")
8497        ((#:asd-system-name _ #f) "cl-ana.hdf-typespec")))))
8498
8499 (define-public cl-ana.hdf-typespec
8500   (sbcl-package->cl-source-package sbcl-cl-ana.hdf-typespec))
8501
8502 (define-public ecl-cl-ana.hdf-typespec
8503   (sbcl-package->ecl-package sbcl-cl-ana.hdf-typespec))
8504
8505 (define-public sbcl-cl-ana.hdf-utils
8506   (package
8507     (inherit sbcl-cl-ana-boot0)
8508     (name "sbcl-cl-ana.hdf-utils")
8509     (inputs
8510      `(("alexandria" ,sbcl-alexandria)
8511        ("cffi" ,sbcl-cffi)
8512        ("cl-ana.hdf-cffi" ,sbcl-cl-ana.hdf-cffi)
8513        ("cl-ana.hdf-typespec" ,sbcl-cl-ana.hdf-typespec)
8514        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8515        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
8516        ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
8517        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8518        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
8519     (arguments
8520      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8521        ((#:asd-file _ "") "hdf-utils/cl-ana.hdf-utils.asd")
8522        ((#:asd-system-name _ #f) "cl-ana.hdf-utils")))))
8523
8524 (define-public cl-ana.hdf-utils
8525   (sbcl-package->cl-source-package sbcl-cl-ana.hdf-utils))
8526
8527 (define-public ecl-cl-ana.hdf-utils
8528   (sbcl-package->ecl-package sbcl-cl-ana.hdf-utils))
8529
8530 (define-public sbcl-cl-ana.typed-table
8531   (package
8532     (inherit sbcl-cl-ana-boot0)
8533     (name "sbcl-cl-ana.typed-table")
8534     (inputs
8535      `(("alexandria" ,sbcl-alexandria)
8536        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8537        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8538        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8539        ("cl-ana.table" ,sbcl-cl-ana.table)
8540        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
8541     (arguments
8542      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8543        ((#:asd-file _ "") "typed-table/cl-ana.typed-table.asd")
8544        ((#:asd-system-name _ #f) "cl-ana.typed-table")))))
8545
8546 (define-public cl-ana.typed-table
8547   (sbcl-package->cl-source-package sbcl-cl-ana.typed-table))
8548
8549 (define-public ecl-cl-ana.typed-table
8550   (sbcl-package->ecl-package sbcl-cl-ana.typed-table))
8551
8552 (define-public sbcl-cl-ana.hdf-table
8553   (package
8554     (inherit sbcl-cl-ana-boot0)
8555     (name "sbcl-cl-ana.hdf-table")
8556     (inputs
8557      `(("alexandria" ,sbcl-alexandria)
8558        ("cl-ana.binary-tree" ,sbcl-cl-ana.binary-tree)
8559        ("cl-ana.hdf-cffi" ,sbcl-cl-ana.hdf-cffi)
8560        ("cl-ana.hdf-typespec" ,sbcl-cl-ana.hdf-typespec)
8561        ("cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
8562        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8563        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
8564        ("cl-ana.table" ,sbcl-cl-ana.table)
8565        ("cl-ana.typed-table" ,sbcl-cl-ana.typed-table)
8566        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
8567     (arguments
8568      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8569        ((#:asd-file _ "") "hdf-table/cl-ana.hdf-table.asd")
8570        ((#:asd-system-name _ #f) "cl-ana.hdf-table")))))
8571
8572 (define-public cl-ana.hdf-table
8573   (sbcl-package->cl-source-package sbcl-cl-ana.hdf-table))
8574
8575 (define-public ecl-cl-ana.hdf-table
8576   (sbcl-package->ecl-package sbcl-cl-ana.hdf-table))
8577
8578 (define-public sbcl-cl-ana.gsl-cffi
8579   (package
8580     (inherit sbcl-cl-ana-boot0)
8581     (name "sbcl-cl-ana.gsl-cffi")
8582     (inputs
8583      `(("cffi" ,sbcl-cffi)
8584        ("gsl" ,gsl)))
8585     (arguments
8586      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8587        ((#:asd-file _ "") "gsl-cffi/cl-ana.gsl-cffi.asd")
8588        ((#:asd-system-name _ #f) "cl-ana.gsl-cffi")
8589        ((#:phases phases '%standard-phases)
8590         `(modify-phases ,phases
8591            (add-after 'unpack 'fix-paths
8592              (lambda* (#:key inputs #:allow-other-keys)
8593                (substitute* "gsl-cffi/gsl-cffi.lisp"
8594                  (("define-foreign-library gsl-cffi" all)
8595                   (string-append all " (:unix "
8596                                  (assoc-ref inputs "gsl")
8597                                  "/lib/libgsl.so)")))))))))))
8598
8599 (define-public cl-ana.gsl-cffi
8600   (sbcl-package->cl-source-package sbcl-cl-ana.gsl-cffi))
8601
8602 (define-public ecl-cl-ana.gsl-cffi
8603   (sbcl-package->ecl-package sbcl-cl-ana.gsl-cffi))
8604
8605 (define-public sbcl-cl-ana.ntuple-table
8606   (package
8607     (inherit sbcl-cl-ana-boot0)
8608     (name "sbcl-cl-ana.ntuple-table")
8609     (inputs
8610      `(("alexandria" ,sbcl-alexandria)
8611        ("cffi" ,sbcl-cffi)
8612        ("cl-ana.gsl-cffi" ,sbcl-cl-ana.gsl-cffi)
8613        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8614        ("cl-ana.table" ,sbcl-cl-ana.table)
8615        ("cl-ana.typed-table" ,sbcl-cl-ana.typed-table)
8616        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)
8617        ("gsll" ,sbcl-gsll)))
8618     (arguments
8619      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8620        ((#:asd-file _ "") "ntuple-table/cl-ana.ntuple-table.asd")
8621        ((#:asd-system-name _ #f) "cl-ana.ntuple-table")))))
8622
8623 (define-public cl-ana.ntuple-table
8624   (sbcl-package->cl-source-package sbcl-cl-ana.ntuple-table))
8625
8626 (define-public sbcl-cl-ana.csv-table
8627   (package
8628     (inherit sbcl-cl-ana-boot0)
8629     (name "sbcl-cl-ana.csv-table")
8630     (inputs
8631      `(("alexandria" ,sbcl-alexandria)
8632        ("antik" ,sbcl-antik)
8633        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8634        ("cl-ana.table" ,sbcl-cl-ana.table)
8635        ("cl-csv" ,sbcl-cl-csv)
8636        ("iterate" ,sbcl-iterate)))
8637     (arguments
8638      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8639        ((#:asd-file _ "") "csv-table/cl-ana.csv-table.asd")
8640        ((#:asd-system-name _ #f) "cl-ana.csv-table")))))
8641
8642 (define-public cl-ana.csv-table
8643   (sbcl-package->cl-source-package sbcl-cl-ana.csv-table))
8644
8645 (define-public sbcl-cl-ana.reusable-table
8646   (package
8647     (inherit sbcl-cl-ana-boot0)
8648     (name "sbcl-cl-ana.reusable-table")
8649     (inputs
8650      `(("alexandria" ,sbcl-alexandria)
8651        ("cl-ana.table" ,sbcl-cl-ana.table)))
8652     (arguments
8653      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8654        ((#:asd-file _ "") "reusable-table/cl-ana.reusable-table.asd")
8655        ((#:asd-system-name _ #f) "cl-ana.reusable-table")))))
8656
8657 (define-public cl-ana.reusable-table
8658   (sbcl-package->cl-source-package sbcl-cl-ana.reusable-table))
8659
8660 (define-public ecl-cl-ana.reusable-table
8661   (sbcl-package->ecl-package sbcl-cl-ana.reusable-table))
8662
8663 (define-public sbcl-cl-ana.linear-algebra
8664   (package
8665     (inherit sbcl-cl-ana-boot0)
8666     (name "sbcl-cl-ana.linear-algebra")
8667     (inputs
8668      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8669        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8670        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
8671        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
8672        ("gsll" ,sbcl-gsll)))
8673     (arguments
8674      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8675        ((#:asd-file _ "") "linear-algebra/cl-ana.linear-algebra.asd")
8676        ((#:asd-system-name _ #f) "cl-ana.linear-algebra")))))
8677
8678 (define-public cl-ana.linear-algebra
8679   (sbcl-package->cl-source-package sbcl-cl-ana.linear-algebra))
8680
8681 (define-public sbcl-cl-ana.lorentz
8682   (package
8683     (inherit sbcl-cl-ana-boot0)
8684     (name "sbcl-cl-ana.lorentz")
8685     (inputs
8686      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8687        ("cl-ana.linear-algebra" ,sbcl-cl-ana.linear-algebra)
8688        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
8689        ("iterate" ,sbcl-iterate)))
8690     (arguments
8691      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8692        ((#:asd-file _ "") "lorentz/cl-ana.lorentz.asd")
8693        ((#:asd-system-name _ #f) "cl-ana.lorentz")))))
8694
8695 (define-public cl-ana.lorentz
8696   (sbcl-package->cl-source-package sbcl-cl-ana.lorentz))
8697
8698 (define-public sbcl-cl-ana.clos-utils
8699   (package
8700     (inherit sbcl-cl-ana-boot0)
8701     (name "sbcl-cl-ana.clos-utils")
8702     (inputs
8703      `(("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8704        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8705        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
8706        ("closer-mop" ,sbcl-closer-mop)))
8707     (arguments
8708      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8709        ((#:asd-file _ "") "clos-utils/cl-ana.clos-utils.asd")
8710        ((#:asd-system-name _ #f) "cl-ana.clos-utils")))))
8711
8712 (define-public cl-ana.clos-utils
8713   (sbcl-package->cl-source-package sbcl-cl-ana.clos-utils))
8714
8715 (define-public ecl-cl-ana.clos-utils
8716   (sbcl-package->ecl-package sbcl-cl-ana.clos-utils))
8717
8718 (define-public sbcl-cl-ana.hash-table-utils
8719   (package
8720     (inherit sbcl-cl-ana-boot0)
8721     (name "sbcl-cl-ana.hash-table-utils")
8722     (arguments
8723      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8724        ((#:asd-file _ "") "hash-table-utils/cl-ana.hash-table-utils.asd")
8725        ((#:asd-system-name _ #f) "cl-ana.hash-table-utils")))))
8726
8727 (define-public cl-ana.hash-table-utils
8728   (sbcl-package->cl-source-package sbcl-cl-ana.hash-table-utils))
8729
8730 (define-public ecl-cl-ana.hash-table-utils
8731   (sbcl-package->ecl-package sbcl-cl-ana.hash-table-utils))
8732
8733 (define-public sbcl-cl-ana.map
8734   (package
8735     (inherit sbcl-cl-ana-boot0)
8736     (name "sbcl-cl-ana.map")
8737     (inputs
8738      `(("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)))
8739     (arguments
8740      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8741        ((#:asd-file _ "") "map/cl-ana.map.asd")
8742        ((#:asd-system-name _ #f) "cl-ana.map")))))
8743
8744 (define-public cl-ana.map
8745   (sbcl-package->cl-source-package sbcl-cl-ana.map))
8746
8747 (define-public ecl-cl-ana.map
8748   (sbcl-package->ecl-package sbcl-cl-ana.map))
8749
8750 (define-public sbcl-cl-ana.fitting
8751   (package
8752     (inherit sbcl-cl-ana-boot0)
8753     (name "sbcl-cl-ana.fitting")
8754     (inputs
8755      `(("alexandria" ,sbcl-alexandria)
8756        ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
8757        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8758        ("cl-ana.map" ,sbcl-cl-ana.map)
8759        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
8760        ("gsll" ,sbcl-gsll)))
8761     (arguments
8762      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8763        ((#:asd-file _ "") "fitting/cl-ana.fitting.asd")
8764        ((#:asd-system-name _ #f) "cl-ana.fitting")))))
8765
8766 (define-public cl-ana.fitting
8767   (sbcl-package->cl-source-package sbcl-cl-ana.fitting))
8768
8769 (define-public sbcl-cl-ana.histogram
8770   (package
8771     (inherit sbcl-cl-ana-boot0)
8772     (name "sbcl-cl-ana.histogram")
8773     (inputs
8774      `(("alexandria" ,sbcl-alexandria)
8775        ("iterate" ,sbcl-iterate)
8776        ("cl-ana.binary-tree" ,sbcl-cl-ana.binary-tree)
8777        ("cl-ana.clos-utils" ,sbcl-cl-ana.clos-utils)
8778        ("cl-ana.fitting" ,sbcl-cl-ana.fitting)
8779        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
8780        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8781        ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
8782        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8783        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8784        ("cl-ana.map" ,sbcl-cl-ana.map)
8785        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)))
8786     (arguments
8787      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8788        ((#:asd-file _ "") "histogram/cl-ana.histogram.asd")
8789        ((#:asd-system-name _ #f) "cl-ana.histogram")))))
8790
8791 (define-public cl-ana.histogram
8792   (sbcl-package->cl-source-package sbcl-cl-ana.histogram))
8793
8794 (define-public sbcl-cl-ana.file-utils
8795   (package
8796     (inherit sbcl-cl-ana-boot0)
8797     (name "sbcl-cl-ana.file-utils")
8798     (inputs
8799      `(("external-program" ,sbcl-external-program)
8800        ("split-sequence" ,sbcl-split-sequence)))
8801     (arguments
8802      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8803        ((#:asd-file _ "") "file-utils/cl-ana.file-utils.asd")
8804        ((#:asd-system-name _ #f) "cl-ana.file-utils")))))
8805
8806 (define-public cl-ana.file-utils
8807   (sbcl-package->cl-source-package sbcl-cl-ana.file-utils))
8808
8809 (define-public ecl-cl-ana.file-utils
8810   (sbcl-package->ecl-package sbcl-cl-ana.file-utils))
8811
8812 (define-public sbcl-cl-ana.statistics
8813   (package
8814     (inherit sbcl-cl-ana-boot0)
8815     (name "sbcl-cl-ana.statistics")
8816     (inputs
8817      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8818        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
8819        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8820        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8821        ("cl-ana.map" ,sbcl-cl-ana.map)))
8822     (arguments
8823      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8824        ((#:asd-file _ "") "statistics/cl-ana.statistics.asd")
8825        ((#:asd-system-name _ #f) "cl-ana.statistics")))))
8826
8827 (define-public cl-ana.statistics
8828   (sbcl-package->cl-source-package sbcl-cl-ana.statistics))
8829
8830 (define-public sbcl-cl-ana.gnuplot-interface
8831   (package
8832     (inherit sbcl-cl-ana-boot0)
8833     (name "sbcl-cl-ana.gnuplot-interface")
8834     (inputs
8835      `(("external-program" ,sbcl-external-program)))
8836     (arguments
8837      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8838        ((#:asd-file _ "") "gnuplot-interface/cl-ana.gnuplot-interface.asd")
8839        ((#:asd-system-name _ #f) "cl-ana.gnuplot-interface")))))
8840
8841 (define-public cl-ana.gnuplot-interface
8842   (sbcl-package->cl-source-package sbcl-cl-ana.gnuplot-interface))
8843
8844 (define-public ecl-cl-ana.gnuplot-interface
8845   (sbcl-package->ecl-package sbcl-cl-ana.gnuplot-interface))
8846
8847 (define-public sbcl-cl-ana.plotting
8848   (package
8849     (inherit sbcl-cl-ana-boot0)
8850     (name "sbcl-cl-ana.plotting")
8851     (inputs
8852      `(("alexandria" ,sbcl-alexandria)
8853        ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
8854        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
8855        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8856        ("cl-ana.gnuplot-interface" ,sbcl-cl-ana.gnuplot-interface)
8857        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
8858        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8859        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8860        ("cl-ana.map" ,sbcl-cl-ana.map)
8861        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
8862        ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
8863        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8864        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
8865        ("external-program" ,sbcl-external-program)
8866        ("split-sequence" ,sbcl-split-sequence)))
8867     (arguments
8868      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8869        ((#:asd-file _ "") "plotting/cl-ana.plotting.asd")
8870        ((#:asd-system-name _ #f) "cl-ana.plotting")))))
8871
8872 (define-public cl-ana.plotting
8873   (sbcl-package->cl-source-package sbcl-cl-ana.plotting))
8874
8875 (define-public sbcl-cl-ana.table-viewing
8876   (package
8877     (inherit sbcl-cl-ana-boot0)
8878     (name "sbcl-cl-ana.table-viewing")
8879     (inputs
8880      `(("alexandria" ,sbcl-alexandria)
8881        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8882        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
8883        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8884        ("cl-ana.plotting" ,sbcl-cl-ana.plotting)
8885        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8886        ("cl-ana.table" ,sbcl-cl-ana.table)))
8887     (arguments
8888      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8889        ((#:asd-file _ "") "table-viewing/cl-ana.table-viewing.asd")
8890        ((#:asd-system-name _ #f) "cl-ana.table-viewing")))))
8891
8892 (define-public cl-ana.table-viewing
8893   (sbcl-package->cl-source-package sbcl-cl-ana.table-viewing))
8894
8895 (define-public sbcl-cl-ana.serialization
8896   (package
8897     (inherit sbcl-cl-ana-boot0)
8898     (name "sbcl-cl-ana.serialization")
8899     (inputs
8900      `(("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
8901        ("cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
8902        ("cl-ana.hdf-table" ,sbcl-cl-ana.hdf-table)
8903        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
8904        ("cl-ana.int-char" ,sbcl-cl-ana.int-char)
8905        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8906        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
8907     (arguments
8908      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8909        ((#:asd-file _ "") "serialization/cl-ana.serialization.asd")
8910        ((#:asd-system-name _ #f) "cl-ana.serialization")))))
8911
8912 (define-public cl-ana.serialization
8913   (sbcl-package->cl-source-package sbcl-cl-ana.serialization))
8914
8915 (define-public sbcl-cl-ana.makeres
8916   (package
8917     (inherit sbcl-cl-ana-boot0)
8918     (name "sbcl-cl-ana.makeres")
8919     (inputs
8920      `(("alexandria" ,sbcl-alexandria)
8921        ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
8922        ("cl-ana.file-utils" ,sbcl-cl-ana.file-utils)
8923        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
8924        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8925        ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
8926        ("cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
8927        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
8928        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8929        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8930        ("cl-ana.map" ,sbcl-cl-ana.map)
8931        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
8932        ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
8933        ("cl-ana.plotting" ,sbcl-cl-ana.plotting)
8934        ("cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
8935        ("cl-ana.serialization" ,sbcl-cl-ana.serialization)
8936        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8937        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8938        ("cl-ana.table" ,sbcl-cl-ana.table)
8939        ("external-program" ,sbcl-external-program)))
8940     (native-inputs
8941      `(("cl-fad" ,sbcl-cl-fad)))
8942     (arguments
8943      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8944        ((#:asd-file _ "") "makeres/cl-ana.makeres.asd")
8945        ((#:asd-system-name _ #f) "cl-ana.makeres")))))
8946
8947 (define-public cl-ana.makeres
8948   (sbcl-package->cl-source-package sbcl-cl-ana.makeres))
8949
8950 (define-public sbcl-cl-ana.makeres-macro
8951   (package
8952     (inherit sbcl-cl-ana-boot0)
8953     (name "sbcl-cl-ana.makeres-macro")
8954     (inputs
8955      `(("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8956        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)))
8957     (arguments
8958      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8959        ((#:asd-file _ "") "makeres-macro/cl-ana.makeres-macro.asd")
8960        ((#:asd-system-name _ #f) "cl-ana.makeres-macro")))))
8961
8962 (define-public cl-ana.makeres-macro
8963   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-macro))
8964
8965 (define-public sbcl-cl-ana.makeres-block
8966   (package
8967     (inherit sbcl-cl-ana-boot0)
8968     (name "sbcl-cl-ana.makeres-block")
8969     (inputs
8970      `(("alexandria" ,sbcl-alexandria)
8971        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8972        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8973        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)))
8974     (arguments
8975      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8976        ((#:asd-file _ "") "makeres-block/cl-ana.makeres-block.asd")
8977        ((#:asd-system-name _ #f) "cl-ana.makeres-block")))))
8978
8979 (define-public cl-ana.makeres-block
8980   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-block))
8981
8982 (define-public sbcl-cl-ana.makeres-progress
8983   (package
8984     (inherit sbcl-cl-ana-boot0)
8985     (name "sbcl-cl-ana.makeres-progress")
8986     (inputs
8987      `(("alexandria" ,sbcl-alexandria)
8988        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8989        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)))
8990     (arguments
8991      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8992        ((#:asd-file _ "") "makeres-progress/cl-ana.makeres-progress.asd")
8993        ((#:asd-system-name _ #f) "cl-ana.makeres-progress")))))
8994
8995 (define-public cl-ana.makeres-progress
8996   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-progress))
8997
8998 (define-public sbcl-cl-ana.makeres-table
8999   (package
9000     (inherit sbcl-cl-ana-boot0)
9001     (name "sbcl-cl-ana.makeres-table")
9002     (inputs
9003      `(("cl-ana.csv-table" ,sbcl-cl-ana.csv-table)
9004        ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
9005        ("cl-ana.hdf-table" ,sbcl-cl-ana.hdf-table)
9006        ("cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
9007        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9008        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9009        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)
9010        ("cl-ana.makeres-macro" ,sbcl-cl-ana.makeres-macro)
9011        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
9012        ("cl-ana.ntuple-table" ,sbcl-cl-ana.ntuple-table)
9013        ("cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
9014        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
9015        ("cl-ana.table" ,sbcl-cl-ana.table)))
9016     (native-inputs
9017      `(("cl-fad" ,sbcl-cl-fad)))
9018     (arguments
9019      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9020        ((#:asd-file _ "") "makeres-table/cl-ana.makeres-table.asd")
9021        ((#:asd-system-name _ #f) "cl-ana.makeres-table")))))
9022
9023 (define-public cl-ana.makeres-table
9024   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-table))
9025
9026 (define-public sbcl-cl-ana.makeres-graphviz
9027   (package
9028     (inherit sbcl-cl-ana-boot0)
9029     (name "sbcl-cl-ana.makeres-graphviz")
9030     (inputs
9031      `(("cl-ana.makeres" ,sbcl-cl-ana.makeres)
9032        ("external-program" ,sbcl-external-program)))
9033     (arguments
9034      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9035        ((#:asd-file _ "") "makeres-graphviz/cl-ana.makeres-graphviz.asd")
9036        ((#:asd-system-name _ #f) "cl-ana.makeres-graphviz")))))
9037
9038 (define-public cl-ana.makeres-graphviz
9039   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-graphviz))
9040
9041 (define-public sbcl-cl-ana.makeres-branch
9042   (package
9043     (inherit sbcl-cl-ana-boot0)
9044     (name "sbcl-cl-ana.makeres-branch")
9045     (inputs
9046      `(("alexandria" ,sbcl-alexandria)
9047        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9048        ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
9049        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9050        ("cl-ana.map" ,sbcl-cl-ana.map)
9051        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)))
9052     (arguments
9053      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9054        ((#:asd-file _ "") "makeres-branch/cl-ana.makeres-branch.asd")
9055        ((#:asd-system-name _ #f) "cl-ana.makeres-branch")))))
9056
9057 (define-public cl-ana.makeres-branch
9058   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-branch))
9059
9060 (define-public sbcl-cl-ana.makeres-utils
9061   (package
9062     (inherit sbcl-cl-ana-boot0)
9063     (name "sbcl-cl-ana.makeres-utils")
9064     (inputs
9065      `(("alexandria" ,sbcl-alexandria)
9066        ("cl-ana.file-utils" ,sbcl-cl-ana.file-utils)
9067        ("cl-ana.fitting" ,sbcl-cl-ana.fitting)
9068        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
9069        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9070        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9071        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9072        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9073        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)
9074        ("cl-ana.map" ,sbcl-cl-ana.map)
9075        ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
9076        ("cl-ana.plotting" ,sbcl-cl-ana.plotting)
9077        ("cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
9078        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
9079        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
9080        ("cl-ana.table" ,sbcl-cl-ana.table)))
9081     (native-inputs
9082      `(("cl-fad" ,sbcl-cl-fad)))
9083     (arguments
9084      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9085        ((#:asd-file _ "") "makeres-utils/cl-ana.makeres-utils.asd")
9086        ((#:asd-system-name _ #f) "cl-ana.makeres-utils")))))
9087
9088 (define-public cl-ana.makeres-utils
9089   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-utils))
9090
9091 (define-public sbcl-cl-ana.statistical-learning
9092   (package
9093     (inherit sbcl-cl-ana-boot0)
9094     (name "sbcl-cl-ana.statistical-learning")
9095     (inputs
9096      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9097        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
9098        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9099        ("cl-ana.linear-algebra" ,sbcl-cl-ana.linear-algebra)
9100        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9101        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9102        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
9103        ("cl-ana.map" ,sbcl-cl-ana.map)
9104        ("cl-ana.statistics" ,sbcl-cl-ana.statistics)))
9105     (native-inputs
9106      `(("cl-fad" ,sbcl-cl-fad)))
9107     (arguments
9108      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9109        ((#:asd-file _ "")
9110         "statistical-learning/cl-ana.statistical-learning.asd")
9111        ((#:asd-system-name _ #f) "cl-ana.statistical-learning")))))
9112
9113 (define-public cl-ana.statistical-learning
9114   (sbcl-package->cl-source-package sbcl-cl-ana.statistical-learning))
9115
9116 (define-public sbcl-cl-ana
9117   (package
9118     (inherit sbcl-cl-ana-boot0)
9119     (name "sbcl-cl-ana")
9120     (inputs
9121      `(("cl-ana.binary-tree" ,sbcl-cl-ana.binary-tree)
9122        ("cl-ana.calculus" ,sbcl-cl-ana.calculus)
9123        ("cl-ana.clos-utils" ,sbcl-cl-ana.clos-utils)
9124        ("cl-ana.csv-table" ,sbcl-cl-ana.csv-table)
9125        ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
9126        ("cl-ana.file-utils" ,sbcl-cl-ana.file-utils)
9127        ("cl-ana.fitting" ,sbcl-cl-ana.fitting)
9128        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9129        ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
9130        ("cl-ana.hdf-table" ,sbcl-cl-ana.hdf-table)
9131        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9132        ("cl-ana.int-char" ,sbcl-cl-ana.int-char)
9133        ("cl-ana.linear-algebra" ,sbcl-cl-ana.linear-algebra)
9134        ("cl-ana.lorentz" ,sbcl-cl-ana.lorentz)
9135        ("cl-ana.map" ,sbcl-cl-ana.map)
9136        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)
9137        ("cl-ana.makeres-block" ,sbcl-cl-ana.makeres-block)
9138        ("cl-ana.makeres-branch" ,sbcl-cl-ana.makeres-branch)
9139        ("cl-ana.makeres-graphviz" ,sbcl-cl-ana.makeres-graphviz)
9140        ("cl-ana.makeres-macro" ,sbcl-cl-ana.makeres-macro)
9141        ("cl-ana.makeres-progress" ,sbcl-cl-ana.makeres-progress)
9142        ("cl-ana.makeres-table" ,sbcl-cl-ana.makeres-table)
9143        ("cl-ana.makeres-utils" ,sbcl-cl-ana.makeres-utils)
9144        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
9145        ("cl-ana.ntuple-table" ,sbcl-cl-ana.ntuple-table)
9146        ("cl-ana.package-utils" ,sbcl-cl-ana.package-utils)
9147        ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
9148        ("cl-ana.plotting" ,sbcl-cl-ana.plotting)
9149        ("cl-ana.quantity" ,sbcl-cl-ana.quantity)
9150        ("cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
9151        ("cl-ana.serialization" ,sbcl-cl-ana.serialization)
9152        ("cl-ana.statistics" ,sbcl-cl-ana.statistics)
9153        ("cl-ana.statistical-learning" ,sbcl-cl-ana.statistical-learning)
9154        ("cl-ana.table" ,sbcl-cl-ana.table)
9155        ("cl-ana.table-utils" ,sbcl-cl-ana.table-utils)
9156        ("cl-ana.table-viewing" ,sbcl-cl-ana.table-viewing)
9157        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
9158        ("libffi" ,libffi)))
9159     (native-inputs
9160      `(("cl-fad" ,sbcl-cl-fad)))
9161     (arguments
9162      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9163        ((#:asd-file _ "") "cl-ana.asd")
9164        ((#:asd-system-name _ #f) "cl-ana")))))
9165
9166 (define-public cl-ana
9167   (sbcl-package->cl-source-package sbcl-cl-ana))
9168
9169 (define-public sbcl-archive
9170   (let ((commit "631271c091ed02994bec3980cb288a2cf32c7cdc")
9171         (revision "1"))
9172     (package
9173       (name "sbcl-archive")
9174       (version (git-version "0.9" revision commit))
9175       (source (origin
9176                 (method git-fetch)
9177                 (uri (git-reference
9178                       (url "https://github.com/sharplispers/archive.git")
9179                       (commit commit)))
9180                 (file-name (git-file-name name version))
9181                 (sha256
9182                  (base32
9183                   "0pvsc9fmybx7rxd0kmzq4shi6hszdpwdc1sfy7jwyfxf8n3hnv4p"))))
9184       (build-system asdf-build-system/sbcl)
9185       (inputs
9186        `(("cl-fad" ,sbcl-cl-fad)
9187          ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
9188       (synopsis "Common Lisp library for tar and cpio archives")
9189       (description
9190        "This is a Common Lisp library to read and write disk-based file
9191 archives such as those generated by the tar and cpio programs on Unix.")
9192       (home-page "https://github.com/sharplispers/archive")
9193       (license license:bsd-3))))
9194
9195 (define-public cl-archive
9196   (sbcl-package->cl-source-package sbcl-archive))
9197
9198 (define-public ecl-archive
9199   (sbcl-package->ecl-package sbcl-archive))
9200
9201 (define-public sbcl-misc-extensions
9202   (let ((commit "101c05112bf2f1e1bbf527396822d2f50ca6327a")
9203         (revision "1"))
9204     (package
9205       (name "sbcl-misc-extensions")
9206       (version (git-version "3.3" revision commit))
9207       (source
9208        (origin
9209          (method git-fetch)
9210          (uri (git-reference
9211                (url "https://gitlab.common-lisp.net/misc-extensions/devel.git")
9212                (commit commit)))
9213          (file-name (git-file-name name version))
9214          (sha256
9215           (base32
9216            "0gz5f4p70qzilnxsnf5lih2n9m4wjcw8hlw4w8mpn9jyhyppyyv0"))))
9217       (build-system asdf-build-system/sbcl)
9218       (synopsis "Collection of small macros and extensions for Common Lisp")
9219       (description
9220        "This project is intended as a catchall for small, general-purpose
9221 extensions to Common Lisp.  It contains:
9222
9223 @itemize
9224 @item @code{new-let}, a macro that combines and generalizes @code{let},
9225 @code{let*} and @code{multiple-value-bind},
9226 @item @code{gmap}, an iteration macro that generalizes @code{map}.
9227 @end itemize\n")
9228       (home-page "https://common-lisp.net/project/misc-extensions/")
9229       (license license:public-domain))))
9230
9231 (define-public cl-misc-extensions
9232   (sbcl-package->cl-source-package sbcl-misc-extensions))
9233
9234 (define-public ecl-misc-extensions
9235   (sbcl-package->ecl-package sbcl-misc-extensions))
9236
9237 (define-public sbcl-mt19937
9238   (package
9239     (name "sbcl-mt19937")
9240     (version "1.1")
9241     (source
9242      (origin
9243        (method url-fetch)
9244        (uri (string-append "https://common-lisp.net/project/asdf-packaging/"
9245                            "mt19937-latest.tar.gz"))
9246        (sha256
9247         (base32
9248          "1iw636b0iw5ygkv02y8i41lh7xj0acglv0hg5agryn0zzi2nf1xv"))))
9249     (build-system asdf-build-system/sbcl)
9250     (synopsis "Mersenne Twister pseudo-random number generator")
9251     (description
9252      "MT19937 is a portable Mersenne Twister pseudo-random number generator
9253 for Common Lisp.")
9254     (home-page "https://www.cliki.net/mt19937")
9255     (license license:public-domain)))
9256
9257 (define-public cl-mt19937
9258   (sbcl-package->cl-source-package sbcl-mt19937))
9259
9260 (define-public ecl-mt19937
9261   (sbcl-package->ecl-package sbcl-mt19937))
9262
9263 (define-public sbcl-fset
9264   (let ((commit "6d2f9ded8934d2b42f2571a0ba5bda091037d852")
9265         (revision "1"))
9266     (package
9267       (name "sbcl-fset")
9268       (version (git-version "1.3.2" revision commit))
9269       (source
9270        (origin
9271          (method git-fetch)
9272          (uri (git-reference
9273                (url "https://github.com/slburson/fset")
9274                (commit commit)))
9275          (file-name (git-file-name name version))
9276          (sha256
9277           (base32
9278            "127acblwrbqicx47h6sgvknz1cqyfn8p4xkhkn1m7hxh8w5gk1zy"))
9279          (snippet '(begin
9280                      ;; Remove obsolete copy of system definition.
9281                      (delete-file "Code/fset.asd")
9282                      #t))))
9283       (build-system asdf-build-system/sbcl)
9284       (inputs
9285        `(("misc-extensions" ,sbcl-misc-extensions)
9286          ("mt19937" ,sbcl-mt19937)
9287          ("named-readtables" ,sbcl-named-readtables)))
9288       (synopsis "Functional set-theoretic collections library")
9289       (description
9290        "FSet is a functional set-theoretic collections library for Common Lisp.
9291 Functional means that all update operations return a new collection rather than
9292 modifying an existing one in place.  Set-theoretic means that collections may
9293 be nested arbitrarily with no additional programmer effort; for instance, sets
9294 may contain sets, maps may be keyed by sets, etc.")
9295       (home-page "https://common-lisp.net/project/fset/Site/index.html")
9296       (license license:llgpl))))
9297
9298 (define-public cl-fset
9299   (sbcl-package->cl-source-package sbcl-fset))
9300
9301 (define-public sbcl-cl-cont
9302   (let ((commit "fc1fa7e6eb64894fdca13e688e6015fad5290d2a")
9303         (revision "1"))
9304     (package
9305       (name "sbcl-cl-cont")
9306       (version (git-version "0.3.8" revision commit))
9307       (source
9308        (origin
9309          (method git-fetch)
9310          (uri (git-reference
9311                (url "https://gitlab.common-lisp.net/cl-cont/cl-cont.git")
9312                (commit commit)))
9313          (file-name (git-file-name name version))
9314          (sha256
9315           (base32
9316            "1zf8zvb0i6jm3hhfks4w74hibm6avgc6f9s1qwgjrn2bcik8lrvz"))))
9317       (build-system asdf-build-system/sbcl)
9318       (inputs
9319        `(("alexandria" ,sbcl-alexandria)
9320          ("closer-mop" ,sbcl-closer-mop)))
9321       (native-inputs
9322        `(("rt" ,sbcl-rt)))
9323       (synopsis "Delimited continuations for Common Lisp")
9324       (description
9325        "This is a library that implements delimited continuations by
9326 transforming Common Lisp code to continuation passing style.")
9327       (home-page "https://common-lisp.net/project/cl-cont/")
9328       (license license:llgpl))))
9329
9330 (define-public cl-cont
9331   (sbcl-package->cl-source-package sbcl-cl-cont))
9332
9333 (define-public ecl-cl-cont
9334   (sbcl-package->ecl-package sbcl-cl-cont))
9335
9336 (define-public sbcl-cl-coroutine
9337   (let ((commit "de098f8d5debd8b14ef6864b5bdcbbf5ddbcfd72")
9338         (revision "1"))
9339     (package
9340       (name "sbcl-cl-coroutine")
9341       (version (git-version "0.1" revision commit))
9342       (source
9343        (origin
9344          (method git-fetch)
9345          (uri (git-reference
9346                (url "https://github.com/takagi/cl-coroutine.git")
9347                (commit commit)))
9348          (file-name (git-file-name name version))
9349          (sha256
9350           (base32
9351            "1cqdhdjxffgfs116l1swjlsmcbly0xgcgrckvaajd566idj9yj4l"))))
9352       (build-system asdf-build-system/sbcl)
9353       (inputs
9354        `(("alexandria" ,sbcl-alexandria)
9355          ("cl-cont" ,sbcl-cl-cont)))
9356       (native-inputs
9357        `(("prove" ,sbcl-prove)))
9358       (arguments
9359        `(;; TODO: Fix the tests. They fail with:
9360          ;; "Component CL-COROUTINE-ASD::CL-COROUTINE-TEST not found"
9361          #:tests? #f
9362          #:phases
9363          (modify-phases %standard-phases
9364            (add-after 'unpack 'fix-tests
9365              (lambda _
9366                (substitute* "cl-coroutine-test.asd"
9367                  (("cl-test-more")
9368                   "prove"))
9369                #t)))))
9370       (synopsis "Coroutine library for Common Lisp")
9371       (description
9372        "This is a coroutine library for Common Lisp implemented using the
9373 continuations of the @code{cl-cont} library.")
9374       (home-page "https://github.com/takagi/cl-coroutine")
9375       (license license:llgpl))))
9376
9377 (define-public cl-coroutine
9378   (sbcl-package->cl-source-package sbcl-cl-coroutine))
9379
9380 (define-public ecl-cl-coroutine
9381   (sbcl-package->ecl-package sbcl-cl-coroutine))
9382
9383 (define-public sbcl-vom
9384   (let ((commit "1aeafeb5b74c53741b79497e0ef4acf85c92ff24")
9385         (revision "1"))
9386     (package
9387       (name "sbcl-vom")
9388       (version (git-version "0.1.4" revision commit))
9389       (source
9390        (origin
9391          (method git-fetch)
9392          (uri (git-reference
9393                (url "https://github.com/orthecreedence/vom.git")
9394                (commit commit)))
9395          (file-name (git-file-name name version))
9396          (sha256
9397           (base32
9398            "0536kppj76ax4lrxhv42npkfjsmx45km2g439vf9jmw3apinz9cy"))))
9399       (build-system asdf-build-system/sbcl)
9400       (synopsis "Tiny logging utility for Common Lisp")
9401       (description
9402        "Vom is a logging library for Common Lisp.  It's goal is to be useful
9403 and small.  It does not provide a lot of features as other loggers do, but
9404 has a small codebase that's easy to understand and use.")
9405       (home-page "https://github.com/orthecreedence/vom")
9406       (license license:expat))))
9407
9408 (define-public cl-vom
9409   (sbcl-package->cl-source-package sbcl-vom))
9410
9411 (define-public ecl-vom
9412   (sbcl-package->ecl-package sbcl-vom))
9413
9414 (define-public sbcl-cl-libuv
9415   (let ((commit "32100c023c518038d0670a103eaa4d50dd785d29")
9416         (revision "1"))
9417     (package
9418       (name "sbcl-cl-libuv")
9419       (version (git-version "0.1.6" revision commit))
9420       (source
9421        (origin
9422          (method git-fetch)
9423          (uri (git-reference
9424                (url "https://github.com/orthecreedence/cl-libuv.git")
9425                (commit commit)))
9426          (file-name (git-file-name name version))
9427          (sha256
9428           (base32
9429            "1kwix4si8a8hza34ab2k7whrh7z0yrmx39v2wc3qblv9m244jkh1"))))
9430       (build-system asdf-build-system/sbcl)
9431       (inputs
9432        `(("alexandria" ,sbcl-alexandria)
9433          ("cffi" ,sbcl-cffi)
9434          ("cffi-grovel" ,sbcl-cffi-grovel)
9435          ("libuv" ,libuv)))
9436       (arguments
9437        `(#:phases
9438          (modify-phases %standard-phases
9439            (add-after 'unpack 'fix-paths
9440              (lambda* (#:key inputs #:allow-other-keys)
9441                (substitute* "lib.lisp"
9442                  (("/usr/lib/libuv.so")
9443                   (string-append (assoc-ref inputs "libuv")
9444                                  "/lib/libuv.so")))
9445                #t))
9446            (add-after 'fix-paths 'fix-system-definition
9447              (lambda _
9448                (substitute* "cl-libuv.asd"
9449                  (("#:cffi #:alexandria")
9450                   "#:cffi #:cffi-grovel #:alexandria"))
9451                #t)))))
9452       (synopsis "Common Lisp bindings to libuv")
9453       (description
9454        "This library provides low-level libuv bindings for Common Lisp.")
9455       (home-page "https://github.com/orthecreedence/cl-libuv")
9456       (license license:expat))))
9457
9458 (define-public cl-libuv
9459   (sbcl-package->cl-source-package sbcl-cl-libuv))
9460
9461 (define-public ecl-cl-libuv
9462   (sbcl-package->ecl-package sbcl-cl-libuv))
9463
9464 (define-public sbcl-cl-async-base
9465   (let ((commit "f6423e44404a44434d803605e0d2e17199158e28")
9466         (revision "1"))
9467     (package
9468       (name "sbcl-cl-async-base")
9469       (version (git-version "0.6.1" revision commit))
9470       (source
9471        (origin
9472          (method git-fetch)
9473          (uri (git-reference
9474                (url "https://github.com/orthecreedence/cl-async.git")
9475                (commit commit)))
9476          (file-name (git-file-name name version))
9477          (sha256
9478           (base32
9479            "11xi9dxb8mjgwzrkj88i0xkgk26z9w9ddxzbv6xsvfc1d4x5cf4x"))))
9480       (build-system asdf-build-system/sbcl)
9481       (inputs
9482        `(("bordeaux-threads" ,sbcl-bordeaux-threads)
9483          ("cffi" ,sbcl-cffi)
9484          ("cl-libuv" ,sbcl-cl-libuv)))
9485       (arguments
9486        `(#:asd-file "cl-async.asd"))
9487       (synopsis "Base system for cl-async")
9488       (description
9489        "Cl-async is a library for general purpose, non-blocking programming in
9490 Common Lisp.  It uses the libuv library as backend.")
9491       (home-page "https://orthecreedence.github.io/cl-async/")
9492       (license license:expat))))
9493
9494 (define-public cl-async-base
9495   (sbcl-package->cl-source-package sbcl-cl-async-base))
9496
9497 (define-public ecl-cl-async-base
9498   (sbcl-package->ecl-package sbcl-cl-async-base))
9499
9500 (define-public sbcl-cl-async-util
9501   (package
9502     (inherit sbcl-cl-async-base)
9503     (name "sbcl-cl-async-util")
9504     (inputs
9505      `(("bordeaux-threads" ,sbcl-bordeaux-threads)
9506        ("cffi" ,sbcl-cffi)
9507        ("cl-async-base" ,sbcl-cl-async-base)
9508        ("cl-libuv" ,sbcl-cl-libuv)
9509        ("cl-ppcre" ,sbcl-cl-ppcre)
9510        ("fast-io" ,sbcl-fast-io)
9511        ("vom" ,sbcl-vom)))
9512     (synopsis "Internal utilities for cl-async")))
9513
9514 (define-public cl-async-util
9515   (sbcl-package->cl-source-package sbcl-cl-async-util))
9516
9517 (define-public ecl-cl-async-util
9518   (sbcl-package->ecl-package sbcl-cl-async-util))
9519
9520 (define-public sbcl-cl-async
9521   (package
9522     (inherit sbcl-cl-async-base)
9523     (name "sbcl-cl-async")
9524     (inputs
9525      `(("babel" ,sbcl-babel)
9526        ("cffi" ,sbcl-cffi)
9527        ("cl-async-base" ,sbcl-cl-async-base)
9528        ("cl-async-util" ,sbcl-cl-async-util)
9529        ("cl-libuv" ,sbcl-cl-libuv)
9530        ("cl-ppcre" ,sbcl-cl-ppcre)
9531        ("static-vectors" ,sbcl-static-vectors)
9532        ("trivial-features" ,sbcl-trivial-features)
9533        ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
9534     (synopsis "Asynchronous operations for Common Lisp")))
9535
9536 (define-public cl-async
9537   (sbcl-package->cl-source-package sbcl-cl-async))
9538
9539 (define-public ecl-cl-async
9540   (sbcl-package->ecl-package sbcl-cl-async))
9541
9542 (define-public sbcl-cl-async-repl
9543   (package
9544     (inherit sbcl-cl-async-base)
9545     (name "sbcl-cl-async-repl")
9546     (inputs
9547      `(("bordeaux-threads" ,sbcl-bordeaux-threads)
9548        ("cl-async" ,sbcl-cl-async)))
9549     (arguments
9550      (substitute-keyword-arguments (package-arguments sbcl-cl-async-base)
9551        ((#:asd-file _ "") "cl-async-repl.asd")))
9552     (synopsis "REPL integration for cl-async")))
9553
9554 (define-public cl-async-repl
9555   (sbcl-package->cl-source-package sbcl-cl-async-repl))
9556
9557 (define-public ecl-cl-async-repl
9558   (sbcl-package->ecl-package sbcl-cl-async-repl))
9559
9560 (define-public sbcl-cl-async-ssl
9561   (package
9562     (inherit sbcl-cl-async-base)
9563     (name "sbcl-cl-async-ssl")
9564     (inputs
9565      `(("cffi" ,sbcl-cffi)
9566        ("cl-async" ,sbcl-cl-async)
9567        ("openssl" ,openssl)
9568        ("vom" ,sbcl-vom)))
9569     (arguments
9570      (substitute-keyword-arguments (package-arguments sbcl-cl-async-base)
9571        ((#:asd-file _ "") "cl-async-ssl.asd")
9572        ((#:phases phases '%standard-phases)
9573         `(modify-phases ,phases
9574            (add-after 'unpack 'fix-paths
9575              (lambda* (#:key inputs #:allow-other-keys)
9576                (substitute* "src/ssl/package.lisp"
9577                  (("libcrypto\\.so")
9578                   (string-append (assoc-ref inputs "openssl")
9579                                  "/lib/libcrypto.so"))
9580                  (("libssl\\.so")
9581                   (string-append (assoc-ref inputs "openssl")
9582                                  "/lib/libssl.so")))
9583                #t))))))
9584     (synopsis "SSL wrapper around cl-async socket implementation")))
9585
9586 (define-public cl-async-ssl
9587   (sbcl-package->cl-source-package sbcl-cl-async-ssl))
9588
9589 (define-public ecl-cl-async-ssl
9590   (sbcl-package->ecl-package sbcl-cl-async-ssl))
9591
9592 (define-public sbcl-blackbird
9593   (let ((commit "d361f81c1411dec07f6c2dcb11c78f7aea9aaca8")
9594         (revision "1"))
9595     (package
9596       (name "sbcl-blackbird")
9597       (version (git-version "0.5.2" revision commit))
9598       (source
9599        (origin
9600          (method git-fetch)
9601          (uri (git-reference
9602                (url "https://github.com/orthecreedence/blackbird.git")
9603                (commit commit)))
9604          (file-name (git-file-name name version))
9605          (sha256
9606           (base32
9607            "0xfds5yaya64arzr7w1x38karyz11swzbhxx1afldpradj9dh19c"))))
9608       (build-system asdf-build-system/sbcl)
9609       (inputs
9610        `(("vom" ,sbcl-vom)))
9611       (native-inputs
9612        `(("cl-async" ,sbcl-cl-async)
9613          ("fiveam" ,sbcl-fiveam)))
9614       (synopsis "Promise implementation for Common Lisp")
9615       (description
9616        "This is a standalone promise implementation for Common Lisp.  It is
9617 the successor to the now-deprecated cl-async-future project.")
9618       (home-page "http://orthecreedence.github.io/blackbird/")
9619       (license license:expat))))
9620
9621 (define-public cl-blackbird
9622   (sbcl-package->cl-source-package sbcl-blackbird))
9623
9624 (define-public ecl-blackbird
9625   (sbcl-package->ecl-package sbcl-blackbird))
9626
9627 (define-public sbcl-cl-async-future
9628   (let ((commit "ee36c22a69a9516407458d2ed8b475f1fc473959")
9629         (revision "1"))
9630     (package
9631       (name "sbcl-cl-async-future")
9632       (version (git-version "0.4.4.1" revision commit))
9633       (source
9634        (origin
9635          (method git-fetch)
9636          (uri (git-reference
9637                (url "https://github.com/orthecreedence/cl-async-future.git")
9638                (commit commit)))
9639          (file-name (git-file-name name version))
9640          (sha256
9641           (base32
9642            "0z0sc7qlzzxk99f4l26zp6rai9kv0kj0f599sxai5s44p17zbbvh"))))
9643       (build-system asdf-build-system/sbcl)
9644       (inputs
9645        `(("blackbird" ,sbcl-blackbird)))
9646       (native-inputs
9647        `(("cl-async" ,sbcl-cl-async)
9648          ("eos" ,sbcl-eos)))
9649       (synopsis "Futures implementation for Common Lisp")
9650       (description
9651        "This is futures implementation for Common Lisp.  It plugs in nicely
9652 to cl-async.")
9653       (home-page "http://orthecreedence.github.io/cl-async/future")
9654       (license license:expat))))
9655
9656 (define-public cl-async-future
9657   (sbcl-package->cl-source-package sbcl-cl-async-future))
9658
9659 (define-public ecl-cl-async-future
9660   (sbcl-package->ecl-package sbcl-cl-async-future))
9661
9662 (define-public sbcl-green-threads
9663   (let ((commit "fff5ebecb441a37e5c511773716aafd84a3c5840")
9664         (revision "1"))
9665     (package
9666       (name "sbcl-green-threads")
9667       (version (git-version "0.3" revision commit))
9668       (source
9669        (origin
9670          (method git-fetch)
9671          (uri (git-reference
9672                (url "https://github.com/thezerobit/green-threads.git")
9673                (commit commit)))
9674          (file-name (git-file-name name version))
9675          (sha256
9676           (base32
9677            "1czw7nr0dwfps76h8hjvglk1wdh53yqbfbvv30whwbgqx33iippz"))))
9678       (build-system asdf-build-system/sbcl)
9679       (inputs
9680        `(("cl-async-future" ,sbcl-cl-async-future)
9681          ("cl-cont" ,sbcl-cl-cont)))
9682       (native-inputs
9683        `(("prove" ,sbcl-prove)))
9684       (arguments
9685        `(;; TODO: Fix the tests. They fail with:
9686          ;; "The function BLACKBIRD::PROMISE-VALUES is undefined"
9687          #:tests? #f
9688          #:phases
9689          (modify-phases %standard-phases
9690            (add-after 'unpack 'fix-tests
9691              (lambda _
9692                (substitute* "green-threads-test.asd"
9693                  (("cl-test-more")
9694                   "prove"))
9695                #t)))))
9696       (synopsis "Cooperative multitasking library for Common Lisp")
9697       (description
9698        "This library allows for cooperative multitasking with help of cl-cont
9699 for continuations.  It tries to mimic the API of bordeaux-threads as much as
9700 possible.")
9701       (home-page "https://github.com/thezerobit/green-threads")
9702       (license license:bsd-3))))
9703
9704 (define-public cl-green-threads
9705   (sbcl-package->cl-source-package sbcl-green-threads))
9706
9707 (define-public ecl-green-threads
9708   (sbcl-package->ecl-package sbcl-green-threads))
9709
9710 (define-public sbcl-cl-base32
9711   (let ((commit "8cdee06fab397f7b0a19583b57e7f0c98405be85")
9712         (revision "1"))
9713     (package
9714       (name "sbcl-cl-base32")
9715       (version (git-version "0.1" revision commit))
9716       (source
9717        (origin
9718          (method git-fetch)
9719          (uri (git-reference
9720                (url "https://github.com/hargettp/cl-base32.git")
9721                (commit commit)))
9722          (file-name (git-file-name name version))
9723          (sha256
9724           (base32 "17jrng8jb05d64ggyd11hp308c2fl5drvf9g175blgrkkl8l4mf8"))))
9725       (build-system asdf-build-system/sbcl)
9726       (native-inputs
9727        `(("lisp-unit" ,sbcl-lisp-unit)))
9728       (synopsis "Common Lisp library for base32 encoding and decoding")
9729       (description
9730        "This package provides functions for base32 encoding and decoding as
9731 defined in RFC4648.")
9732       (home-page "https://github.com/hargettp/cl-base32")
9733       (license license:expat))))
9734
9735 (define-public cl-base32
9736   (sbcl-package->cl-source-package sbcl-cl-base32))
9737
9738 (define-public ecl-cl-base32
9739   (sbcl-package->ecl-package sbcl-cl-base32))
9740
9741 (define-public sbcl-cl-z85
9742   (let ((commit "85b3951a9cfa2603acb6aee15567684f9a108098")
9743         (revision "1"))
9744     (package
9745       (name "sbcl-cl-z85")
9746       (version (git-version "1.0" revision commit))
9747       (source
9748        (origin
9749          (method git-fetch)
9750          (uri (git-reference
9751                (url "https://github.com/glv2/cl-z85.git")
9752                (commit commit)))
9753          (file-name (git-file-name name version))
9754          (sha256
9755           (base32 "0r27pidjaxbm7k1rr90nnajwl5xm2kp65g1fv0fva17lzy45z1mp"))))
9756       (build-system asdf-build-system/sbcl)
9757       (native-inputs
9758        `(("cl-octet-streams" ,sbcl-cl-octet-streams)
9759          ("fiveam" ,sbcl-fiveam)))
9760       (synopsis "Common Lisp library for Z85 encoding and decoding")
9761       (description
9762        "This package provides functions to encode or decode byte vectors or
9763 byte streams using the Z85 format, which is a base-85 encoding used by
9764 ZeroMQ.")
9765       (home-page "https://github.com/glv2/cl-z85")
9766       (license license:gpl3+))))
9767
9768 (define-public cl-z85
9769   (sbcl-package->cl-source-package sbcl-cl-z85))
9770
9771 (define-public ecl-cl-z85
9772   (sbcl-package->ecl-package sbcl-cl-z85))
9773
9774 (define-public sbcl-ltk
9775   (package
9776     (name "sbcl-ltk")
9777     (version "0.992")
9778     (source
9779      (origin
9780        (method git-fetch)
9781        (uri (git-reference
9782              (url "https://github.com/herth/ltk.git")
9783              (commit version)))
9784        (file-name (git-file-name name version))
9785        (sha256
9786         (base32 "13l2q4mskzilya9xh5wy2xvy30lwn104bd8wrq6ifds56r82iy3x"))))
9787     (build-system asdf-build-system/sbcl)
9788     (inputs
9789      `(("imagemagick" ,imagemagick)
9790        ("tk" ,tk)))
9791     (arguments
9792      `(#:asd-file "ltk/ltk.asd"
9793        #:tests? #f
9794        #:phases (modify-phases %standard-phases
9795                   (add-after 'unpack 'fix-paths
9796                     (lambda* (#:key inputs #:allow-other-keys)
9797                       (substitute* "ltk/ltk.lisp"
9798                         (("#-freebsd \"wish\"")
9799                          (string-append "#-freebsd \""
9800                                         (assoc-ref inputs "tk")
9801                                         "/bin/wish\""))
9802                         (("do-execute \"convert\"")
9803                          (string-append "do-execute \""
9804                                         (assoc-ref inputs "imagemagick")
9805                                         "/bin/convert\"")))
9806                       #t)))))
9807     (synopsis "Common Lisp bindings for the Tk GUI toolkit")
9808     (description
9809      "LTK is a Common Lisp binding for the Tk graphics toolkit.  It is written
9810 in pure Common Lisp and does not require any Tk knowledge for its usage.")
9811     (home-page "http://www.peter-herth.de/ltk/")
9812     (license license:llgpl)))
9813
9814 (define-public cl-ltk
9815   (sbcl-package->cl-source-package sbcl-ltk))
9816
9817 (define-public ecl-ltk
9818   (sbcl-package->ecl-package sbcl-ltk))
9819
9820 (define-public sbcl-ltk-mw
9821   (package
9822     (inherit sbcl-ltk)
9823     (name "sbcl-ltk-mw")
9824     (inputs
9825      `(("ltk" ,sbcl-ltk)))
9826     (arguments
9827      (substitute-keyword-arguments (package-arguments sbcl-ltk)
9828        ((#:asd-file _) "ltk/ltk-mw.asd")
9829        ((#:phases _) '%standard-phases)))
9830     (synopsis "Extra widgets for LTK")
9831     (description
9832      "This is a collection of higher-level widgets built on top of LTK.")))
9833
9834 (define-public cl-ltk-mw
9835   (sbcl-package->cl-source-package sbcl-ltk-mw))
9836
9837 (define-public ecl-ltk-mw
9838   (sbcl-package->ecl-package sbcl-ltk-mw))
9839
9840 (define-public sbcl-ltk-remote
9841   (package
9842     (inherit sbcl-ltk)
9843     (name "sbcl-ltk-remote")
9844     (inputs
9845      `(("ltk" ,sbcl-ltk)))
9846     (arguments
9847      (substitute-keyword-arguments (package-arguments sbcl-ltk)
9848        ((#:asd-file _) "ltk/ltk-remote.asd")
9849        ((#:phases _) '%standard-phases)))
9850     (synopsis "Remote GUI support for LTK")
9851     (description
9852      "This LTK extension allows the GUI to be displayed on a computer different
9853 from the one running the Lisp program by using a TCP connection.")))
9854
9855 (define-public cl-ltk-remote
9856   (sbcl-package->cl-source-package sbcl-ltk-remote))
9857
9858 (define-public sbcl-cl-lex
9859   (let ((commit "f2dbbe25ef553005fb402d9a6203180c3fa1093b")
9860         (revision "1"))
9861     (package
9862       (name "sbcl-cl-lex")
9863       (version (git-version "1.1.3" revision commit))
9864       (source
9865        (origin
9866          (method git-fetch)
9867          (uri (git-reference
9868                (url "https://github.com/djr7C4/cl-lex.git")
9869                (commit commit)))
9870          (file-name (git-file-name name version))
9871          (sha256
9872           (base32 "1kg50f76bfpfxcv4dfivq1n9a0xlsra2ajb0vd68lxwgbidgyc2y"))))
9873       (build-system asdf-build-system/sbcl)
9874       (inputs
9875        `(("cl-ppcre" ,sbcl-cl-ppcre)))
9876       (synopsis "Common Lisp macros for generating lexical analyzers")
9877       (description
9878        "This is a Common Lisp library providing a set of macros for generating
9879 lexical analyzers automatically.  The lexers generated using @code{cl-lex} can
9880 be used with @code{cl-yacc}.")
9881       (home-page "https://github.com/djr7C4/cl-lex")
9882       (license license:gpl3))))
9883
9884 (define-public cl-lex
9885   (sbcl-package->cl-source-package sbcl-cl-lex))
9886
9887 (define-public ecl-cl-lex
9888   (sbcl-package->ecl-package sbcl-cl-lex))
9889
9890 (define-public sbcl-clunit2
9891   (let ((commit "5e28343734eb9b7aee39306a614af92c1062d50b")
9892         (revision "1"))
9893     (package
9894       (name "sbcl-clunit2")
9895       (version (git-version "0.2.4" revision commit))
9896       (source
9897        (origin
9898          (method git-fetch)
9899          (uri (git-reference
9900                (url "https://notabug.org/cage/clunit2.git")
9901                (commit commit)))
9902          (file-name (git-file-name name version))
9903          (sha256
9904           (base32 "1ngiapfki6nm8a555mzhb5p7ch79i3w665za5bmb5j7q34fy80vw"))))
9905       (build-system asdf-build-system/sbcl)
9906       (synopsis "Unit testing framework for Common Lisp")
9907       (description
9908        "CLUnit is a Common Lisp unit testing framework.  It is designed to be
9909 easy to use so that you can quickly start testing.")
9910       (home-page "https://notabug.org/cage/clunit2")
9911       (license license:expat))))
9912
9913 (define-public cl-clunit2
9914   (sbcl-package->cl-source-package sbcl-clunit2))
9915
9916 (define-public ecl-clunit2
9917   (sbcl-package->ecl-package sbcl-clunit2))
9918
9919 (define-public sbcl-cl-colors2
9920   (let ((commit "795aedee593b095fecde574bd999b520dd03ed24")
9921         (revision "1"))
9922     (package
9923       (name "sbcl-cl-colors2")
9924       (version (git-version "0.2.1" revision commit))
9925       (source
9926        (origin
9927          (method git-fetch)
9928          (uri (git-reference
9929                (url "https://notabug.org/cage/cl-colors2.git")
9930                (commit commit)))
9931          (file-name (git-file-name name version))
9932          (sha256
9933           (base32 "0hlyf4h5chkjdp9armla5w4kw5acikk159sym7y8c4jbjp9x47ih"))))
9934       (build-system asdf-build-system/sbcl)
9935       (native-inputs
9936        `(("clunit2" ,sbcl-clunit2)))
9937       (inputs
9938        `(("alexandria" ,sbcl-alexandria)
9939          ("cl-ppcre" ,sbcl-cl-ppcre)))
9940       (synopsis "Color library for Common Lisp")
9941       (description
9942        "This is a very simple color library for Common Lisp, providing:
9943
9944 @itemize
9945 @item Types for representing colors in HSV and RGB spaces.
9946 @item Simple conversion functions between the above types (and also
9947 hexadecimal representation for RGB).
9948 @item Some predefined colors (currently X11 color names -- of course
9949 the library does not depend on X11).
9950 @end itemize\n")
9951       (home-page "https://notabug.org/cage/cl-colors2")
9952       (license license:boost1.0))))
9953
9954 (define-public cl-colors2
9955   (sbcl-package->cl-source-package sbcl-cl-colors2))
9956
9957 (define-public ecl-cl-colors2
9958   (sbcl-package->ecl-package sbcl-cl-colors2))
9959
9960 (define-public sbcl-cl-jpeg
9961   (let ((commit "ec557038128df6895fbfb743bfe8faf8ec2534af")
9962         (revision "1"))
9963     (package
9964       (name "sbcl-cl-jpeg")
9965       (version (git-version "2.8" revision commit))
9966       (source
9967        (origin
9968          (method git-fetch)
9969          (uri (git-reference
9970                (url "https://github.com/sharplispers/cl-jpeg.git")
9971                (commit commit)))
9972          (file-name (git-file-name name version))
9973          (sha256
9974           (base32 "1bkkiqz8fqldlj1wbmrccjsvxcwj98h6s4b6gslr3cg2wmdv5xmy"))))
9975       (build-system asdf-build-system/sbcl)
9976       (synopsis "JPEG image library for Common Lisp")
9977       (description
9978        "This is a baseline JPEG codec written in Common Lisp.  It can be used
9979 for reading and writing JPEG image files.")
9980       (home-page "https://github.com/sharplispers/cl-jpeg")
9981       (license license:bsd-3))))
9982
9983 (define-public cl-jpeg
9984   (sbcl-package->cl-source-package sbcl-cl-jpeg))
9985
9986 (define-public ecl-cl-jpeg
9987   (sbcl-package->ecl-package sbcl-cl-jpeg))
9988
9989 (define-public sbcl-nodgui
9990   (let ((commit "bc59ed9b787dfc9e68ae3bd7f7e8507c5c619212")
9991         (revision "1"))
9992     (package
9993       (name "sbcl-nodgui")
9994       (version (git-version "0.0.5" revision commit))
9995       (source
9996        (origin
9997          (method git-fetch)
9998          (uri (git-reference
9999                (url "https://notabug.org/cage/nodgui.git")
10000                (commit commit)))
10001          (file-name (git-file-name name version))
10002          (sha256
10003           (base32 "0xx0dk54d882i598ydnwmy7mnfk0b7vib3ddsgpqxhjck1rwq8l8"))))
10004       (build-system asdf-build-system/sbcl)
10005       (inputs
10006        `(("alexandria" ,sbcl-alexandria)
10007          ("bordeaux-threads" ,sbcl-bordeaux-threads)
10008          ("cl-colors2" ,sbcl-cl-colors2)
10009          ("cl-jpeg" ,sbcl-cl-jpeg)
10010          ("cl-lex" ,sbcl-cl-lex)
10011          ("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)
10012          ("cl-unicode" ,sbcl-cl-unicode)
10013          ("cl-yacc" ,sbcl-cl-yacc)
10014          ("clunit2" ,sbcl-clunit2)
10015          ("named-readtables" ,sbcl-named-readtables)
10016          ("parse-number" ,sbcl-parse-number)
10017          ("tk" ,tk)))
10018       (arguments
10019        `(#:phases (modify-phases %standard-phases
10020                     (add-after 'unpack 'fix-paths
10021                       (lambda* (#:key inputs #:allow-other-keys)
10022                         (substitute* "src/wish-communication.lisp"
10023                           (("#-freebsd \"wish\"")
10024                            (string-append "#-freebsd \""
10025                                           (assoc-ref inputs "tk")
10026                                           "/bin/wish\"")))
10027                         #t)))))
10028       (synopsis "Common Lisp bindings for the Tk GUI toolkit")
10029       (description
10030        "Nodgui (@emph{No Drama GUI}) is a Common Lisp binding for the Tk GUI
10031 toolkit.  It also provides a few additional widgets more than the standard Tk
10032 ones.")
10033       (home-page "https://www.autistici.org/interzona/nodgui.html")
10034       (license license:llgpl))))
10035
10036 (define-public cl-nodgui
10037   (sbcl-package->cl-source-package sbcl-nodgui))
10038
10039 (define-public ecl-nodgui
10040   (sbcl-package->ecl-package sbcl-nodgui))
10041
10042 (define-public sbcl-salza2
10043   (package
10044     (name "sbcl-salza2")
10045     (version "2.0.9")
10046     (source
10047      (origin
10048        (method git-fetch)
10049        (uri (git-reference
10050              (url "https://github.com/xach/salza2.git")
10051              (commit (string-append "release-" version))))
10052        (file-name (git-file-name name version))
10053        (sha256
10054         (base32 "0p38rj4gq7j5k807php7hrz7l2zyyfshv8i9yms7i8lkgg3433ki"))))
10055     (build-system asdf-build-system/sbcl)
10056     (synopsis "Common Lisp library for zlib, deflate and gzip compression")
10057     (description
10058      "Salza2 is a Common Lisp library for creating compressed data in the zlib,
10059 deflate, or gzip data formats, described in RFC 1950, RFC 1951, and RFC 1952,
10060 respectively.")
10061     (home-page "https://www.xach.com/lisp/salza2/")
10062     (license license:bsd-2)))
10063
10064 (define-public cl-salza2
10065   (sbcl-package->cl-source-package sbcl-salza2))
10066
10067 (define-public ecl-salza2
10068   (sbcl-package->ecl-package sbcl-salza2))
10069
10070 (define-public sbcl-png-read
10071   (let ((commit "ec29f38a689972b9f1373f13bbbcd6b05deada88")
10072         (revision "1"))
10073     (package
10074       (name "sbcl-png-read")
10075       (version (git-version "0.3.1" revision commit))
10076       (source
10077        (origin
10078          (method git-fetch)
10079          (uri (git-reference
10080                (url "https://github.com/Ramarren/png-read.git")
10081                (commit commit)))
10082          (file-name (git-file-name name version))
10083          (sha256
10084           (base32 "0vyczbcwskrygrf1hgrsnk0jil8skmvf1kiaalw5jps4fjrfdkw0"))))
10085       (build-system asdf-build-system/sbcl)
10086       (inputs
10087        `(("babel" ,sbcl-babel)
10088          ("chipz" ,sbcl-chipz)
10089          ("iterate" ,sbcl-iterate)))
10090       (synopsis "PNG decoder for Common Lisp")
10091       (description "This is a Common Lisp library for reading PNG images.")
10092       (home-page "https://github.com/Ramarren/png-read")
10093       (license license:bsd-3))))
10094
10095 (define-public cl-png-read
10096   (sbcl-package->cl-source-package sbcl-png-read))
10097
10098 (define-public ecl-png-read
10099   (sbcl-package->ecl-package sbcl-png-read))
10100
10101 (define-public sbcl-zpng
10102   (package
10103     (name "sbcl-zpng")
10104     (version "1.2.2")
10105     (source
10106      (origin
10107        (method git-fetch)
10108        (uri (git-reference
10109              (url "https://github.com/xach/zpng.git")
10110              (commit (string-append "release-" version))))
10111        (file-name (git-file-name name version))
10112        (sha256
10113         (base32 "0b3ag3jhl3z7kdls3ahdsdxsfhhw5qrizk769984f4wkxhb69rcm"))))
10114     (build-system asdf-build-system/sbcl)
10115     (inputs
10116      `(("salza2" ,sbcl-salza2)))
10117     (synopsis "PNG encoder for Common Lisp")
10118     (description "This is a Common Lisp library for creating PNG images.")
10119     (home-page "https://www.xach.com/lisp/zpng/")
10120     (license license:bsd-2)))
10121
10122 (define-public cl-zpng
10123   (sbcl-package->cl-source-package sbcl-zpng))
10124
10125 (define-public ecl-zpng
10126   (sbcl-package->ecl-package sbcl-zpng))
10127
10128 (define-public sbcl-cl-qrencode
10129   (package
10130     (name "sbcl-cl-qrencode")
10131     (version "0.1.2")
10132     (source
10133      (origin
10134        (method git-fetch)
10135        (uri (git-reference
10136              (url "https://github.com/jnjcc/cl-qrencode.git")
10137              (commit (string-append "v" version))))
10138        (file-name (git-file-name name version))
10139        (sha256
10140         (base32 "1l5k131dchbf6cj8a8xqa731790p01p3qa1kdy2wa9dawy3ymkxr"))))
10141     (build-system asdf-build-system/sbcl)
10142     (native-inputs
10143      `(("lisp-unit" ,sbcl-lisp-unit)))
10144     (inputs
10145      `(("zpng" ,sbcl-zpng)))
10146     (synopsis "QR code encoder for Common Lisp")
10147     (description
10148      "This Common Lisp library provides function to make QR codes and to save
10149 them as PNG files.")
10150     (home-page "https://github.com/jnjcc/cl-qrencode")
10151     (license license:gpl2+)))
10152
10153 (define-public cl-qrencode
10154   (sbcl-package->cl-source-package sbcl-cl-qrencode))
10155
10156 (define-public ecl-cl-qrencode
10157   (sbcl-package->ecl-package sbcl-cl-qrencode))