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 ;;; Copyright © 2020 Konrad Hinsen <konrad.hinsen@fastmail.net>
  20 ;;;
  21 ;;; This file is part of GNU Guix.
  22 ;;;
  23 ;;; GNU Guix is free software; you can redistribute it and/or modify it
  24 ;;; under the terms of the GNU General Public License as published by
  25 ;;; the Free Software Foundation; either version 3 of the License, or (at
  26 ;;; your option) any later version.
  27 ;;;
  28 ;;; GNU Guix is distributed in the hope that it will be useful, but
  29 ;;; WITHOUT ANY WARRANTY; without even the implied warranty of
  30 ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  31 ;;; GNU General Public License for more details.
  32 ;;;
  33 ;;; You should have received a copy of the GNU General Public License
  34 ;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.
  35
  36 ;;; This file only contains Common Lisp libraries.
  37 ;;; Common Lisp compilers and tooling go to lisp.scm.
  38 ;;; Common Lisp applications should go to the most appropriate file,
  39 ;;; e.g. StumpWM is in wm.scm.
  40
  41 (define-module (gnu packages lisp-xyz)
  42   #:use-module (gnu packages)
  43   #:use-module ((guix licenses) #:prefix license:)
  44   #:use-module (guix packages)
  45   #:use-module (guix download)
  46   #:use-module (guix git-download)
  47   #:use-module (guix hg-download)
  48   #:use-module (guix utils)
  49   #:use-module (guix build-system asdf)
  50   #:use-module (guix build-system trivial)
  51   #:use-module (gnu packages c)
  52   #:use-module (gnu packages compression)
  53   #:use-module (gnu packages glib)
  54   #:use-module (gnu packages gtk)
  55   #:use-module (gnu packages imagemagick)
  56   #:use-module (gnu packages libevent)
  57   #:use-module (gnu packages libffi)
  58   #:use-module (gnu packages lisp)
  59   #:use-module (gnu packages maths)
  60   #:use-module (gnu packages pkg-config)
  61   #:use-module (gnu packages python)
  62   #:use-module (gnu packages python-xyz)
  63   #:use-module (gnu packages sqlite)
  64   #:use-module (gnu packages tcl)
  65   #:use-module (gnu packages tls)
  66   #:use-module (gnu packages webkit)
  67   #:use-module (gnu packages xdisorg)
  68   #:use-module (ice-9 match)
  69   #:use-module (srfi srfi-19))
  70
  71 (define-public sbcl-alexandria
  72   (let ((revision "1")
  73         (commit "3b849bc0116ea70f215ee6b2fbf354e862aaa9dd"))
  74     (package
  75       (name "sbcl-alexandria")
  76       (version (git-version "1.0.0" revision commit))
  77       (source
  78        (origin
  79          (method git-fetch)
  80          (uri (git-reference
  81                (url "https://gitlab.common-lisp.net/alexandria/alexandria.git")
  82                (commit commit)))
  83          (sha256
  84           (base32
  85            "04amwvx2vl691f0plcfbqqwxgib9zimih7jrn5zl7mbwvrxy022b"))
  86          (file-name (git-file-name name version))))
  87       (build-system asdf-build-system/sbcl)
  88       (native-inputs
  89        `(("rt" ,sbcl-rt)))
  90       (synopsis "Collection of portable utilities for Common Lisp")
  91       (description
  92        "Alexandria is a collection of portable utilities.  It does not contain
  93 conceptual extensions to Common Lisp.  It is conservative in scope, and
  94 portable between implementations.")
  95       (home-page "https://common-lisp.net/project/alexandria/")
  96       (license license:public-domain))))
  97
  98 (define-public cl-alexandria
  99   (sbcl-package->cl-source-package sbcl-alexandria))
 100
 101 (define-public ecl-alexandria
 102   (sbcl-package->ecl-package sbcl-alexandria))
 103
 104 (define-public sbcl-net.didierverna.asdf-flv
 105   (package
 106     (name "sbcl-net.didierverna.asdf-flv")
 107     (version "2.1")
 108     (source
 109      (origin
 110        (method git-fetch)
 111        (uri (git-reference
 112              (url "https://github.com/didierverna/asdf-flv")
 113              (commit (string-append "version-" version))))
 114        (file-name (git-file-name "asdf-flv" version))
 115        (sha256
 116         (base32 "1fi2y4baxan103jbg4idjddzihy03kwnj2mzbwrknw4d4x7xlgwj"))))
 117     (build-system asdf-build-system/sbcl)
 118     (synopsis "Common Lisp ASDF extension to provide support for file-local variables")
 119     (description "ASDF-FLV provides support for file-local variables through
 120 ASDF.  A file-local variable behaves like @code{*PACKAGE*} and
 121 @code{*READTABLE*} with respect to @code{LOAD} and @code{COMPILE-FILE}: a new
 122 dynamic binding is created before processing the file, so that any
 123 modification to the variable becomes essentially file-local.
 124
 125 In order to make one or several variables file-local, use the macros
 126 @code{SET-FILE-LOCAL-VARIABLE(S)}.")
 127     (home-page "https://www.lrde.epita.fr/~didier/software/lisp/misc.php#asdf-flv")
 128     (license (license:non-copyleft
 129               "https://www.gnu.org/prep/maintain/html_node/License-Notices-for-Other-Files.html"
 130               "GNU All-Permissive License"))))
 131
 132 (define-public cl-net.didierverna.asdf-flv
 133   (sbcl-package->cl-source-package sbcl-net.didierverna.asdf-flv))
 134
 135 (define-public ecl-net.didierverna.asdf-flv
 136   (sbcl-package->ecl-package sbcl-net.didierverna.asdf-flv))
 137
 138 (define-public sbcl-fiveam
 139   (package
 140     (name "sbcl-fiveam")
 141     (version "1.4.1")
 142     (source
 143      (origin
 144        (method git-fetch)
 145        (uri (git-reference
 146              (url "https://github.com/sionescu/fiveam.git")
 147              (commit (string-append "v" version))))
 148        (file-name (git-file-name "fiveam" version))
 149        (sha256
 150         (base32 "1q3d38pwafnwnw42clq0f8g5xw7pbzr287jl9jsqmb1vb0n1vrli"))))
 151     (inputs
 152      `(("alexandria" ,sbcl-alexandria)
 153        ("net.didierverna.asdf-flv" ,sbcl-net.didierverna.asdf-flv)
 154        ("trivial-backtrace" ,sbcl-trivial-backtrace)))
 155     (build-system asdf-build-system/sbcl)
 156     (synopsis "Common Lisp testing framework")
 157     (description "FiveAM is a simple (as far as writing and running tests
 158 goes) regression testing framework.  It has been designed with Common Lisp's
 159 interactive development model in mind.")
 160     (home-page "https://common-lisp.net/project/fiveam/")
 161     (license license:bsd-3)))
 162
 163 (define-public cl-fiveam
 164   (sbcl-package->cl-source-package sbcl-fiveam))
 165
 166 (define-public ecl-fiveam
 167   (sbcl-package->ecl-package sbcl-fiveam))
 168
 169 (define-public sbcl-bordeaux-threads
 170   (package
 171     (name "sbcl-bordeaux-threads")
 172     (version "0.8.7")
 173     (source (origin
 174               (method git-fetch)
 175               (uri (git-reference
 176                     (url "https://github.com/sionescu/bordeaux-threads.git")
 177                     (commit (string-append "v" version))))
 178               (sha256
 179                (base32 "1whpfmyxp2fsw6viqj45fqgsifgr534c575bfh5vaqw5m84b6alp"))
 180               (file-name
 181                (git-file-name "bordeaux-threads" version))))
 182     (inputs `(("alexandria" ,sbcl-alexandria)))
 183     (native-inputs `(("fiveam" ,sbcl-fiveam)))
 184     (build-system asdf-build-system/sbcl)
 185     (synopsis "Portable shared-state concurrency library for Common Lisp")
 186     (description "BORDEAUX-THREADS is a proposed standard for a minimal
 187 MP/Threading interface.  It is similar to the CLIM-SYS threading and lock
 188 support.")
 189     (home-page "https://common-lisp.net/project/bordeaux-threads/")
 190     (license license:x11)))
 191
 192 (define-public cl-bordeaux-threads
 193   (sbcl-package->cl-source-package sbcl-bordeaux-threads))
 194
 195 (define-public ecl-bordeaux-threads
 196   (sbcl-package->ecl-package sbcl-bordeaux-threads))
 197
 198 (define-public sbcl-trivial-gray-streams
 199   (let ((revision "1")
 200         (commit "0483ade330508b4b2edeabdb47d16ec9437ee1cb"))
 201     (package
 202       (name "sbcl-trivial-gray-streams")
 203       (version (string-append "0.0.0-" revision "." (string-take commit 7)))
 204       (source
 205        (origin
 206          (method git-fetch)
 207          (uri
 208           (git-reference
 209            (url "https://github.com/trivial-gray-streams/trivial-gray-streams.git")
 210            (commit commit)))
 211          (sha256
 212           (base32 "0m3rpf2x0zmdk3nf1qfa01j6a55vj7gkwhyw78qslcgbjlgh8p4d"))
 213          (file-name
 214           (string-append "trivial-gray-streams-" version "-checkout"))))
 215       (build-system asdf-build-system/sbcl)
 216       (synopsis "Compatibility layer for Gray streams implementations")
 217       (description "Gray streams is an interface proposed for inclusion with
 218 ANSI CL by David N. Gray.  The proposal did not make it into ANSI CL, but most
 219 popular CL implementations implement it.  This package provides an extremely
 220 thin compatibility layer for gray streams.")
 221       (home-page "http://www.cliki.net/trivial-gray-streams")
 222       (license license:x11))))
 223
 224 (define-public cl-trivial-gray-streams
 225   (sbcl-package->cl-source-package sbcl-trivial-gray-streams))
 226
 227 (define-public ecl-trivial-gray-streams
 228   (sbcl-package->ecl-package sbcl-trivial-gray-streams))
 229
 230 (define-public sbcl-fiasco
 231   (let ((commit "d62f7558b21addc89f87e306f65d7f760632655f")
 232         (revision "1"))
 233     (package
 234       (name "sbcl-fiasco")
 235       (version (git-version "0.0.1" revision commit))
 236       (source
 237        (origin
 238          (method git-fetch)
 239          (uri (git-reference
 240                (url "https://github.com/joaotavora/fiasco.git")
 241                (commit commit)))
 242          (file-name (git-file-name "fiasco" version))
 243          (sha256
 244           (base32
 245            "1zwxs3d6iswayavcmb49z2892xhym7n556d8dnmvalc32pm9bkjh"))))
 246       (build-system asdf-build-system/sbcl)
 247       (inputs
 248        `(("alexandria" ,sbcl-alexandria)
 249          ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
 250       (synopsis "Simple and powerful test framework for Common Lisp")
 251       (description "A Common Lisp test framework that treasures your failures,
 252 logical continuation of Stefil.  It focuses on interactive debugging.")
 253       (home-page "https://github.com/joaotavora/fiasco")
 254       ;; LICENCE specifies this is public-domain unless the legislation
 255       ;; doesn't allow or recognize it.  In that case it falls back to a
 256       ;; permissive licence.
 257       (license (list license:public-domain
 258                      (license:x11-style "file://LICENCE"))))))
 259
 260 (define-public cl-fiasco
 261   (sbcl-package->cl-source-package sbcl-fiasco))
 262
 263 (define-public ecl-fiasco
 264   (sbcl-package->ecl-package sbcl-fiasco))
 265
 266 (define-public sbcl-flexi-streams
 267   (package
 268     (name "sbcl-flexi-streams")
 269     (version "1.0.18")
 270     (source
 271      (origin
 272        (method git-fetch)
 273        (uri (git-reference
 274              (url "https://github.com/edicl/flexi-streams.git")
 275              (commit (string-append "v" version))))
 276        (file-name (git-file-name "flexi-streams" version))
 277        (sha256
 278         (base32 "0bjv7fd2acknidc5dyi3h85pn10krxv5jyxs1xg8jya2rlfv7f1j"))))
 279     (build-system asdf-build-system/sbcl)
 280     (arguments
 281      `(#:phases
 282        (modify-phases %standard-phases
 283          (add-after 'unpack 'make-git-checkout-writable
 284            (lambda _
 285              (for-each make-file-writable (find-files "."))
 286              #t)))))
 287     (inputs `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
 288     (synopsis "Implementation of virtual bivalent streams for Common Lisp")
 289     (description "Flexi-streams is an implementation of \"virtual\" bivalent
 290 streams that can be layered atop real binary or bivalent streams and that can
 291 be used to read and write character data in various single- or multi-octet
 292 encodings which can be changed on the fly.  It also supplies in-memory binary
 293 streams which are similar to string streams.")
 294     (home-page "http://weitz.de/flexi-streams/")
 295     (license license:bsd-3)))
 296
 297 (define-public cl-flexi-streams
 298   (sbcl-package->cl-source-package sbcl-flexi-streams))
 299
 300 (define-public ecl-flexi-streams
 301   (sbcl-package->ecl-package sbcl-flexi-streams))
 302
 303 (define-public sbcl-cl-ppcre
 304   (package
 305     (name "sbcl-cl-ppcre")
 306     (version "2.1.1")
 307     (source
 308      (origin
 309        (method git-fetch)
 310        (uri (git-reference
 311              (url "https://github.com/edicl/cl-ppcre.git")
 312              (commit (string-append "v" version))))
 313        (file-name (git-file-name "cl-ppcre" version))
 314        (sha256
 315         (base32 "0dwvr29diqzcg5n6jvbk2rnd90i05l7n828hhw99khmqd0kz7xsi"))))
 316     (build-system asdf-build-system/sbcl)
 317     (native-inputs `(("flexi-streams" ,sbcl-flexi-streams)))
 318     (synopsis "Portable regular expression library for Common Lisp")
 319     (description "CL-PPCRE is a portable regular expression library for Common
 320 Lisp, which is compatible with perl.  It is pretty fast, thread-safe, and
 321 compatible with ANSI-compliant Common Lisp implementations.")
 322     (home-page "http://weitz.de/cl-ppcre/")
 323     (license license:bsd-2)))
 324
 325 (define-public cl-ppcre
 326   (sbcl-package->cl-source-package sbcl-cl-ppcre))
 327
 328 (define-public ecl-cl-ppcre
 329   (sbcl-package->ecl-package sbcl-cl-ppcre))
 330
 331 (define sbcl-cl-unicode-base
 332   (package
 333     (name "sbcl-cl-unicode-base")
 334     (version "0.1.6")
 335     (source (origin
 336               (method git-fetch)
 337               (uri (git-reference
 338                     (url "https://github.com/edicl/cl-unicode.git")
 339                     (commit (string-append "v" version))))
 340               (file-name (git-file-name name version))
 341               (sha256
 342                (base32
 343                 "0ykx2s9lqfl74p1px0ik3l2izd1fc9jd1b4ra68s5x34rvjy0hza"))))
 344     (build-system asdf-build-system/sbcl)
 345     (arguments
 346      '(#:asd-file "cl-unicode.asd"
 347        #:asd-system-name "cl-unicode/base"))
 348     (inputs
 349      `(("cl-ppcre" ,sbcl-cl-ppcre)))
 350     (home-page "http://weitz.de/cl-unicode/")
 351     (synopsis "Portable Unicode library for Common Lisp")
 352     (description "CL-UNICODE is a portable Unicode library Common Lisp, which
 353 is compatible with perl.  It is pretty fast, thread-safe, and compatible with
 354 ANSI-compliant Common Lisp implementations.")
 355     (license license:bsd-2)))
 356
 357 (define-public sbcl-cl-unicode
 358   (package
 359     (inherit sbcl-cl-unicode-base)
 360     (name "sbcl-cl-unicode")
 361     (inputs
 362      `(("cl-unicode/base" ,sbcl-cl-unicode-base)
 363        ,@(package-inputs sbcl-cl-unicode-base)))
 364     (native-inputs
 365      `(("flexi-streams" ,sbcl-flexi-streams)))
 366     (arguments '())))
 367
 368 (define-public ecl-cl-unicode
 369   (sbcl-package->ecl-package sbcl-cl-unicode))
 370
 371 (define-public cl-unicode
 372   (sbcl-package->cl-source-package sbcl-cl-unicode))
 373
 374 (define-public sbcl-zpb-ttf
 375   (package
 376     (name "sbcl-zpb-ttf")
 377     (version "1.0.3")
 378     (source
 379      (origin
 380        (method git-fetch)
 381        (uri (git-reference
 382              (url "https://github.com/xach/zpb-ttf.git")
 383              (commit (string-append "release-" version))))
 384        (file-name (git-file-name name version))
 385        (sha256
 386         (base32
 387          "1wh66vjijzqlydnrihynpwp6796917xwrh0i9li93c17kyxa74ih"))))
 388     (build-system asdf-build-system/sbcl)
 389     (home-page "https://github.com/xach/zpb-ttf")
 390     (synopsis "TrueType font file access for Common Lisp")
 391     (description
 392      "ZPB-TTF is a TrueType font file parser that provides an interface for
 393 reading typographic metrics, glyph outlines, and other information from the
 394 file.")
 395     (license license:bsd-2)))
 396
 397 (define-public ecl-zpb-ttf
 398   (sbcl-package->ecl-package sbcl-zpb-ttf))
 399
 400 (define-public cl-zpb-ttf
 401   (sbcl-package->cl-source-package sbcl-zpb-ttf))
 402
 403 (define-public sbcl-cl-aa
 404   (package
 405     (name "sbcl-cl-aa")
 406     (version "0.1.5")
 407     (source
 408      (origin
 409        (method url-fetch)
 410        (uri (string-append "http://projects.tuxee.net/cl-vectors/"
 411                            "files/cl-vectors-" version ".tar.gz"))
 412        (sha256
 413         (base32
 414          "04lhwi0kq8pkwhgd885pk80m1cp9sfvjjn5zj70s1dnckibhdmqh"))))
 415     (build-system asdf-build-system/sbcl)
 416     (arguments '(#:asd-file "cl-aa.asd"))
 417     (home-page "http://projects.tuxee.net/cl-vectors/")
 418     (synopsis "Polygon rasterizer")
 419     (description
 420      "This is a Common Lisp library implementing the AA polygon rasterization
 421 algorithm from the @url{http://antigrain.com, Antigrain} project.")
 422     (license license:expat)))
 423
 424 (define-public ecl-cl-aa
 425   (sbcl-package->ecl-package sbcl-cl-aa))
 426
 427 (define-public cl-aa
 428   (sbcl-package->cl-source-package sbcl-cl-aa))
 429
 430 (define-public sbcl-cl-paths
 431   (package
 432     (inherit sbcl-cl-aa)
 433     (name "sbcl-cl-paths")
 434     (arguments '(#:asd-file "cl-paths.asd"))
 435     (synopsis "Facilities to create and manipulate vectorial paths")
 436     (description
 437      "This package provides facilities to create and manipulate vectorial
 438 paths.")))
 439
 440 (define-public ecl-cl-paths
 441   (sbcl-package->ecl-package sbcl-cl-paths))
 442
 443 (define-public cl-paths
 444   (sbcl-package->cl-source-package sbcl-cl-paths))
 445
 446 (define-public sbcl-cl-paths-ttf
 447   (package
 448     (inherit sbcl-cl-aa)
 449     (name "sbcl-cl-paths-ttf")
 450     (arguments '(#:asd-file "cl-paths-ttf.asd"))
 451     (inputs
 452      `(("cl-paths" ,sbcl-cl-paths)
 453        ("zpb-ttf" ,sbcl-zpb-ttf)))
 454     (synopsis "Facilities to create and manipulate vectorial paths")
 455     (description
 456      "This package provides facilities to create and manipulate vectorial
 457 paths.")))
 458
 459 (define-public ecl-cl-paths-ttf
 460   (sbcl-package->ecl-package sbcl-cl-paths-ttf))
 461
 462 (define-public cl-paths-ttf
 463   (sbcl-package->cl-source-package sbcl-cl-paths-ttf))
 464
 465 (define-public sbcl-cl-vectors
 466   (package
 467     (inherit sbcl-cl-aa)
 468     (name "sbcl-cl-vectors")
 469     (arguments '(#:asd-file "cl-vectors.asd"))
 470     (inputs
 471      `(("cl-aa" ,sbcl-cl-aa)
 472        ("cl-paths" ,sbcl-cl-paths)))
 473     (synopsis "Create, transform and render anti-aliased vectorial paths")
 474     (description
 475      "This is a pure Common Lisp library to create, transform and render
 476 anti-aliased vectorial paths.")))
 477
 478 (define-public ecl-cl-vectors
 479   (sbcl-package->ecl-package sbcl-cl-vectors))
 480
 481 (define-public cl-vectors
 482   (sbcl-package->cl-source-package sbcl-cl-vectors))
 483
 484 (define-public sbcl-spatial-trees
 485   ;; There have been no releases.
 486   (let ((commit "81fdad0a0bf109c80a53cc96eca2e093823400ba")
 487         (revision "1"))
 488     (package
 489       (name "sbcl-spatial-trees")
 490       (version (git-version "0" revision commit))
 491       (source
 492        (origin
 493          (method git-fetch)
 494          (uri (git-reference
 495                (url "https://github.com/rpav/spatial-trees.git")
 496                (commit commit)))
 497          (file-name (git-file-name name version))
 498          (sha256
 499           (base32
 500            "11rhc6h501dwcik2igkszz7b9n515cr99m5pjh4r2qfwgiri6ysa"))))
 501       (build-system asdf-build-system/sbcl)
 502       (arguments
 503        '(#:tests? #f           ; spatial-trees.test requires spatial-trees.nns
 504          #:asd-file "spatial-trees.asd"
 505          #:test-asd-file "spatial-trees.test.asd"))
 506       (native-inputs
 507        `(("fiveam" ,sbcl-fiveam)))
 508       (home-page "https://github.com/rpav/spatial-trees")
 509       (synopsis "Dynamic index data structures for spatially-extended data")
 510       (description
 511        "Spatial-trees is a set of dynamic index data structures for
 512 spatially-extended data.")
 513       (license license:bsd-3))))
 514
 515 (define-public ecl-spatial-trees
 516   (sbcl-package->ecl-package sbcl-spatial-trees))
 517
 518 (define-public cl-spatial-trees
 519   (sbcl-package->cl-source-package sbcl-spatial-trees))
 520
 521 (define-public sbcl-flexichain
 522   ;; There are no releases.
 523   (let ((commit "13d2a6c505ed0abfcd4c4ec7d7145059b06855d6")
 524         (revision "1"))
 525     (package
 526       (name "sbcl-flexichain")
 527       (version "1.5.1")
 528       (source
 529        (origin
 530          (method git-fetch)
 531          (uri (git-reference
 532                (url "https://github.com/robert-strandh/Flexichain.git")
 533                (commit commit)))
 534          (file-name (git-file-name name version))
 535          (sha256
 536           (base32
 537            "0pfyvhsfbjd2sjb30grfs52r51a428xglv7bwydvpg2lc117qimg"))))
 538       (build-system asdf-build-system/sbcl)
 539       (home-page "https://github.com/robert-strandh/Flexichain.git")
 540       (synopsis "Dynamically add elements to or remove them from sequences")
 541       (description
 542        "This package provides an implementation of the flexichain protocol,
 543 allowing client code to dynamically add elements to, and delete elements from
 544 a sequence (or chain) of such elements.")
 545       (license license:lgpl2.1+))))
 546
 547 (define-public ecl-flexichain
 548   (sbcl-package->ecl-package sbcl-flexichain))
 549
 550 (define-public cl-flexichain
 551   (sbcl-package->cl-source-package sbcl-flexichain))
 552
 553 (define-public sbcl-cl-pdf
 554   ;; There are no releases
 555   (let ((commit "752e337e6d6fc206f09d091a982e7f8e5c404e4e")
 556         (revision "1"))
 557     (package
 558       (name "sbcl-cl-pdf")
 559       (version (git-version "0" revision commit))
 560       (source
 561        (origin
 562          (method git-fetch)
 563          (uri (git-reference
 564                (url "https://github.com/mbattyani/cl-pdf.git")
 565                (commit commit)))
 566          (file-name (git-file-name name version))
 567          (sha256
 568           (base32
 569            "1cg3k3m3r11ipb8j008y8ipynj97l3xjlpi2knqc9ndmx4r3kb1r"))))
 570       (build-system asdf-build-system/sbcl)
 571       (inputs
 572        `(("iterate" ,sbcl-iterate)
 573          ("zpb-ttf" ,sbcl-zpb-ttf)))
 574       (home-page "https://github.com/mbattyani/cl-pdf")
 575       (synopsis "Common Lisp library for generating PDF files")
 576       (description
 577        "CL-PDF is a cross-platform Common Lisp library for generating PDF
 578 files.")
 579       (license license:bsd-2))))
 580
 581 (define-public ecl-cl-pdf
 582   (sbcl-package->ecl-package sbcl-cl-pdf))
 583
 584 (define-public cl-pdf
 585   (sbcl-package->cl-source-package sbcl-cl-pdf))
 586
 587 (define-public sbcl-clx
 588   (package
 589     (name "sbcl-clx")
 590     (version "0.7.5")
 591     (source
 592      (origin
 593        (method git-fetch)
 594        (uri
 595         (git-reference
 596          (url "https://github.com/sharplispers/clx.git")
 597          (commit version)))
 598        (sha256
 599         (base32
 600          "1vi67z9hpj5rr4xcmfbfwzmlcc0ah7hzhrmfid6lqdkva238v2wf"))
 601        (file-name (string-append "clx-" version))))
 602     (build-system asdf-build-system/sbcl)
 603     (native-inputs
 604      `(("fiasco" ,sbcl-fiasco)))
 605     (home-page "http://www.cliki.net/portable-clx")
 606     (synopsis "X11 client library for Common Lisp")
 607     (description "CLX is an X11 client library for Common Lisp.  The code was
 608 originally taken from a CMUCL distribution, was modified somewhat in order to
 609 make it compile and run under SBCL, then a selection of patches were added
 610 from other CLXes around the net.")
 611     (license license:x11)))
 612
 613 (define-public cl-clx
 614   (sbcl-package->cl-source-package sbcl-clx))
 615
 616 (define-public ecl-clx
 617   (sbcl-package->ecl-package sbcl-clx))
 618
 619 (define-public sbcl-cl-ppcre-unicode
 620   (package (inherit sbcl-cl-ppcre)
 621     (name "sbcl-cl-ppcre-unicode")
 622     (arguments
 623      `(#:tests? #f ; tests fail with "Component :CL-PPCRE-TEST not found"
 624        #:asd-file "cl-ppcre-unicode.asd"))
 625     (inputs
 626      `(("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
 627        ("sbcl-cl-unicode" ,sbcl-cl-unicode)))))
 628
 629 (define-public ecl-cl-ppcre-unicode
 630   (sbcl-package->ecl-package sbcl-cl-ppcre-unicode))
 631
 632 ;; The slynk that users expect to install includes all of slynk's contrib
 633 ;; modules.  Therefore, we build the base module and all contribs first; then
 634 ;; we expose the union of these as `sbcl-slynk'.  The following variable
 635 ;; describes the base module.
 636 (define sbcl-slynk-boot0
 637   (let ((revision "2")
 638         (commit "cbf84c36c4eca8b032e3fd16177a7bc02df3ec4c"))
 639     (package
 640       (name "sbcl-slynk-boot0")
 641       (version (string-append "1.0.0-beta-" revision "." (string-take commit 7)))
 642       (source
 643        (origin
 644          (method git-fetch)
 645          (uri
 646           (git-reference
 647            (url "https://github.com/joaotavora/sly.git")
 648            (commit commit)))
 649          (sha256
 650           (base32 "13dyhsravn591p7g6is01mp2ynzjnnj7pwgi57r6xqmd4611y9vh"))
 651          (file-name (string-append "slynk-" version "-checkout"))
 652          (modules '((guix build utils)
 653                     (ice-9 ftw)))
 654          (snippet
 655           '(begin
 656              ;; Move the contribs into the main source directory for easier
 657              ;; access
 658              (substitute* "slynk/slynk.asd"
 659                (("\\.\\./contrib")
 660                 "contrib")
 661                (("\\(defsystem :slynk/util")
 662                 "(defsystem :slynk/util :depends-on (:slynk)")
 663                ((":depends-on \\(:slynk :slynk/util\\)")
 664                 ":depends-on (:slynk :slynk-util)"))
 665              (substitute* "contrib/slynk-trace-dialog.lisp"
 666                (("\\(slynk::reset-inspector\\)") ; Causes problems on load
 667                 "nil"))
 668              (substitute* "contrib/slynk-profiler.lisp"
 669                (("slynk:to-line")
 670                 "slynk-pprint-to-line"))
 671              (substitute* "contrib/slynk-fancy-inspector.lisp"
 672                (("slynk/util") "slynk-util")
 673                ((":compile-toplevel :load-toplevel") ""))
 674              (rename-file "contrib" "slynk/contrib")
 675              ;; Move slynk's contents into the base directory for easier
 676              ;; access
 677              (for-each (lambda (file)
 678                          (unless (string-prefix? "." file)
 679                            (rename-file (string-append "slynk/" file)
 680                                         (string-append "./" (basename file)))))
 681                        (scandir "slynk"))
 682              #t))))
 683       (build-system asdf-build-system/sbcl)
 684       (arguments
 685        `(#:tests? #f ; No test suite
 686          #:asd-system-name "slynk"))
 687       (synopsis "Common Lisp IDE for Emacs")
 688       (description "SLY is a fork of SLIME, an IDE backend for Common Lisp.
 689 It also features a completely redesigned REPL based on Emacs's own
 690 full-featured comint.el, live code annotations, and a consistent interactive
 691 button interface.  Everything can be copied to the REPL.  One can create
 692 multiple inspectors with independent history.")
 693       (home-page "https://github.com/joaotavora/sly")
 694       (license license:public-domain)
 695       (properties `((cl-source-variant . ,(delay cl-slynk)))))))
 696
 697 (define-public cl-slynk
 698   (package
 699     (inherit (sbcl-package->cl-source-package sbcl-slynk-boot0))
 700     (name "cl-slynk")))
 701
 702 (define ecl-slynk-boot0
 703   (sbcl-package->ecl-package sbcl-slynk-boot0))
 704
 705 (define sbcl-slynk-arglists
 706   (package
 707     (inherit sbcl-slynk-boot0)
 708     (name "sbcl-slynk-arglists")
 709     (inputs `(("slynk" ,sbcl-slynk-boot0)))
 710     (arguments
 711      (substitute-keyword-arguments (package-arguments sbcl-slynk-boot0)
 712        ((#:asd-file _ "") "slynk.asd")
 713        ((#:asd-system-name _ #f) "slynk/arglists")))))
 714
 715 (define ecl-slynk-arglists
 716   (sbcl-package->ecl-package sbcl-slynk-arglists))
 717
 718 (define sbcl-slynk-util
 719   (package
 720     (inherit sbcl-slynk-boot0)
 721     (name "sbcl-slynk-util")
 722     (inputs `(("slynk" ,sbcl-slynk-boot0)))
 723     (arguments
 724      (substitute-keyword-arguments (package-arguments sbcl-slynk-boot0)
 725        ((#:asd-file _ "") "slynk.asd")
 726        ((#:asd-system-name _ #f) "slynk/util")))))
 727
 728 (define ecl-slynk-util
 729   (sbcl-package->ecl-package sbcl-slynk-util))
 730
 731 (define sbcl-slynk-fancy-inspector
 732   (package
 733     (inherit sbcl-slynk-arglists)
 734     (name "sbcl-slynk-fancy-inspector")
 735     (inputs `(("slynk-util" ,sbcl-slynk-util)
 736               ,@(package-inputs sbcl-slynk-arglists)))
 737     (arguments
 738      (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
 739        ((#:asd-system-name _ #f) "slynk/fancy-inspector")))))
 740
 741 (define ecl-slynk-fancy-inspector
 742   (sbcl-package->ecl-package sbcl-slynk-fancy-inspector))
 743
 744 (define sbcl-slynk-package-fu
 745   (package
 746     (inherit sbcl-slynk-arglists)
 747     (name "sbcl-slynk-package-fu")
 748     (arguments
 749      (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
 750        ((#:asd-system-name _ #f) "slynk/package-fu")))))
 751
 752 (define ecl-slynk-package-fu
 753   (sbcl-package->ecl-package sbcl-slynk-package-fu))
 754
 755 (define sbcl-slynk-mrepl
 756   (package
 757     (inherit sbcl-slynk-fancy-inspector)
 758     (name "sbcl-slynk-mrepl")
 759     (arguments
 760      (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
 761        ((#:asd-system-name _ #f) "slynk/mrepl")))))
 762
 763 (define ecl-slynk-mrepl
 764   (sbcl-package->ecl-package sbcl-slynk-mrepl))
 765
 766 (define sbcl-slynk-trace-dialog
 767   (package
 768     (inherit sbcl-slynk-arglists)
 769     (name "sbcl-slynk-trace-dialog")
 770     (arguments
 771      (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
 772        ((#:asd-system-name _ #f) "slynk/trace-dialog")))))
 773
 774 (define ecl-slynk-trace-dialog
 775   (sbcl-package->ecl-package sbcl-slynk-trace-dialog))
 776
 777 (define sbcl-slynk-profiler
 778   (package
 779     (inherit sbcl-slynk-arglists)
 780     (name "sbcl-slynk-profiler")
 781     (arguments
 782      (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
 783        ((#:asd-system-name _ #f) "slynk/profiler")))))
 784
 785 (define ecl-slynk-profiler
 786   (sbcl-package->ecl-package sbcl-slynk-profiler))
 787
 788 (define sbcl-slynk-stickers
 789   (package
 790     (inherit sbcl-slynk-arglists)
 791     (name "sbcl-slynk-stickers")
 792     (arguments
 793      (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
 794        ((#:asd-system-name _ #f) "slynk/stickers")))))
 795
 796 (define ecl-slynk-stickers
 797   (sbcl-package->ecl-package sbcl-slynk-stickers))
 798
 799 (define sbcl-slynk-indentation
 800   (package
 801     (inherit sbcl-slynk-arglists)
 802     (name "sbcl-slynk-indentation")
 803     (arguments
 804      (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
 805        ((#:asd-system-name _ #f) "slynk/indentation")))))
 806
 807 (define ecl-slynk-indentation
 808   (sbcl-package->ecl-package sbcl-slynk-indentation))
 809
 810 (define sbcl-slynk-retro
 811   (package
 812     (inherit sbcl-slynk-arglists)
 813     (name "sbcl-slynk-retro")
 814     (arguments
 815      (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
 816        ((#:asd-system-name _ #f) "slynk/retro")))))
 817
 818 (define ecl-slynk-retro
 819   (sbcl-package->ecl-package sbcl-slynk-retro))
 820
 821 (define slynk-systems
 822   '("slynk"
 823     "slynk-util"
 824     "slynk-arglists"
 825     "slynk-fancy-inspector"
 826     "slynk-package-fu"
 827     "slynk-mrepl"
 828     "slynk-profiler"
 829     "slynk-trace-dialog"
 830     "slynk-stickers"
 831     "slynk-indentation"
 832     "slynk-retro"))
 833
 834 (define-public sbcl-slynk
 835   (package
 836     (inherit sbcl-slynk-boot0)
 837     (name "sbcl-slynk")
 838     (inputs
 839      `(("slynk" ,sbcl-slynk-boot0)
 840        ("slynk-util" ,sbcl-slynk-util)
 841        ("slynk-arglists" ,sbcl-slynk-arglists)
 842        ("slynk-fancy-inspector" ,sbcl-slynk-fancy-inspector)
 843        ("slynk-package-fu" ,sbcl-slynk-package-fu)
 844        ("slynk-mrepl" ,sbcl-slynk-mrepl)
 845        ("slynk-profiler" ,sbcl-slynk-profiler)
 846        ("slynk-trace-dialog" ,sbcl-slynk-trace-dialog)
 847        ("slynk-stickers" ,sbcl-slynk-stickers)
 848        ("slynk-indentation" ,sbcl-slynk-indentation)
 849        ("slynk-retro" ,sbcl-slynk-retro)))
 850     (native-inputs `(("sbcl" ,sbcl)))
 851     (build-system trivial-build-system)
 852     (source #f)
 853     (outputs '("out" "image"))
 854     (arguments
 855      `(#:modules ((guix build union)
 856                   (guix build utils)
 857                   (guix build lisp-utils))
 858        #:builder
 859        (begin
 860          (use-modules (ice-9 match)
 861                       (srfi srfi-1)
 862                       (guix build union)
 863                       (guix build lisp-utils))
 864
 865          (union-build
 866           (assoc-ref %outputs "out")
 867           (filter-map
 868            (match-lambda
 869              ((name . path)
 870               (if (string-prefix? "slynk" name) path #f)))
 871            %build-inputs))
 872
 873          (prepend-to-source-registry
 874           (string-append (assoc-ref %outputs "out") "//"))
 875
 876          (parameterize ((%lisp-type "sbcl")
 877                         (%lisp (string-append (assoc-ref %build-inputs "sbcl")
 878                                               "/bin/sbcl")))
 879            (build-image (string-append
 880                          (assoc-ref %outputs "image")
 881                          "/bin/slynk")
 882                         %outputs
 883                         #:dependencies ',slynk-systems))
 884          #t)))))
 885
 886 (define-public ecl-slynk
 887   (package
 888     (inherit sbcl-slynk)
 889     (name "ecl-slynk")
 890     (inputs
 891      (map (match-lambda
 892             ((name pkg . _)
 893              (list name (sbcl-package->ecl-package pkg))))
 894           (package-inputs sbcl-slynk)))
 895     (native-inputs '())
 896     (outputs '("out"))
 897     (arguments
 898      '(#:modules ((guix build union))
 899        #:builder
 900        (begin
 901          (use-modules (ice-9 match)
 902                       (guix build union))
 903          (match %build-inputs
 904            (((names . paths) ...)
 905             (union-build (assoc-ref %outputs "out")
 906                          paths)
 907             #t)))))))
 908
 909 (define-public sbcl-parse-js
 910   (let ((commit "fbadc6029bec7039602abfc06c73bb52970998f6")
 911         (revision "1"))
 912     (package
 913       (name "sbcl-parse-js")
 914       (version (string-append "0.0.0-" revision "." (string-take commit 9)))
 915       (source
 916        (origin
 917          (method git-fetch)
 918          (uri (git-reference
 919                (url "http://marijn.haverbeke.nl/git/parse-js")
 920                (commit commit)))
 921          (file-name (string-append name "-" commit "-checkout"))
 922          (sha256
 923           (base32
 924            "1wddrnr5kiya5s3gp4cdq6crbfy9fqcz7fr44p81502sj3bvdv39"))))
 925       (build-system asdf-build-system/sbcl)
 926       (home-page "http://marijnhaverbeke.nl/parse-js/")
 927       (synopsis "Parse JavaScript")
 928       (description "Parse-js is a Common Lisp package for parsing
 929 JavaScript (ECMAScript 3).  It has basic support for ECMAScript 5.")
 930       (license license:zlib))))
 931
 932 (define-public cl-parse-js
 933   (sbcl-package->cl-source-package sbcl-parse-js))
 934
 935 (define-public sbcl-parse-number
 936   (package
 937     (name "sbcl-parse-number")
 938     (version "1.7")
 939     (source
 940      (origin
 941        (method git-fetch)
 942        (uri (git-reference
 943               (url "https://github.com/sharplispers/parse-number/")
 944               (commit (string-append "v" version))))
 945        (file-name (git-file-name name version))
 946        (sha256
 947         (base32
 948          "0sk06ib1bhqv9y39vwnnw44vmbc4b0kvqm37xxmkxd4dwchq82d7"))))
 949     (build-system asdf-build-system/sbcl)
 950     (home-page "http://www.cliki.net/PARSE-NUMBER")
 951     (synopsis "Parse numbers")
 952     (description "@code{parse-number} is a library of functions for parsing
 953 strings into one of the standard Common Lisp number types without using the
 954 reader.  @code{parse-number} accepts an arbitrary string and attempts to parse
 955 the string into one of the standard Common Lisp number types, if possible, or
 956 else @code{parse-number} signals an error of type @code{invalid-number}.")
 957     (license license:bsd-3)))
 958
 959 (define-public cl-parse-number
 960   (sbcl-package->cl-source-package sbcl-parse-number))
 961
 962 (define-public sbcl-iterate
 963   (package
 964     (name "sbcl-iterate")
 965     (version "1.5")
 966     (source
 967      (origin
 968        (method url-fetch)
 969        (uri (string-append "https://common-lisp.net/project/iterate/releases/"
 970                            "iterate-" version ".tar.gz"))
 971        (sha256
 972         (base32
 973          "1lqsbhrkfl0yif46aymvb7l3nb9wdcmj4jyw485blj32jb4famzn"))))
 974     (build-system asdf-build-system/sbcl)
 975     (native-inputs
 976      `(("rt" ,sbcl-rt)))
 977     (home-page "https://common-lisp.net/project/iterate/")
 978     (synopsis "Iteration construct for Common Lisp")
 979     (description "@code{iterate} is an iteration construct for Common Lisp.
 980 It is similar to the @code{CL:LOOP} macro, with these distinguishing marks:
 981
 982 @itemize
 983 @item it is extensible,
 984 @item it helps editors like Emacs indent iterate forms by having a more
 985   lisp-like syntax, and
 986 @item it isn't part of the ANSI standard for Common Lisp.
 987 @end itemize\n")
 988     (license license:expat)))
 989
 990 (define-public cl-iterate
 991   (sbcl-package->cl-source-package sbcl-iterate))
 992
 993 (define-public ecl-iterate
 994   (sbcl-package->ecl-package sbcl-iterate))
 995
 996 (define-public sbcl-cl-uglify-js
 997   ;; There have been many bug fixes since the 2010 release.
 998   (let ((commit "429c5e1d844e2f96b44db8fccc92d6e8e28afdd5")
 999         (revision "1"))
1000     (package
1001       (name "sbcl-cl-uglify-js")
1002       (version (string-append "0.1-" revision "." (string-take commit 9)))
1003       (source
1004        (origin
1005          (method git-fetch)
1006          (uri (git-reference
1007                (url "https://github.com/mishoo/cl-uglify-js.git")
1008                (commit commit)))
1009          (file-name (git-file-name name version))
1010          (sha256
1011           (base32
1012            "0k39y3c93jgxpr7gwz7w0d8yknn1fdnxrjhd03057lvk5w8js27a"))))
1013       (build-system asdf-build-system/sbcl)
1014       (inputs
1015        `(("sbcl-parse-js" ,sbcl-parse-js)
1016          ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
1017          ("sbcl-cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)
1018          ("sbcl-parse-number" ,sbcl-parse-number)
1019          ("sbcl-iterate" ,sbcl-iterate)))
1020       (home-page "https://github.com/mishoo/cl-uglify-js")
1021       (synopsis "JavaScript compressor library for Common Lisp")
1022       (description "This is a Common Lisp version of UglifyJS, a JavaScript
1023 compressor.  It works on data produced by @code{parse-js} to generate a
1024 @dfn{minified} version of the code.  Currently it can:
1025
1026 @itemize
1027 @item reduce variable names (usually to single letters)
1028 @item join consecutive @code{var} statements
1029 @item resolve simple binary expressions
1030 @item group most consecutive statements using the @code{sequence} operator (comma)
1031 @item remove unnecessary blocks
1032 @item convert @code{IF} expressions in various ways that result in smaller code
1033 @item remove some unreachable code
1034 @end itemize\n")
1035       (license license:zlib))))
1036
1037 (define-public cl-uglify-js
1038   (sbcl-package->cl-source-package sbcl-cl-uglify-js))
1039
1040 (define-public uglify-js
1041   (package
1042     (inherit sbcl-cl-uglify-js)
1043     (name "uglify-js")
1044     (build-system trivial-build-system)
1045     (arguments
1046      `(#:modules ((guix build utils))
1047        #:builder
1048        (let* ((bin    (string-append (assoc-ref %outputs "out") "/bin/"))
1049               (script (string-append bin "uglify-js")))
1050          (use-modules (guix build utils))
1051          (mkdir-p bin)
1052          (with-output-to-file script
1053            (lambda _
1054              (format #t "#!~a/bin/sbcl --script
1055  (require :asdf)
1056  (push (truename \"~a/lib/sbcl\") asdf:*central-registry*)"
1057                      (assoc-ref %build-inputs "sbcl")
1058                      (assoc-ref %build-inputs "sbcl-cl-uglify-js"))
1059              ;; FIXME: cannot use progn here because otherwise it fails to
1060              ;; find cl-uglify-js.
1061              (for-each
1062               write
1063               '(;; Quiet, please!
1064                 (let ((*standard-output* (make-broadcast-stream))
1065                       (*error-output* (make-broadcast-stream)))
1066                   (asdf:load-system :cl-uglify-js))
1067                 (let ((file (cadr *posix-argv*)))
1068                   (if file
1069                       (format t "~a"
1070                               (cl-uglify-js:ast-gen-code
1071                                (cl-uglify-js:ast-mangle
1072                                 (cl-uglify-js:ast-squeeze
1073                                  (with-open-file (in file)
1074                                                  (parse-js:parse-js in))))
1075                                :beautify nil))
1076                       (progn
1077                        (format *error-output*
1078                                "Please provide a JavaScript file.~%")
1079                        (sb-ext:exit :code 1))))))))
1080          (chmod script #o755)
1081          #t)))
1082     (inputs
1083      `(("sbcl" ,sbcl)
1084        ("sbcl-cl-uglify-js" ,sbcl-cl-uglify-js)))
1085     (synopsis "JavaScript compressor")))
1086
1087 (define-public sbcl-cl-strings
1088   (let ((revision "1")
1089         (commit "c5c5cbafbf3e6181d03c354d66e41a4f063f00ae"))
1090     (package
1091       (name "sbcl-cl-strings")
1092       (version (git-version "0.0.0" revision commit))
1093       (source
1094        (origin
1095          (method git-fetch)
1096          (uri (git-reference
1097                (url "https://github.com/diogoalexandrefranco/cl-strings")
1098                (commit commit)))
1099          (sha256
1100           (base32
1101            "00754mfaqallj480lwd346nkfb6ra8pa8xcxcylf4baqn604zlmv"))
1102          (file-name (string-append "cl-strings-" version "-checkout"))))
1103       (build-system asdf-build-system/sbcl)
1104       (synopsis "Portable, dependency-free set of utilities to manipulate strings in Common Lisp")
1105       (description
1106        "@command{cl-strings} is a small, portable, dependency-free set of
1107 utilities that make it even easier to manipulate text in Common Lisp.  It has
1108 100% test coverage and works at least on sbcl, ecl, ccl, abcl and clisp.")
1109       (home-page "https://github.com/diogoalexandrefranco/cl-strings")
1110       (license license:expat))))
1111
1112 (define-public cl-strings
1113   (sbcl-package->cl-source-package sbcl-cl-strings))
1114
1115 (define-public ecl-cl-strings
1116   (sbcl-package->ecl-package sbcl-cl-strings))
1117
1118 (define-public sbcl-trivial-features
1119   (package
1120     (name "sbcl-trivial-features")
1121     (version "0.8")
1122     (source
1123      (origin
1124        (method git-fetch)
1125        (uri (git-reference
1126              (url "https://github.com/trivial-features/trivial-features.git")
1127              (commit (string-append "v" version))))
1128        (file-name (git-file-name "trivial-features" version))
1129        (sha256
1130         (base32 "0ccv7dqyrk55xga78i5vzlic7mdwp28in3g1a8fqhlk6626scsq9"))))
1131     (build-system asdf-build-system/sbcl)
1132     (arguments '(#:tests? #f))
1133     (home-page "http://cliki.net/trivial-features")
1134     (synopsis "Ensures consistency of @code{*FEATURES*} in Common Lisp")
1135     (description "Trivial-features ensures that @code{*FEATURES*} is
1136 consistent across multiple Common Lisp implementations.")
1137     (license license:expat)))
1138
1139 (define-public cl-trivial-features
1140   (sbcl-package->cl-source-package sbcl-trivial-features))
1141
1142 (define-public ecl-trivial-features
1143   (sbcl-package->ecl-package sbcl-trivial-features))
1144
1145 (define-public sbcl-hu.dwim.asdf
1146   (package
1147     (name "sbcl-hu.dwim.asdf")
1148     (version "20190521")
1149     (source
1150      (origin
1151        (method url-fetch)
1152        (uri (string-append "http://beta.quicklisp.org/archive/hu.dwim.asdf/"
1153                            "2019-05-21/hu.dwim.asdf-" version "-darcs.tgz"))
1154        (sha256
1155         (base32
1156          "0rsbv71vyszy8w35yjwb5h6zcmknjq223hkzir79y72qdsc6sabn"))))
1157     (build-system asdf-build-system/sbcl)
1158     (home-page "https://hub.darcs.net/hu.dwim/hu.dwim.asdf")
1159     (synopsis "Extensions to ASDF")
1160     (description "Various ASDF extensions such as attached test and
1161 documentation system, explicit development support, etc.")
1162     (license license:public-domain)))
1163
1164 (define-public cl-hu.dwim.asdf
1165   (sbcl-package->cl-source-package sbcl-hu.dwim.asdf))
1166
1167 (define-public ecl-hu.dwim.asdf
1168   (sbcl-package->ecl-package sbcl-hu.dwim.asdf))
1169
1170 (define-public sbcl-hu.dwim.stefil
1171   (let ((commit "ab6d1aa8995878a1b66d745dfd0ba021090bbcf9"))
1172     (package
1173       (name "sbcl-hu.dwim.stefil")
1174       (version (git-version "0.0.0" "1" commit))
1175       (source
1176        (origin
1177          (method git-fetch)
1178          (uri
1179           (git-reference
1180            (url "https://gitlab.common-lisp.net/xcvb/hu.dwim.stefil.git")
1181            (commit commit)))
1182          (sha256
1183           (base32 "1d8yccw65zj3zh46cbi3x6nmn1dwdb76s9d0av035077mvyirqqp"))
1184          (file-name (git-file-name "hu.dwim.stefil" version))))
1185       (build-system asdf-build-system/sbcl)
1186       (native-inputs
1187        `(("asdf:cl-hu.dwim.asdf" ,sbcl-hu.dwim.asdf)))
1188       (inputs
1189        `(("sbcl-alexandria" ,sbcl-alexandria)))
1190       (home-page "https://hub.darcs.net/hu.dwim/hu.dwim.stefil")
1191       (synopsis "Simple test framework")
1192       (description "Stefil is a simple test framework for Common Lisp,
1193 with a focus on interactive development.")
1194       (license license:public-domain))))
1195
1196 (define-public cl-hu.dwim.stefil
1197   (sbcl-package->cl-source-package sbcl-hu.dwim.stefil))
1198
1199 (define-public ecl-hu.dwim.stefil
1200   (sbcl-package->ecl-package sbcl-hu.dwim.stefil))
1201
1202 (define-public sbcl-babel
1203   (package
1204     (name "sbcl-babel")
1205     (version "0.5.0")
1206     (source
1207      (origin
1208        (method git-fetch)
1209        (uri (git-reference
1210              (url "https://github.com/cl-babel/babel.git")
1211              (commit (string-append "v" version))))
1212        (file-name (git-file-name "babel" version))
1213        (sha256
1214         (base32 "139a8rn2gnhj082n8jg01gc8fyr63hkj57hgrnmb3d1r327yc77f"))))
1215     (build-system asdf-build-system/sbcl)
1216     (native-inputs
1217      `(("tests:cl-hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
1218     (inputs
1219      `(("sbcl-alexandria" ,sbcl-alexandria)
1220        ("sbcl-trivial-features" ,sbcl-trivial-features)))
1221     (home-page "https://common-lisp.net/project/babel/")
1222     (synopsis "Charset encoding and decoding library")
1223     (description "Babel is a charset encoding and decoding library, not unlike
1224 GNU libiconv, but completely written in Common Lisp.")
1225     (license license:expat)))
1226
1227 (define-public cl-babel
1228   (sbcl-package->cl-source-package sbcl-babel))
1229
1230 (define-public ecl-babel
1231   (sbcl-package->ecl-package sbcl-babel))
1232
1233 (define-public sbcl-cl-yacc
1234   (package
1235     (name "sbcl-cl-yacc")
1236     (version "0.3")
1237     (source
1238      (origin
1239        (method git-fetch)
1240        (uri (git-reference
1241              (url "https://github.com/jech/cl-yacc")
1242              (commit (string-append "cl-yacc-" version))))
1243        (sha256
1244         (base32
1245          "16946pzf8vvadnyfayvj8rbh4zjzw90h0azz2qk1mxrvhh5wklib"))
1246        (file-name (string-append "cl-yacc-" version "-checkout"))))
1247     (build-system asdf-build-system/sbcl)
1248     (arguments
1249      `(#:asd-file "yacc.asd"
1250        #:asd-system-name "yacc"))
1251     (synopsis "LALR(1) parser generator for Common Lisp, similar in spirit to Yacc")
1252     (description
1253      "CL-Yacc is a LALR(1) parser generator for Common Lisp, similar in spirit
1254 to AT&T Yacc, Berkeley Yacc, GNU Bison, Zebu, lalr.cl or lalr.scm.
1255
1256 CL-Yacc uses the algorithm due to Aho and Ullman, which is the one also used
1257 by AT&T Yacc, Berkeley Yacc and Zebu.  It does not use the faster algorithm due
1258 to DeRemer and Pennello, which is used by Bison and lalr.scm (not lalr.cl).")
1259     (home-page "https://www.irif.fr/~jch//software/cl-yacc/")
1260     (license license:expat)))
1261
1262 (define-public cl-yacc
1263   (sbcl-package->cl-source-package sbcl-cl-yacc))
1264
1265 (define-public ecl-cl-yacc
1266   (sbcl-package->ecl-package sbcl-cl-yacc))
1267
1268 (define-public sbcl-jpl-util
1269   (let ((commit "0311ed374e19a49d43318064d729fe3abd9a3b62"))
1270     (package
1271       (name "sbcl-jpl-util")
1272       (version "20151005")
1273       (source
1274        (origin
1275          (method git-fetch)
1276          (uri (git-reference
1277                ;; Quicklisp uses this fork.
1278                (url "https://github.com/hawkir/cl-jpl-util")
1279                (commit commit)))
1280          (file-name
1281           (git-file-name "jpl-util" version))
1282          (sha256
1283           (base32
1284            "0nc0rk9n8grkg3045xsw34whmcmddn2sfrxki4268g7kpgz0d2yz"))))
1285       (build-system asdf-build-system/sbcl)
1286       (synopsis "Collection of Common Lisp utility functions and macros")
1287       (description
1288        "@command{cl-jpl-util} is a collection of Common Lisp utility functions
1289 and macros, primarily for software projects written in CL by the author.")
1290       (home-page "https://www.thoughtcrime.us/software/cl-jpl-util/")
1291       (license license:isc))))
1292
1293 (define-public cl-jpl-util
1294   (sbcl-package->cl-source-package sbcl-jpl-util))
1295
1296 (define-public ecl-jpl-util
1297   (sbcl-package->ecl-package sbcl-jpl-util))
1298
1299 (define-public sbcl-jpl-queues
1300   (package
1301     (name "sbcl-jpl-queues")
1302     (version "0.1")
1303     (source
1304      (origin
1305        (method url-fetch)
1306        (uri (string-append
1307              "http://www.thoughtcrime.us/software/jpl-queues/jpl-queues-"
1308              version
1309              ".tar.gz"))
1310        (sha256
1311         (base32
1312          "1wvvv7j117h9a42qaj1g4fh4mji28xqs7s60rn6d11gk9jl76h96"))))
1313     (build-system asdf-build-system/sbcl)
1314     (inputs
1315      `(("jpl-util" ,sbcl-jpl-util)
1316        ("bordeaux-threads" ,sbcl-bordeaux-threads)))
1317     (arguments
1318      ;; Tests seem to be broken.
1319      `(#:tests? #f))
1320     (synopsis "Common Lisp library implementing a few different kinds of queues")
1321     (description
1322      "A Common Lisp library implementing a few different kinds of queues:
1323
1324 @itemize
1325 @item Bounded and unbounded FIFO queues.
1326 @item Lossy bounded FIFO queues that drop elements when full.
1327 @item Unbounded random-order queues that use less memory than unbounded FIFO queues.
1328 @end itemize
1329
1330 Additionally, a synchronization wrapper is provided to make any queue
1331 conforming to the @command{jpl-queues} API thread-safe for lightweight
1332 multithreading applications.  (See Calispel for a more sophisticated CL
1333 multithreaded message-passing library with timeouts and alternation among
1334 several blockable channels.)")
1335     (home-page "https://www.thoughtcrime.us/software/jpl-queues/")
1336     (license license:isc)))
1337
1338 (define-public cl-jpl-queues
1339   (sbcl-package->cl-source-package sbcl-jpl-queues))
1340
1341 (define-public ecl-jpl-queues
1342   (sbcl-package->ecl-package sbcl-jpl-queues))
1343
1344 (define-public sbcl-eos
1345   (let ((commit "b0faca83781ead9a588661e37bd47f90362ccd94"))
1346     (package
1347       (name "sbcl-eos")
1348       (version (git-version "0.0.0" "1" commit))
1349       (source
1350        (origin
1351          (method git-fetch)
1352          (uri (git-reference
1353                (url "https://github.com/adlai/Eos")
1354                (commit commit)))
1355          (sha256
1356           (base32
1357            "1bq8cfg087iyxmxi1mwgx5cfgy3b8ydrf81xljcis8qbgb2vszph"))
1358          (file-name (git-file-name "eos" version))))
1359       (build-system asdf-build-system/sbcl)
1360       (synopsis "Unit Testing for Common Lisp")
1361       (description
1362        "Eos was a unit testing library for Common Lisp.
1363 It began as a fork of FiveAM; however, FiveAM development has continued, while
1364 that of Eos has not.  Thus, Eos is now deprecated in favor of FiveAM.")
1365       (home-page "https://github.com/adlai/Eos")
1366       (license license:expat))))
1367
1368 (define-public cl-eos
1369   (sbcl-package->cl-source-package sbcl-eos))
1370
1371 (define-public ecl-eos
1372   (sbcl-package->ecl-package sbcl-eos))
1373
1374 (define-public sbcl-esrap
1375   (let ((commit "133be8b05c2aae48696fe5b739eea2fa573fa48d"))
1376     (package
1377       (name "sbcl-esrap")
1378       (version (git-version "0.0.0" "1" commit))
1379       (source
1380        (origin
1381          (method git-fetch)
1382          (uri (git-reference
1383                (url "https://github.com/nikodemus/esrap")
1384                (commit commit)))
1385          (sha256
1386           (base32
1387            "02d5clihsdryhf7pix8c5di2571fdsffh75d40fkzhws90r5mksl"))
1388          (file-name (git-file-name "esrap" version))))
1389       (build-system asdf-build-system/sbcl)
1390       (native-inputs
1391        `(("eos" ,sbcl-eos)))            ;For testing only.
1392       (inputs
1393        `(("alexandria" ,sbcl-alexandria)))
1394       (synopsis "Common Lisp packrat parser")
1395       (description
1396        "A packrat parser for Common Lisp.
1397 In addition to regular Packrat / Parsing Grammar / TDPL features ESRAP supports:
1398
1399 @itemize
1400 @item dynamic redefinition of nonterminals
1401 @item inline grammars
1402 @item semantic predicates
1403 @item introspective facilities (describing grammars, tracing, setting breaks)
1404 @end itemize\n")
1405       (home-page "https://nikodemus.github.io/esrap/")
1406       (license license:expat))))
1407
1408 (define-public cl-esrap
1409   (sbcl-package->cl-source-package sbcl-esrap))
1410
1411 (define-public ecl-esrap
1412   (sbcl-package->ecl-package sbcl-esrap))
1413
1414 (define-public sbcl-split-sequence
1415   (package
1416     (name "sbcl-split-sequence")
1417     (version "2.0.0")
1418     (source
1419      (origin
1420        (method git-fetch)
1421        (uri (git-reference
1422              (url "https://github.com/sharplispers/split-sequence")
1423              (commit (string-append "v" version))))
1424        (sha256
1425         (base32
1426          "0jcpnx21hkfwqj5fvp7kc6pn1qcz9hk7g2s5x8h0349x1j2irln0"))
1427        (file-name (git-file-name "split-sequence" version))))
1428     (build-system asdf-build-system/sbcl)
1429     (native-inputs
1430      `(("fiveam" ,sbcl-fiveam)))
1431     (synopsis "Member of the Common Lisp Utilities family of programs")
1432     (description
1433      "Splits sequence into a list of subsequences delimited by objects
1434 satisfying the test.")
1435     (home-page "https://cliki.net/split-sequence")
1436     (license license:expat)))
1437
1438 (define-public cl-split-sequence
1439   (sbcl-package->cl-source-package sbcl-split-sequence))
1440
1441 (define-public ecl-split-sequence
1442   (sbcl-package->ecl-package sbcl-split-sequence))
1443
1444 (define-public sbcl-html-encode
1445   (package
1446     (name "sbcl-html-encode")
1447     (version "1.2")
1448     (source
1449      (origin
1450        (method url-fetch)
1451        (uri (string-append
1452              "http://beta.quicklisp.org/archive/html-encode/2010-10-06/html-encode-"
1453              version ".tgz"))
1454        (sha256
1455         (base32
1456          "06mf8wn95yf5swhmzk4vp0xr4ylfl33dgfknkabbkd8n6jns8gcf"))
1457        (file-name (string-append "colorize" version "-checkout"))))
1458     (build-system asdf-build-system/sbcl)
1459     (synopsis "Common Lisp library for encoding text in various web-savvy encodings")
1460     (description
1461      "A library for encoding text in various web-savvy encodings.")
1462     (home-page "http://quickdocs.org/html-encode/")
1463     (license license:expat)))
1464
1465 (define-public cl-html-encode
1466   (sbcl-package->cl-source-package sbcl-html-encode))
1467
1468 (define-public ecl-html-encode
1469   (sbcl-package->ecl-package sbcl-html-encode))
1470
1471 (define-public sbcl-colorize
1472   (let ((commit "ea676b584e0899cec82f21a9e6871172fe3c0eb5"))
1473     (package
1474       (name "sbcl-colorize")
1475       (version (git-version "0.0.0" "1" commit))
1476       (source
1477        (origin
1478          (method git-fetch)
1479          (uri (git-reference
1480                (url "https://github.com/kingcons/colorize")
1481                (commit commit)))
1482          (sha256
1483           (base32
1484            "1pdg4kiaczmr3ivffhirp7m3lbr1q27rn7dhaay0vwghmi31zcw9"))
1485          (file-name (git-file-name "colorize" version))))
1486       (build-system asdf-build-system/sbcl)
1487       (inputs
1488        `(("alexandria" ,sbcl-alexandria)
1489          ("split-sequence" ,sbcl-split-sequence)
1490          ("html-encode" ,sbcl-html-encode)))
1491       (synopsis "Common Lisp for syntax highlighting")
1492       (description
1493        "@command{colorize} is a Lisp library for syntax highlighting
1494 supporting the following languages: Common Lisp, Emacs Lisp, Scheme, Clojure,
1495 C, C++, Java, Python, Erlang, Haskell, Objective-C, Diff, Webkit.")
1496       (home-page "https://github.com/kingcons/colorize")
1497       ;; TODO: Missing license?
1498       (license license:expat))))
1499
1500 (define-public cl-colorize
1501   (sbcl-package->cl-source-package sbcl-colorize))
1502
1503 (define-public ecl-colorize
1504   (sbcl-package->ecl-package sbcl-colorize))
1505
1506 (define-public sbcl-3bmd
1507   (let ((commit "192ea13435b605a96ef607df51317056914cabbd"))
1508     (package
1509       (name "sbcl-3bmd")
1510       (version (git-version "0.0.0" "1" commit))
1511       (source
1512        (origin
1513          (method git-fetch)
1514          (uri (git-reference
1515                (url "https://github.com/3b/3bmd")
1516                (commit commit)))
1517          (sha256
1518           (base32
1519            "1rgv3gi7wf963ikmmpk132wgn0icddf226gq3bmcnk1fr3v9gf2f"))
1520          (file-name (git-file-name "3bmd" version))))
1521       (build-system asdf-build-system/sbcl)
1522       (arguments
1523        ;; FIXME: We need to specify the name because the build-system thinks
1524        ;; "3" is a version marker.
1525        `(#:asd-system-name "3bmd"))
1526       (inputs
1527        `(("esrap" ,sbcl-esrap)
1528          ("split-sequence" ,sbcl-split-sequence)))
1529       (synopsis "Markdown processor in Command Lisp using esrap parser")
1530       (description
1531        "Common Lisp Markdown -> HTML converter, using @command{esrap} for
1532 parsing, and grammar based on @command{peg-markdown}.")
1533       (home-page "https://github.com/3b/3bmd")
1534       (license license:expat))))
1535
1536 (define-public cl-3bmd
1537   (sbcl-package->cl-source-package sbcl-3bmd))
1538
1539 (define-public ecl-3bmd
1540   (sbcl-package->ecl-package sbcl-3bmd))
1541
1542 (define-public sbcl-3bmd-ext-code-blocks
1543   (let ((commit "192ea13435b605a96ef607df51317056914cabbd"))
1544     (package
1545       (inherit sbcl-3bmd)
1546       (name "sbcl-3bmd-ext-code-blocks")
1547       (arguments
1548        `(#:asd-system-name "3bmd-ext-code-blocks"
1549          #:asd-file "3bmd-ext-code-blocks.asd"))
1550       (inputs
1551        `(("3bmd" ,sbcl-3bmd)
1552          ("colorize" ,sbcl-colorize)))
1553       (synopsis "3bmd extension which adds support for GitHub-style fenced
1554 code blocks")
1555       (description
1556        "3bmd extension which adds support for GitHub-style fenced code blocks,
1557 with @command{colorize} support."))))
1558
1559 (define-public cl-3bmd-ext-code-blocks
1560   (sbcl-package->cl-source-package sbcl-3bmd-ext-code-blocks))
1561
1562 (define-public ecl-3bmd-ext-code-blocks
1563   (sbcl-package->ecl-package sbcl-3bmd-ext-code-blocks))
1564
1565 (define-public sbcl-cl-fad
1566   (package
1567     (name "sbcl-cl-fad")
1568     (version "0.7.6")
1569     (source
1570      (origin
1571        (method git-fetch)
1572        (uri (git-reference
1573              (url "https://github.com/edicl/cl-fad/")
1574              (commit (string-append "v" version))))
1575        (sha256
1576         (base32
1577          "1gc8i82v6gks7g0lnm54r4prk2mklidv2flm5fvbr0a7rsys0vpa"))
1578        (file-name (string-append "cl-fad" version "-checkout"))))
1579     (build-system asdf-build-system/sbcl)
1580     (inputs
1581      `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
1582     (synopsis "Portable pathname library for Common Lisp")
1583     (description
1584      "CL-FAD (for \"Files and Directories\") is a thin layer atop Common
1585 Lisp's standard pathname functions.  It is intended to provide some
1586 unification between current CL implementations on Windows, OS X, Linux, and
1587 Unix.  Most of the code was written by Peter Seibel for his book Practical
1588 Common Lisp.")
1589     (home-page "https://edicl.github.io/cl-fad/")
1590     (license license:bsd-2)))
1591
1592 (define-public cl-fad
1593   (sbcl-package->cl-source-package sbcl-cl-fad))
1594
1595 (define-public ecl-cl-fad
1596   (sbcl-package->ecl-package sbcl-cl-fad))
1597
1598 (define-public sbcl-rt
1599   (package
1600     (name "sbcl-rt")
1601     (version "1990.12.19")
1602     (source
1603      (origin
1604        (method url-fetch)
1605        (uri (string-append "http://beta.quicklisp.org/archive/rt/2010-10-06/rt-"
1606                            "20101006-git" ".tgz"))
1607        (sha256
1608         (base32
1609          "1jncar0xwkqk8yrc2dln389ivvgzs7ijdhhs3zpfyi5d21f0qa1v"))))
1610     (build-system asdf-build-system/sbcl)
1611     (synopsis "MIT Regression Tester")
1612     (description
1613      "RT provides a framework for writing regression test suites.")
1614     (home-page "https://github.com/sharplispers/nibbles")
1615     (license license:unlicense)))
1616
1617 (define-public cl-rt
1618   (sbcl-package->cl-source-package sbcl-rt))
1619
1620 (define-public ecl-rt
1621   (sbcl-package->ecl-package sbcl-rt))
1622
1623 (define-public sbcl-nibbles
1624   (package
1625     (name "sbcl-nibbles")
1626     (version "0.14")
1627     (source
1628      (origin
1629        (method git-fetch)
1630        (uri (git-reference
1631              (url "https://github.com/sharplispers/nibbles/")
1632              (commit (string-append "v" version))))
1633        (sha256
1634         (base32
1635          "1v7qfgpvdr6nz7v63dj69d26dis0kff3rd8xamr1llfdvza2pm8f"))
1636        (file-name (git-file-name "nibbles" version))))
1637     (build-system asdf-build-system/sbcl)
1638     (native-inputs
1639      ;; Tests only.
1640      `(("rt" ,sbcl-rt)))
1641     (synopsis "Common Lisp library for accessing octet-addressed blocks of data")
1642     (description
1643      "When dealing with network protocols and file formats, it's common to
1644 have to read or write 16-, 32-, or 64-bit datatypes in signed or unsigned
1645 flavors.  Common Lisp sort of supports this by specifying :element-type for
1646 streams, but that facility is underspecified and there's nothing similar for
1647 read/write from octet vectors.  What most people wind up doing is rolling their
1648 own small facility for their particular needs and calling it a day.
1649
1650 This library attempts to be comprehensive and centralize such
1651 facilities.  Functions to read 16-, 32-, and 64-bit quantities from octet
1652 vectors in signed or unsigned flavors are provided; these functions are also
1653 SETFable.  Since it's sometimes desirable to read/write directly from streams,
1654 functions for doing so are also provided.  On some implementations,
1655 reading/writing IEEE singles/doubles (i.e. single-float and double-float) will
1656 also be supported.")
1657     (home-page "https://github.com/sharplispers/nibbles")
1658     (license license:bsd-3)))
1659
1660 (define-public cl-nibbles
1661   (sbcl-package->cl-source-package sbcl-nibbles))
1662
1663 (define-public ecl-nibbles
1664   (sbcl-package->ecl-package sbcl-nibbles))
1665
1666 (define-public sbcl-ironclad
1667   (package
1668     (name "sbcl-ironclad")
1669     (version "0.48")
1670     (source
1671      (origin
1672        (method git-fetch)
1673        (uri (git-reference
1674              (url "https://github.com/sharplispers/ironclad/")
1675              (commit (string-append "v" version))))
1676        (sha256
1677         (base32
1678          "1wzczpgvgjc5h8ghz75kxi7iykmqxqchdhgdhkif9j99kyqvbyam"))
1679        (file-name (git-file-name name version))))
1680     (build-system asdf-build-system/sbcl)
1681     (native-inputs
1682      ;; Tests only.
1683      `(("rt" ,sbcl-rt)))
1684     (inputs
1685      `(("bordeaux-threads" ,sbcl-bordeaux-threads)
1686        ("flexi-streams" ,sbcl-flexi-streams)))
1687     (synopsis "Cryptographic toolkit written in Common Lisp")
1688     (description
1689      "Ironclad is a cryptography library written entirely in Common Lisp.
1690 It includes support for several popular ciphers, digests, MACs and public key
1691 cryptography algorithms.  For several implementations that support Gray
1692 streams, support is included for convenient stream wrappers.")
1693     (home-page "https://github.com/sharplispers/ironclad")
1694     (license license:bsd-3)))
1695
1696 (define-public cl-ironclad
1697   (sbcl-package->cl-source-package sbcl-ironclad))
1698
1699 (define-public ecl-ironclad
1700   (sbcl-package->ecl-package sbcl-ironclad))
1701
1702 (define-public sbcl-named-readtables
1703   (let ((commit "4dfb89fa1af6b305b6492b8af042f5190c11e9fc")
1704         (revision "1"))
1705     (package
1706       (name "sbcl-named-readtables")
1707       (version (string-append "0.9-" revision "." (string-take commit 7)))
1708       (source
1709        (origin
1710          (method git-fetch)
1711          (uri (git-reference
1712                (url "https://github.com/melisgl/named-readtables.git")
1713                (commit commit)))
1714          (sha256
1715           (base32 "083kgh5462iqbb4px6kq8s7sggvpvkm36hx4qi9rnaw53b6ilqkk"))
1716          (file-name (git-file-name "named-readtables" version))))
1717       (build-system asdf-build-system/sbcl)
1718       (arguments
1719        ;; Tests seem to be broken.
1720        `(#:tests? #f))
1721       (home-page "https://github.com/melisgl/named-readtables/")
1722       (synopsis "Library that creates a namespace for named readtables")
1723       (description "Named readtables is a library that creates a namespace for
1724 named readtables, which is akin to package namespacing in Common Lisp.")
1725       (license license:bsd-3))))
1726
1727 (define-public cl-named-readtables
1728   (sbcl-package->cl-source-package sbcl-named-readtables))
1729
1730 (define-public ecl-named-readtables
1731   (sbcl-package->ecl-package sbcl-named-readtables))
1732
1733 (define-public sbcl-pythonic-string-reader
1734   (let ((commit "47a70ba1e32362e03dad6ef8e6f36180b560f86a"))
1735     (package
1736       (name "sbcl-pythonic-string-reader")
1737       (version (git-version "0.0.0" "1" commit))
1738       (source
1739        (origin
1740          (method git-fetch)
1741          (uri (git-reference
1742                (url "https://github.com/smithzvk/pythonic-string-reader/")
1743                (commit commit)))
1744          (sha256
1745           (base32 "1b5iryqw8xsh36swckmz8rrngmc39k92si33fgy5pml3n9l5rq3j"))
1746          (file-name (git-file-name "pythonic-string-reader" version))))
1747       (build-system asdf-build-system/sbcl)
1748       (inputs
1749        `(("named-readtables" ,sbcl-named-readtables)))
1750       (home-page "https://github.com/smithzvk/pythonic-string-reader")
1751       (synopsis "Read table modification inspired by Python's three quote strings")
1752       (description "This piece of code sets up some reader macros that make it
1753 simpler to input string literals which contain backslashes and double quotes
1754 This is very useful for writing complicated docstrings and, as it turns out,
1755 writing code that contains string literals that contain code themselves.")
1756       (license license:bsd-3))))
1757
1758 (define-public cl-pythonic-string-reader
1759   (sbcl-package->cl-source-package sbcl-pythonic-string-reader))
1760
1761 (define-public ecl-pythonic-string-reader
1762   (sbcl-package->ecl-package sbcl-pythonic-string-reader))
1763
1764 ;; SLIME does not have a ASDF system definition to build all of Swank.  As a
1765 ;; result, the asdf-build-system/sbcl will produce an almost empty package.
1766 ;; Some work was done to fix this at
1767 ;; https://github.com/sionescu/slime/tree/swank-asdf but it was never merged
1768 ;; and is now lagging behind.  Building SBCL fasls might not be worth the
1769 ;; hassle, so let's just ship the source then.
1770 (define-public cl-slime-swank
1771   (package
1772     (name "cl-slime-swank")
1773     (version "2.24")
1774     (source
1775      (origin
1776        (file-name (string-append name "-" version ".tar.gz"))
1777        (method git-fetch)
1778        (uri (git-reference
1779              (url "https://github.com/slime/slime/")
1780              (commit (string-append "v" version))))
1781        (sha256
1782         (base32
1783          "0js24x42m7b5iymb4rxz501dff19vav5pywnzv50b673rbkaaqvh"))))
1784     (build-system asdf-build-system/source)
1785     (home-page "https://github.com/slime/slime")
1786     (synopsis "Common Lisp Swank server")
1787     (description
1788      "This is only useful if you want to start a Swank server in a Lisp
1789 processes that doesn't run under Emacs.  Lisp processes created by
1790 @command{M-x slime} automatically start the server.")
1791     (license (list license:gpl2+ license:public-domain))))
1792
1793 (define-public sbcl-slime-swank
1794   (deprecated-package "sbcl-slime-swank" cl-slime-swank))
1795
1796 (define-public sbcl-mgl-pax
1797   (let ((commit "818448418d6b9de74620f606f5b23033c6082769"))
1798     (package
1799       (name "sbcl-mgl-pax")
1800       (version (git-version "0.0.0" "1" commit))
1801       (source
1802        (origin
1803          (method git-fetch)
1804          (uri (git-reference
1805                (url "https://github.com/melisgl/mgl-pax")
1806                (commit commit)))
1807          (sha256
1808           (base32
1809            "1p97zfkh130bdxqqxwaw2j9psv58751wakx7czbfpq410lg7dd7i"))
1810          (file-name (git-file-name "mgl-pax" version))))
1811       (build-system asdf-build-system/sbcl)
1812       (inputs
1813        `(("3bmd" ,sbcl-3bmd)
1814          ("3bmd-ext-code-blocks" ,sbcl-3bmd-ext-code-blocks)
1815          ("babel" ,sbcl-babel)
1816          ("cl-fad" ,sbcl-cl-fad)
1817          ("ironclad" ,sbcl-ironclad)
1818          ("named-readtables" ,sbcl-named-readtables)
1819          ("pythonic-string-reader" ,sbcl-pythonic-string-reader)))
1820       (propagated-inputs
1821        ;; Packages having mgl-pax as input complain that it can't find
1822        ;; swank if we put it in inputs, so let's put it in propageted-inputs.
1823        `(("swank" ,cl-slime-swank)))
1824       (synopsis "Exploratory programming environment and documentation generator")
1825       (description
1826        "PAX provides an extremely poor man's Explorable Programming
1827 environment.  Narrative primarily lives in so called sections that mix markdown
1828 docstrings with references to functions, variables, etc, all of which should
1829 probably have their own docstrings.
1830
1831 The primary focus is on making code easily explorable by using SLIME's
1832 @command{M-.} (@command{slime-edit-definition}).  See how to enable some
1833 fanciness in Emacs Integration.  Generating documentation from sections and all
1834 the referenced items in Markdown or HTML format is also implemented.
1835
1836 With the simplistic tools provided, one may accomplish similar effects as with
1837 Literate Programming, but documentation is generated from code, not vice versa
1838 and there is no support for chunking yet.  Code is first, code must look
1839 pretty, documentation is code.")
1840       (home-page "http://quotenil.com/")
1841       (license license:expat))))
1842
1843 (define-public cl-mgl-pax
1844   (sbcl-package->cl-source-package sbcl-mgl-pax))
1845
1846 (define-public ecl-mgl-pax
1847   (sbcl-package->ecl-package sbcl-mgl-pax))
1848
1849 (define-public sbcl-lisp-unit
1850   (let ((commit "89653a232626b67400bf9a941f9b367da38d3815"))
1851     (package
1852       (name "sbcl-lisp-unit")
1853       (version (git-version "0.0.0" "1" commit))
1854       (source
1855        (origin
1856          (method git-fetch)
1857          (uri (git-reference
1858                (url "https://github.com/OdonataResearchLLC/lisp-unit")
1859                (commit commit)))
1860          (sha256
1861           (base32
1862            "0p6gdmgr7p383nvd66c9y9fp2bjk4jx1lpa5p09g43hr9y9pp9ry"))
1863          (file-name (git-file-name "lisp-unit" version))))
1864       (build-system asdf-build-system/sbcl)
1865       (synopsis "Common Lisp Test framework inspired by JUnit to be simple of use")
1866       (description
1867        "@command{lisp-unit} is a Common Lisp library that supports unit
1868 testing.  It is an extension of the library written by Chris Riesbeck.")
1869       (home-page "https://github.com/OdonataResearchLLC/lisp-unit")
1870       (license license:expat))))
1871
1872 (define-public cl-lisp-unit
1873   (sbcl-package->cl-source-package sbcl-lisp-unit))
1874
1875 (define-public ecl-lisp-unit
1876   (sbcl-package->ecl-package sbcl-lisp-unit))
1877
1878 (define-public sbcl-anaphora
1879   (package
1880     (name "sbcl-anaphora")
1881     (version "0.9.6")
1882     (source
1883      (origin
1884        (method git-fetch)
1885        (uri (git-reference
1886              (url "https://github.com/tokenrove/anaphora")
1887              (commit version)))
1888        (sha256
1889         (base32
1890          "19wfrk3asimznkli0x2rfy637hwpdgqyvwj3vhq9x7vjvyf5vv6x"))
1891        (file-name (git-file-name "anaphora" version))))
1892     (build-system asdf-build-system/sbcl)
1893     (native-inputs
1894      `(("rt" ,sbcl-rt)))
1895     (synopsis "The anaphoric macro collection from Hell")
1896     (description
1897      "Anaphora is the anaphoric macro collection from Hell: it includes many
1898 new fiends in addition to old friends like @command{aif} and
1899 @command{awhen}.")
1900     (home-page "https://github.com/tokenrove/anaphora")
1901     (license license:public-domain)))
1902
1903 (define-public cl-anaphora
1904   (sbcl-package->cl-source-package sbcl-anaphora))
1905
1906 (define-public ecl-anaphora
1907   (sbcl-package->ecl-package sbcl-anaphora))
1908
1909 (define-public sbcl-lift
1910   (let ((commit "7d49a66c62759535624037826891152223d4206c"))
1911     (package
1912       (name "sbcl-lift")
1913       (version (git-version "1.7.1" "1" commit))
1914       (source
1915        (origin
1916          (method git-fetch)
1917          (uri (git-reference
1918                (url "https://github.com/gwkkwg/lift")
1919                (commit commit)))
1920          (sha256
1921           (base32
1922            "127v5avpz1i4m0lkaxqrq8hrl69rdazqaxf6s8awf0nd7wj2g4dp"))
1923          (file-name (git-file-name "lift" version))
1924          (modules '((guix build utils)))
1925          (snippet
1926           ;; Don't keep the bundled website
1927           `(begin
1928              (delete-file-recursively "website")
1929              #t))))
1930       (build-system asdf-build-system/sbcl)
1931       (arguments
1932        ;; The tests require a debugger, but we run with the debugger disabled.
1933        '(#:tests? #f))
1934       (synopsis "LIsp Framework for Testing")
1935       (description
1936        "The LIsp Framework for Testing (LIFT) is a unit and system test tool for LISP.
1937 Though inspired by SUnit and JUnit, it's built with Lisp in mind.  In LIFT,
1938 testcases are organized into hierarchical testsuites each of which can have
1939 its own fixture.  When run, a testcase can succeed, fail, or error.  LIFT
1940 supports randomized testing, benchmarking, profiling, and reporting.")
1941       (home-page "https://github.com/gwkkwg/lift")
1942       (license license:expat))))
1943
1944 (define-public cl-lift
1945   (sbcl-package->cl-source-package sbcl-lift))
1946
1947 (define-public ecl-lift
1948   (sbcl-package->ecl-package sbcl-lift))
1949
1950 (define-public sbcl-let-plus
1951   (let ((commit "5f14af61d501ecead02ec6b5a5c810efc0c9fdbb"))
1952     (package
1953       (name "sbcl-let-plus")
1954       (version (git-version "0.0.0" "1" commit))
1955       (source
1956        (origin
1957          (method git-fetch)
1958          (uri (git-reference
1959                (url "https://github.com/sharplispers/let-plus")
1960                (commit commit)))
1961          (sha256
1962           (base32
1963            "0i050ca2iys9f5mb7dgqgqdxfnc3b0rnjdwv95sqd490vkiwrsaj"))
1964          (file-name (git-file-name "let-plus" version))))
1965       (build-system asdf-build-system/sbcl)
1966       (inputs
1967        `(("alexandria" ,sbcl-alexandria)
1968          ("anaphora" ,sbcl-anaphora)))
1969       (native-inputs
1970        `(("lift" ,sbcl-lift)))
1971       (synopsis "Destructuring extension of let*")
1972       (description
1973        "This library implements the let+ macro, which is a dectructuring
1974 extension of let*.  It features:
1975
1976 @itemize
1977 @item Clean, consistent syntax and small implementation (less than 300 LOC,
1978 not counting tests)
1979 @item Placeholder macros allow editor hints and syntax highlighting
1980 @item @command{&ign} for ignored values (in forms where that makes sense)
1981 @item Very easy to extend
1982 @end itemize\n")
1983       (home-page "https://github.com/sharplispers/let-plus")
1984       (license license:boost1.0))))
1985
1986 (define-public cl-let-plus
1987   (sbcl-package->cl-source-package sbcl-let-plus))
1988
1989 (define-public ecl-let-plus
1990   (sbcl-package->ecl-package sbcl-let-plus))
1991
1992 (define-public sbcl-cl-colors
1993   (let ((commit "827410584553f5c717eec6182343b7605f707f75"))
1994     (package
1995       (name "sbcl-cl-colors")
1996       (version (git-version "0.0.0" "1" commit))
1997       (source
1998        (origin
1999          (method git-fetch)
2000          (uri (git-reference
2001                (url "https://github.com/tpapp/cl-colors")
2002                (commit commit)))
2003          (sha256
2004           (base32
2005            "0l446lday4hybsm9bq3jli97fvv8jb1d33abg79vbylpwjmf3y9a"))
2006          (file-name (git-file-name "cl-colors" version))))
2007       (build-system asdf-build-system/sbcl)
2008       (inputs
2009        `(("alexandria" ,sbcl-alexandria)
2010          ("let-plus" ,sbcl-let-plus)))
2011       (synopsis "Simple color library for Common Lisp")
2012       (description
2013        "This is a very simple color library for Common Lisp, providing
2014
2015 @itemize
2016 @item Types for representing colors in HSV and RGB spaces.
2017 @item Simple conversion functions between the above types (and also
2018 hexadecimal representation for RGB).
2019 @item Some predefined colors (currently X11 color names – of course the
2020 library does not depend on X11).Because color in your terminal is nice.
2021 @end itemize
2022
2023 This library is no longer supported by its author.")
2024       (home-page "https://github.com/tpapp/cl-colors")
2025       (license license:boost1.0))))
2026
2027 (define-public cl-colors
2028   (sbcl-package->cl-source-package sbcl-cl-colors))
2029
2030 (define-public ecl-cl-colors
2031   (sbcl-package->ecl-package sbcl-cl-colors))
2032
2033 (define-public sbcl-cl-ansi-text
2034   (let ((commit "53badf7878f27f22f2d4a2a43e6df458e43acbe9"))
2035     (package
2036       (name "sbcl-cl-ansi-text")
2037       (version (git-version "1.0.0" "1" commit))
2038       (source
2039        (origin
2040          (method git-fetch)
2041          (uri (git-reference
2042                (url "https://github.com/pnathan/cl-ansi-text")
2043                (commit commit)))
2044          (sha256
2045           (base32
2046            "11i27n0dbz5lmygiw65zzr8lx0rac6b6yysqranphn31wls6ja3v"))
2047          (file-name (git-file-name "cl-ansi-text" version))))
2048       (build-system asdf-build-system/sbcl)
2049       (inputs
2050        `(("alexandria" ,sbcl-alexandria)
2051          ("cl-colors" ,sbcl-cl-colors)))
2052       (native-inputs
2053        `(("fiveam" ,sbcl-fiveam)))
2054       (synopsis "ANSI terminal color implementation for Common Lisp")
2055       (description
2056        "@command{cl-ansi-text} provides utilities which enable printing to an
2057 ANSI terminal with colored text.  It provides the macro @command{with-color}
2058 which causes everything printed in the body to be displayed with the provided
2059 color.  It further provides functions which will print the argument with the
2060 named color.")
2061       (home-page "https://github.com/pnathan/cl-ansi-text")
2062       (license license:llgpl))))
2063
2064 (define-public cl-ansi-text
2065   (sbcl-package->cl-source-package sbcl-cl-ansi-text))
2066
2067 (define-public ecl-cl-ansi-text
2068   (sbcl-package->ecl-package sbcl-cl-ansi-text))
2069
2070 (define-public sbcl-prove-asdf
2071   (let ((commit "4f9122bd393e63c5c70c1fba23070622317cfaa0"))
2072     (package
2073       (name "sbcl-prove-asdf")
2074       (version (git-version "1.0.0" "1" commit))
2075       (source
2076        (origin
2077          (method git-fetch)
2078          (uri (git-reference
2079                (url "https://github.com/fukamachi/prove")
2080                (commit commit)))
2081          (sha256
2082           (base32
2083            "07sbfw459z8bbjvx1qlmfa8qk2mvbjnnzi2mi0x72blaj8bkl4vc"))
2084          (file-name (git-file-name "prove" version))))
2085       (build-system asdf-build-system/sbcl)
2086       (arguments
2087        `(#:asd-file "prove-asdf.asd"))
2088       (synopsis "Test requirement for the Common Lisp 'prove' library")
2089       (description
2090        "Test requirement for the Common Lisp @command{prove} library.")
2091       (home-page "https://github.com/fukamachi/prove")
2092       (license license:expat))))
2093
2094 (define-public cl-prove-asdf
2095   (sbcl-package->cl-source-package sbcl-prove-asdf))
2096
2097 (define-public ecl-prove-asdf
2098   (sbcl-package->ecl-package sbcl-prove-asdf))
2099
2100 (define-public sbcl-prove
2101   (package
2102     (inherit sbcl-prove-asdf)
2103     (name "sbcl-prove")
2104     (inputs
2105      `(("alexandria" ,sbcl-alexandria)
2106        ("cl-ppcre" ,sbcl-cl-ppcre)
2107        ("cl-ansi-text" ,sbcl-cl-ansi-text)))
2108     (native-inputs
2109      `(("prove-asdf" ,sbcl-prove-asdf)))
2110     (arguments
2111      `(#:asd-file "prove.asd"))
2112     (synopsis "Yet another unit testing framework for Common Lisp")
2113     (description
2114      "This project was originally called @command{cl-test-more}.
2115 @command{prove} is yet another unit testing framework for Common Lisp.  The
2116 advantages of @command{prove} are:
2117
2118 @itemize
2119 @item Various simple functions for testing and informative error messages
2120 @item ASDF integration
2121 @item Extensible test reporters
2122 @item Colorizes the report if it's available (note for SLIME)
2123 @item Reports test durations
2124 @end itemize\n")))
2125
2126 (define-public cl-prove
2127   (sbcl-package->cl-source-package sbcl-prove))
2128
2129 (define-public ecl-prove
2130   (sbcl-package->ecl-package sbcl-prove))
2131
2132 (define-public sbcl-proc-parse
2133   (let ((commit "ac3636834d561bdc2686c956dbd82494537285fd"))
2134     (package
2135       (name "sbcl-proc-parse")
2136       (version (git-version "0.0.0" "1" commit))
2137       (source
2138        (origin
2139          (method git-fetch)
2140          (uri (git-reference
2141                (url "https://github.com/fukamachi/proc-parse")
2142                (commit commit)))
2143          (sha256
2144           (base32
2145            "06rnl0h4cx6xv2wj3jczmmcxqn2703inmmvg1s4npbghmijsybfh"))
2146          (file-name (git-file-name "proc-parse" version))))
2147       (build-system asdf-build-system/sbcl)
2148       (inputs
2149        `(("alexandria" ,sbcl-alexandria)
2150          ("babel" ,sbcl-babel)))
2151       (native-inputs
2152        `(("prove" ,sbcl-prove)
2153          ("prove-asdf" ,sbcl-prove-asdf)))
2154       (arguments
2155        ;; TODO: Tests don't find "proc-parse-test", why?
2156        `(#:tests? #f))
2157       (synopsis "Procedural vector parser")
2158       (description
2159        "This is a string/octets parser library for Common Lisp with speed and
2160 readability in mind.  Unlike other libraries, the code is not a
2161 pattern-matching-like, but a char-by-char procedural parser.")
2162       (home-page "https://github.com/fukamachi/proc-parse")
2163       (license license:bsd-2))))
2164
2165 (define-public cl-proc-parse
2166   (sbcl-package->cl-source-package sbcl-proc-parse))
2167
2168 (define-public ecl-proc-parse
2169   (sbcl-package->ecl-package sbcl-proc-parse))
2170
2171 (define-public sbcl-parse-float
2172   (let ((commit "2aae569f2a4b2eb3bfb5401a959425dcf151b09c"))
2173     (package
2174       (name "sbcl-parse-float")
2175       (version (git-version "0.0.0" "1" commit))
2176       (source
2177        (origin
2178          (method git-fetch)
2179          (uri (git-reference
2180                (url "https://github.com/soemraws/parse-float")
2181                (commit commit)))
2182          (sha256
2183           (base32
2184            "08xw8cchhmqcc0byng69m3f5a2izc9y2290jzz2k0qrbibp1fdk7"))
2185          (file-name (git-file-name "proc-parse" version))))
2186       (build-system asdf-build-system/sbcl)
2187       (inputs
2188        `(("alexandria" ,sbcl-alexandria)
2189          ("babel" ,sbcl-babel)))
2190       (native-inputs
2191        `(("prove" ,sbcl-prove)
2192          ("prove-asdf" ,sbcl-prove-asdf)))
2193       (arguments
2194        ;; TODO: Tests don't find "proc-parse-test", why?
2195        `(#:tests? #f))
2196       (synopsis "Parse a floating point value from a string in Common Lisp")
2197       (description
2198        "This package exports the following function to parse floating-point
2199 values from a string in Common Lisp.")
2200       (home-page "https://github.com/soemraws/parse-float")
2201       (license license:public-domain))))
2202
2203 (define-public cl-parse-float
2204   (sbcl-package->cl-source-package sbcl-parse-float))
2205
2206 (define-public ecl-parse-float
2207   (sbcl-package->ecl-package sbcl-parse-float))
2208
2209 (define-public sbcl-ascii-strings
2210   (let ((revision "1")
2211         (changeset "5048480a61243e6f1b02884012c8f25cdbee6d97"))
2212     (package
2213       (name "sbcl-ascii-strings")
2214       (version (string-append "0-" revision "." (string-take changeset 7)))
2215       (source
2216        (origin
2217          (method hg-fetch)
2218          (uri (hg-reference
2219                (url "https://bitbucket.org/vityok/cl-string-match/")
2220                (changeset changeset)))
2221          (sha256
2222           (base32
2223            "01wn5qx562w43ssy92xlfgv79w7p0nv0wbl76mpmba131n9ziq2y"))
2224          (file-name (git-file-name "cl-string-match" version))))
2225       (build-system asdf-build-system/sbcl)
2226       (inputs
2227        `(("alexandria" ,sbcl-alexandria)
2228          ("babel" ,sbcl-babel)))
2229       (arguments
2230        `(#:asd-file "ascii-strings.asd"))
2231       (synopsis "Operations on ASCII strings")
2232       (description
2233        "Operations on ASCII strings.  Essentially this can be any kind of
2234 single-byte encoded strings.")
2235       (home-page "https://bitbucket.org/vityok/cl-string-match/")
2236       (license license:bsd-3))))
2237
2238 (define-public cl-ascii-strings
2239   (sbcl-package->cl-source-package sbcl-ascii-strings))
2240
2241 (define-public ecl-ascii-strings
2242   (sbcl-package->ecl-package sbcl-ascii-strings))
2243
2244 (define-public sbcl-simple-scanf
2245   (package
2246     (inherit sbcl-ascii-strings)
2247     (name "sbcl-simple-scanf")
2248     (inputs
2249      `(("alexandria" ,sbcl-alexandria)
2250        ("iterate" ,sbcl-iterate)
2251        ("proc-parse" ,sbcl-proc-parse)
2252        ("parse-float" ,sbcl-parse-float)))
2253     (arguments
2254      `(#:asd-file "simple-scanf.asd"))
2255     (synopsis "Simple scanf-like functionality implementation")
2256     (description
2257      "A simple scanf-like functionality implementation.")))
2258
2259 (define-public cl-simple-scanf
2260   (sbcl-package->cl-source-package sbcl-simple-scanf))
2261
2262 (define-public ecl-simple-scanf
2263   (sbcl-package->ecl-package sbcl-simple-scanf))
2264
2265 (define-public sbcl-cl-string-match
2266   (package
2267     (inherit sbcl-ascii-strings)
2268     (name "sbcl-cl-string-match")
2269     (inputs
2270      `(("alexandria" ,sbcl-alexandria)
2271        ("ascii-strings" ,sbcl-ascii-strings)
2272        ("yacc" ,sbcl-cl-yacc)
2273        ("jpl-util" ,sbcl-jpl-util)
2274        ("jpl-queues" ,sbcl-jpl-queues)
2275        ("mgl-pax" ,sbcl-mgl-pax)
2276        ("iterate" ,sbcl-iterate)))
2277     ;; TODO: Tests are not evaluated properly.
2278     (native-inputs
2279      ;; For testing:
2280      `(("lisp-unit" ,sbcl-lisp-unit)
2281        ("simple-scanf" ,sbcl-simple-scanf)))
2282     (arguments
2283      `(#:tests? #f
2284        #:asd-file "cl-string-match.asd"))
2285     (synopsis "Portable, dependency-free set of utilities to manipulate strings in Common Lisp")
2286     (description
2287      "@command{cl-strings} is a small, portable, dependency-free set of
2288 utilities that make it even easier to manipulate text in Common Lisp.  It has
2289 100% test coverage and works at least on sbcl, ecl, ccl, abcl and clisp.")))
2290
2291 (define-public cl-string-match
2292   (sbcl-package->cl-source-package sbcl-cl-string-match))
2293
2294 (define-public ecl-cl-string-match
2295   (sbcl-package->ecl-package sbcl-cl-string-match))
2296
2297 (define-public sbcl-ptester
2298   (package
2299     (name "sbcl-ptester")
2300     (version "20160929")
2301     (source
2302      (origin
2303        (method url-fetch)
2304        (uri (string-append "http://beta.quicklisp.org/archive/ptester/"
2305                            (date->string (string->date version "~Y~m~d") "~Y-~m-~d")
2306                            "/ptester-"
2307                            version
2308                            "-git.tgz"))
2309        (sha256
2310         (base32
2311          "04rlq1zljhxc65pm31bah3sq3as24l0sdivz440s79qlnnyh13hz"))))
2312     (build-system asdf-build-system/sbcl)
2313     (home-page "http://quickdocs.org/ptester/")
2314     (synopsis "Portable test harness package")
2315     (description
2316      "@command{ptester} is a portable testing framework based on Franz's
2317 tester module.")
2318     (license license:lgpl3+)))
2319
2320 (define-public cl-ptester
2321   (sbcl-package->cl-source-package sbcl-ptester))
2322
2323 (define-public ecl-ptester
2324   (sbcl-package->ecl-package sbcl-ptester))
2325
2326 (define-public sbcl-puri
2327   (package
2328     (name "sbcl-puri")
2329     (version "20180228")
2330     (source
2331      (origin
2332        (method url-fetch)
2333        (uri (string-append "http://beta.quicklisp.org/archive/puri/"
2334                            (date->string (string->date version "~Y~m~d") "~Y-~m-~d")
2335                            "/puri-"
2336                            version
2337                            "-git.tgz"))
2338        (sha256
2339         (base32
2340          "1s4r5adrjy5asry45xbcbklxhdjydvf6n55z897nvyw33bigrnbz"))))
2341     (build-system asdf-build-system/sbcl)
2342     ;; REVIEW: Webiste down?
2343     (native-inputs
2344      `(("ptester" ,sbcl-ptester)))
2345     (home-page "http://files.kpe.io/puri/")
2346     (synopsis "Portable URI Library")
2347     (description
2348      "This is portable Universal Resource Identifier library for Common Lisp
2349 programs.  It parses URI according to the RFC 2396 specification")
2350     (license license:lgpl3+)))
2351
2352 (define-public cl-puri
2353   (sbcl-package->cl-source-package sbcl-puri))
2354
2355 (define-public ecl-puri
2356   (sbcl-package->ecl-package sbcl-puri))
2357
2358 (define-public sbcl-queues
2359   (let ((commit "47d4da65e9ea20953b74aeeab7e89a831b66bc94"))
2360     (package
2361       (name "sbcl-queues")
2362       (version (git-version "0.0.0" "1" commit))
2363       (source
2364        (origin
2365          (method git-fetch)
2366          (uri (git-reference
2367                (url "https://github.com/oconnore/queues")
2368                (commit commit)))
2369          (file-name (git-file-name "queues" version))
2370          (sha256
2371           (base32
2372            "0wdhfnzi4v6d97pggzj2aw55si94w4327br94jrmyvwf351wqjvv"))))
2373       (build-system asdf-build-system/sbcl)
2374       (home-page "https://github.com/oconnore/queues")
2375       (synopsis "Common Lisp queue library")
2376       (description
2377        "This is a simple queue library for Common Lisp with features such as
2378 non-consing thread safe queues and fibonacci priority queues.")
2379       (license license:expat))))
2380
2381 (define-public cl-queues
2382   (sbcl-package->cl-source-package sbcl-queues))
2383
2384 (define-public ecl-queues
2385   (sbcl-package->ecl-package sbcl-queues))
2386
2387 (define-public sbcl-queues.simple-queue
2388   (package
2389     (inherit sbcl-queues)
2390     (name "sbcl-queues.simple-queue")
2391     (inputs
2392      `(("sbcl-queues" ,sbcl-queues)))
2393     (arguments
2394      `(#:asd-file "queues.simple-queue.asd"))
2395     (synopsis "Simple queue implementation")
2396     (description
2397      "This is a simple queue library for Common Lisp with features such as
2398 non-consing thread safe queues and fibonacci priority queues.")
2399     (license license:expat)))
2400
2401 (define-public cl-queues.simple-queue
2402   (sbcl-package->cl-source-package sbcl-queues.simple-queue))
2403
2404 (define-public ecl-queues.simple-queue
2405   (sbcl-package->ecl-package sbcl-queues.simple-queue))
2406
2407 (define-public sbcl-queues.simple-cqueue
2408   (package
2409     (inherit sbcl-queues)
2410     (name "sbcl-queues.simple-cqueue")
2411     (inputs
2412      `(("sbcl-queues" ,sbcl-queues)
2413        ("sbcl-queues.simple-queue" ,sbcl-queues.simple-queue)
2414        ("bordeaux-threads" ,sbcl-bordeaux-threads)))
2415     (arguments
2416      `(#:asd-file "queues.simple-cqueue.asd"))
2417     (synopsis "Thread safe queue implementation")
2418     (description
2419      "This is a simple queue library for Common Lisp with features such as
2420 non-consing thread safe queues and fibonacci priority queues.")
2421     (license license:expat)))
2422
2423 (define-public cl-queues.simple-cqueue
2424   (sbcl-package->cl-source-package sbcl-queues.simple-cqueue))
2425
2426 (define-public ecl-queues.simple-cqueue
2427   (sbcl-package->ecl-package sbcl-queues.simple-cqueue))
2428
2429 (define-public sbcl-queues.priority-queue
2430   (package
2431     (inherit sbcl-queues)
2432     (name "sbcl-queues.priority-queue")
2433     (inputs
2434      `(("sbcl-queues" ,sbcl-queues)))
2435     (arguments
2436      `(#:asd-file "queues.priority-queue.asd"))
2437     (synopsis "Priority queue (Fibonacci) implementation")
2438     (description
2439      "This is a simple queue library for Common Lisp with features such as
2440 non-consing thread safe queues and fibonacci priority queues.")
2441     (license license:expat)))
2442
2443 (define-public cl-queues.priority-queue
2444   (sbcl-package->cl-source-package sbcl-queues.priority-queue))
2445
2446 (define-public ecl-queues.priority-queue
2447   (sbcl-package->ecl-package sbcl-queues.priority-queue))
2448
2449 (define-public sbcl-queues.priority-cqueue
2450   (package
2451     (inherit sbcl-queues)
2452     (name "sbcl-queues.priority-cqueue")
2453     (inputs
2454      `(("sbcl-queues" ,sbcl-queues)
2455        ("sbcl-queues.priority-queue" ,sbcl-queues.priority-queue)
2456        ("bordeaux-threads" ,sbcl-bordeaux-threads)))
2457     (arguments
2458      `(#:asd-file "queues.priority-cqueue.asd"))
2459     (synopsis "Thread safe fibonacci priority queue implementation")
2460     (description
2461      "This is a simple queue library for Common Lisp with features such as
2462 non-consing thread safe queues and fibonacci priority queues.")
2463     (license license:expat)))
2464
2465 (define-public cl-queues.priority-cqueue
2466   (sbcl-package->cl-source-package sbcl-queues.priority-cqueue))
2467
2468 (define-public ecl-queues.priority-cqueue
2469   (sbcl-package->ecl-package sbcl-queues.priority-cqueue))
2470
2471 (define sbcl-cffi-bootstrap
2472   (package
2473     (name "sbcl-cffi-bootstrap")
2474     (version "0.21.0")
2475     (source
2476      (origin
2477        (method git-fetch)
2478        (uri (git-reference
2479              (url "https://github.com/cffi/cffi.git")
2480              (commit (string-append "v" version))))
2481        (file-name (git-file-name "cffi-bootstrap" version))
2482        (sha256
2483         (base32 "1qalargz9bhp850qv60ffwpdqi4xirzar4l3g6qcg8yc6xqf2cjk"))))
2484     (build-system asdf-build-system/sbcl)
2485     (inputs
2486      `(("libffi" ,libffi)
2487        ("alexandria" ,sbcl-alexandria)
2488        ("babel" ,sbcl-babel)
2489        ("trivial-features" ,sbcl-trivial-features)))
2490     (native-inputs
2491      `(("pkg-config" ,pkg-config)))
2492     (arguments
2493      '(#:phases
2494        (modify-phases %standard-phases
2495          (add-after 'unpack 'fix-paths
2496            (lambda* (#:key inputs #:allow-other-keys)
2497              (substitute* "libffi/libffi.lisp"
2498                (("libffi.so.6" all) (string-append
2499                                      (assoc-ref inputs "libffi")
2500                                      "/lib/" all)))
2501              (substitute* "toolchain/c-toolchain.lisp"
2502                (("\"cc\"") (format #f "~S" (which "gcc")))))))
2503        #:asd-system-name "cffi"
2504        #:tests? #f))
2505     (home-page "https://common-lisp.net/project/cffi/")
2506     (synopsis "Common Foreign Function Interface for Common Lisp")
2507     (description "The Common Foreign Function Interface (CFFI)
2508 purports to be a portable foreign function interface for Common Lisp.
2509 The CFFI library is composed of a Lisp-implementation-specific backend
2510 in the CFFI-SYS package, and a portable frontend in the CFFI
2511 package.")
2512     (license license:expat)))
2513
2514 (define-public sbcl-cffi-toolchain
2515   (package
2516     (inherit sbcl-cffi-bootstrap)
2517     (name "sbcl-cffi-toolchain")
2518     (inputs
2519      `(("libffi" ,libffi)
2520        ("sbcl-cffi" ,sbcl-cffi-bootstrap)))
2521     (arguments
2522      (substitute-keyword-arguments (package-arguments sbcl-cffi-bootstrap)
2523        ((#:asd-system-name _) #f)
2524        ((#:tests? _) #t)))))
2525
2526 (define-public sbcl-cffi-libffi
2527   (package
2528     (inherit sbcl-cffi-toolchain)
2529     (name "sbcl-cffi-libffi")
2530     (inputs
2531      `(("cffi" ,sbcl-cffi-bootstrap)
2532        ("cffi-grovel" ,sbcl-cffi-grovel)
2533        ("trivial-features" ,sbcl-trivial-features)
2534        ("libffi" ,libffi)))))
2535
2536 (define-public sbcl-cffi-grovel
2537   (package
2538     (inherit sbcl-cffi-toolchain)
2539     (name "sbcl-cffi-grovel")
2540     (inputs
2541      `(("libffi" ,libffi)
2542        ("cffi" ,sbcl-cffi-bootstrap)
2543        ("cffi-toolchain" ,sbcl-cffi-toolchain)
2544        ("alexandria" ,sbcl-alexandria)))
2545     (arguments
2546      (substitute-keyword-arguments (package-arguments sbcl-cffi-toolchain)
2547        ((#:phases phases)
2548         `(modify-phases ,phases
2549            (add-after 'build 'install-headers
2550              (lambda* (#:key outputs #:allow-other-keys)
2551                (install-file "grovel/common.h"
2552                              (string-append
2553                               (assoc-ref outputs "out")
2554                               "/include/grovel"))))))))))
2555
2556 (define-public sbcl-cffi
2557   (package
2558     (inherit sbcl-cffi-toolchain)
2559     (name "sbcl-cffi")
2560     (inputs (package-inputs sbcl-cffi-bootstrap))
2561     (native-inputs
2562      `(("cffi-grovel" ,sbcl-cffi-grovel)
2563        ("cffi-libffi" ,sbcl-cffi-libffi)
2564        ("rt" ,sbcl-rt)
2565        ("bordeaux-threads" ,sbcl-bordeaux-threads)
2566        ,@(package-native-inputs sbcl-cffi-bootstrap)))))
2567
2568 (define-public cl-cffi
2569   (sbcl-package->cl-source-package sbcl-cffi))
2570
2571 (define-public sbcl-cl-sqlite
2572   (let ((commit "c738e66d4266ef63a1debc4ef4a1b871a068c112"))
2573     (package
2574       (name "sbcl-cl-sqlite")
2575       (version (git-version "0.2" "1" commit))
2576       (source
2577        (origin
2578          (method git-fetch)
2579          (uri (git-reference
2580                (url "https://github.com/dmitryvk/cl-sqlite")
2581                (commit commit)))
2582          (file-name (git-file-name "cl-sqlite" version))
2583          (sha256
2584           (base32
2585            "1ng45k1hdb84sqjryrfx93g66bsbybmpy301wd0fdybnc5jzr36q"))))
2586       (build-system asdf-build-system/sbcl)
2587       (inputs
2588        `(("iterate" ,sbcl-iterate)
2589          ("cffi" ,sbcl-cffi)
2590          ("sqlite" ,sqlite)))
2591       (native-inputs
2592        `(("fiveam" ,sbcl-fiveam)
2593          ("bordeaux-threads" ,sbcl-bordeaux-threads)))
2594       (arguments
2595        `(#:tests? #f                    ; Upstream seems to have issues with tests: https://github.com/dmitryvk/cl-sqlite/issues/7
2596          #:asd-file "sqlite.asd"
2597          #:asd-system-name "sqlite"
2598          #:phases
2599          (modify-phases %standard-phases
2600            (add-after 'unpack 'fix-paths
2601              (lambda* (#:key inputs #:allow-other-keys)
2602                (substitute* "sqlite-ffi.lisp"
2603                  (("libsqlite3" all) (string-append
2604                                       (assoc-ref inputs "sqlite")"/lib/" all))))))))
2605       (home-page "https://common-lisp.net/project/cl-sqlite/")
2606       (synopsis "Common Lisp binding for SQLite")
2607       (description
2608        "The @command{cl-sqlite} package is an interface to the SQLite embedded
2609 relational database engine.")
2610       (license license:public-domain))))
2611
2612 (define-public cl-sqlite
2613   (sbcl-package->cl-source-package sbcl-cl-sqlite))
2614
2615 (define-public sbcl-parenscript
2616   (let ((commit "061d8e286c81c3f45c84fb2b11ee7d83f590a8f8"))
2617     (package
2618       (name "sbcl-parenscript")
2619       (version (git-version "2.6" "1" commit))
2620       (source
2621        (origin
2622          (method git-fetch)
2623          (uri (git-reference
2624                (url "https://gitlab.common-lisp.net/parenscript/parenscript")
2625                (commit commit)))
2626          (file-name (git-file-name "parenscript" version))
2627          (sha256
2628           (base32
2629            "1kbhgsjbikc73m5cwdp4d4fdafyqcr1b7b630qjrziql0nh6mi3k"))))
2630       (build-system asdf-build-system/sbcl)
2631       (inputs
2632        `(("cl-ppcre" ,sbcl-cl-ppcre)
2633          ("anaphora" ,sbcl-anaphora)
2634          ("named-readtables" ,sbcl-named-readtables)))
2635       (home-page "https://common-lisp.net/project/parenscript/")
2636       (synopsis "Translator from a subset of Common Lisp to JavaScript")
2637       (description
2638        "Parenscript is a translator from an extended subset of Common Lisp to
2639 JavaScript.  Parenscript code can run almost identically on both the
2640 browser (as JavaScript) and server (as Common Lisp).
2641
2642 Parenscript code is treated the same way as Common Lisp code, making the full
2643 power of Lisp macros available for JavaScript.  This provides a web
2644 development environment that is unmatched in its ability to reduce code
2645 duplication and provide advanced meta-programming facilities to web
2646 developers.
2647
2648 At the same time, Parenscript is different from almost all other \"language
2649 X\" to JavaScript translators in that it imposes almost no overhead:
2650
2651 @itemize
2652 @item No run-time dependencies: Any piece of Parenscript code is runnable
2653 as-is.  There are no JavaScript files to include.
2654 @item Native types: Parenscript works entirely with native JavaScript data
2655 types.  There are no new types introduced, and object prototypes are not
2656 touched.
2657 @item Native calling convention: Any JavaScript code can be called without the
2658 need for bindings.  Likewise, Parenscript can be used to make efficient,
2659 self-contained JavaScript libraries.
2660 @item Readable code: Parenscript generates concise, formatted, idiomatic
2661 JavaScript code.  Identifier names are preserved.  This enables seamless
2662 debugging in tools like Firebug.
2663 @item Efficiency: Parenscript introduces minimal overhead for advanced Common
2664 Lisp features.  The generated code is almost as fast as hand-written
2665 JavaScript.
2666 @end itemize\n")
2667       (license license:bsd-3))))
2668
2669 (define-public cl-parenscript
2670   (sbcl-package->cl-source-package sbcl-parenscript))
2671
2672 (define-public ecl-parenscript
2673   (sbcl-package->ecl-package sbcl-parenscript))
2674
2675 (define-public sbcl-cl-json
2676   (let ((commit "6dfebb9540bfc3cc33582d0c03c9ec27cb913e79"))
2677     (package
2678       (name "sbcl-cl-json")
2679       (version (git-version "0.5" "1" commit))
2680       (source
2681        (origin
2682          (method git-fetch)
2683          (uri (git-reference
2684                (url "https://github.com/hankhero/cl-json")
2685                (commit commit)))
2686          (file-name (git-file-name "cl-json" version))
2687          (sha256
2688           (base32
2689            "0fx3m3x3s5ji950yzpazz4s0img3l6b3d6l3jrfjv0lr702496lh"))))
2690       (build-system asdf-build-system/sbcl)
2691       (native-inputs
2692        `(("fiveam" ,sbcl-fiveam)))
2693       (home-page "https://github.com/hankhero/cl-json")
2694       (synopsis "JSON encoder and decoder for Common-Lisp")
2695       (description
2696        "@command{cl-json} provides an encoder of Lisp objects to JSON format
2697 and a corresponding decoder of JSON data to Lisp objects.  Both the encoder
2698 and the decoder are highly customizable; at the same time, the default
2699 settings ensure a very simple mode of operation, similar to that provided by
2700 @command{yason} or @command{st-json}.")
2701       (license license:expat))))
2702
2703 (define-public cl-json
2704   (sbcl-package->cl-source-package sbcl-cl-json))
2705
2706 (define-public ecl-cl-json
2707   (sbcl-package->ecl-package sbcl-cl-json))
2708
2709 (define-public sbcl-unix-opts
2710   (package
2711     (name "sbcl-unix-opts")
2712     (version "0.1.7")
2713     (source
2714      (origin
2715        (method git-fetch)
2716        (uri (git-reference
2717              (url "https://github.com/libre-man/unix-opts")
2718              (commit version)))
2719        (file-name (git-file-name "unix-opts" version))
2720        (sha256
2721         (base32
2722          "08djdi1ard09fijb7w9bdmhmwd98b1hzmcnjw9fqjiqa0g3b44rr"))))
2723     (build-system asdf-build-system/sbcl)
2724     (home-page "https://github.com/hankhero/cl-json")
2725     (synopsis "Unix-style command line options parser")
2726     (description
2727      "This is a minimalistic parser of command line options.  The main
2728 advantage of the library is the ability to concisely define command line
2729 options once and then use this definition for parsing and extraction of
2730 command line arguments, as well as printing description of command line
2731 options (you get --help for free).  This way you don't need to repeat
2732 yourself.  Also, @command{unix-opts} doesn't depend on anything and allows to
2733 precisely control behavior of the parser via Common Lisp restarts.")
2734     (license license:expat)))
2735
2736 (define-public cl-unix-opts
2737   (sbcl-package->cl-source-package sbcl-unix-opts))
2738
2739 (define-public ecl-unix-opts
2740   (sbcl-package->ecl-package sbcl-unix-opts))
2741
2742 (define-public sbcl-trivial-garbage
2743   (package
2744     (name "sbcl-trivial-garbage")
2745     (version "0.21")
2746     (source
2747      (origin
2748        (method git-fetch)
2749        (uri (git-reference
2750              (url "https://github.com/trivial-garbage/trivial-garbage.git")
2751              (commit (string-append "v" version))))
2752        (file-name (git-file-name "trivial-garbage" version))
2753        (sha256
2754         (base32 "0122jicfg7pca1wxw8zak1n92h5friqy60988ns0ysksj3fphw9n"))))
2755     (build-system asdf-build-system/sbcl)
2756     (native-inputs
2757      `(("rt" ,sbcl-rt)))
2758     (home-page "https://common-lisp.net/project/trivial-garbage/")
2759     (synopsis "Portable GC-related APIs for Common Lisp")
2760     (description "@command{trivial-garbage} provides a portable API to
2761 finalizers, weak hash-tables and weak pointers on all major implementations of
2762 the Common Lisp programming language.")
2763     (license license:public-domain)))
2764
2765 (define-public cl-trivial-garbage
2766   (sbcl-package->cl-source-package sbcl-trivial-garbage))
2767
2768 (define-public ecl-trivial-garbage
2769   (sbcl-package->ecl-package sbcl-trivial-garbage))
2770
2771 (define-public sbcl-closer-mop
2772   (let ((commit "fac29ce90e3a46e1fc6cf182190e193526fa9dbc"))
2773     (package
2774       (name "sbcl-closer-mop")
2775       (version (git-version  "1.0.0" "1" commit))
2776       (source
2777        (origin
2778          (method git-fetch)
2779          (uri (git-reference
2780                (url "https://github.com/pcostanza/closer-mop")
2781                (commit commit)))
2782          (sha256
2783           (base32 "0hvh77y869h8fg9di5snyg85fxq6fdh9gj1igmx1g6j6j5x915dl"))
2784          (file-name (git-file-name "closer-mop" version ))))
2785       (build-system asdf-build-system/sbcl)
2786       (home-page "https://github.com/pcostanza/closer-mop")
2787       (synopsis "Rectifies absent or incorrect CLOS MOP features")
2788       (description "Closer to MOP is a compatibility layer that rectifies many
2789 of the absent or incorrect CLOS MOP features across a broad range of Common
2790 Lisp implementations.")
2791       (license license:expat))))
2792
2793 (define-public cl-closer-mop
2794   (sbcl-package->cl-source-package sbcl-closer-mop))
2795
2796 (define-public ecl-closer-mop
2797   (sbcl-package->ecl-package sbcl-closer-mop))
2798
2799 (define sbcl-cl-cffi-gtk-boot0
2800   (let ((commit "29443c5aaca975709df8025c4649366d882033cb"))
2801     (package
2802       (name "sbcl-cl-cffi-gtk-boot0")
2803       (version (git-version "0.11.2" "1" commit))
2804       (source
2805        (origin
2806          (method git-fetch)
2807          (uri (git-reference
2808                (url "https://github.com/Ferada/cl-cffi-gtk/")
2809                (commit commit)))
2810          (file-name (git-file-name "cl-cffi-gtk" version))
2811          (sha256
2812           (base32
2813            "0f6s92sf8xyzh1yksqx8bsy1sv0zmy0c13j3b8bavaba5hlxpxah"))))
2814       (build-system asdf-build-system/sbcl)
2815       (inputs
2816        `(("iterate" ,sbcl-iterate)
2817          ("cffi" ,sbcl-cffi)
2818          ("trivial-features" ,sbcl-trivial-features)))
2819       (home-page "https://github.com/Ferada/cl-cffi-gtk/")
2820       (synopsis "Common Lisp binding for GTK+3")
2821       (description
2822        "@command{cl-cffi-gtk} is a Lisp binding to GTK+ 3 (GIMP Toolkit) which
2823 is a library for creating graphical user interfaces.")
2824       (license license:lgpl3))))
2825
2826 (define-public sbcl-cl-cffi-gtk-glib
2827   (package
2828     (inherit sbcl-cl-cffi-gtk-boot0)
2829     (name "sbcl-cl-cffi-gtk-glib")
2830     (inputs
2831      `(("glib" ,glib)
2832        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2833     (arguments
2834      `(#:asd-file "glib/cl-cffi-gtk-glib.asd"
2835        #:phases
2836        (modify-phases %standard-phases
2837          (add-after 'unpack 'fix-paths
2838            (lambda* (#:key inputs #:allow-other-keys)
2839              (substitute* "glib/glib.init.lisp"
2840                (("libglib|libgthread" all) (string-append
2841                                             (assoc-ref inputs "glib") "/lib/" all))))))))))
2842
2843 (define-public sbcl-cl-cffi-gtk-gobject
2844   (package
2845     (inherit sbcl-cl-cffi-gtk-boot0)
2846     (name "sbcl-cl-cffi-gtk-gobject")
2847     (inputs
2848      `(("glib" ,glib)
2849        ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
2850        ("trivial-garbage" ,sbcl-trivial-garbage)
2851        ("bordeaux-threads" ,sbcl-bordeaux-threads)
2852        ("closer-mop" ,sbcl-closer-mop)
2853        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2854     (arguments
2855      `(#:asd-file "gobject/cl-cffi-gtk-gobject.asd"
2856        #:phases
2857        (modify-phases %standard-phases
2858          (add-after 'unpack 'fix-paths
2859            (lambda* (#:key inputs #:allow-other-keys)
2860              (substitute* "gobject/gobject.init.lisp"
2861                (("libgobject" all) (string-append
2862                                     (assoc-ref inputs "glib") "/lib/" all))))))))))
2863
2864 (define-public sbcl-cl-cffi-gtk-gio
2865   (package
2866     (inherit sbcl-cl-cffi-gtk-boot0)
2867     (name "sbcl-cl-cffi-gtk-gio")
2868     (inputs
2869      `(("glib" ,glib)
2870        ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
2871        ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
2872        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2873     (arguments
2874      `(#:asd-file "gio/cl-cffi-gtk-gio.asd"
2875        #:phases
2876        (modify-phases %standard-phases
2877          (add-after 'unpack 'fix-paths
2878            (lambda* (#:key inputs #:allow-other-keys)
2879              (substitute* "gio/gio.init.lisp"
2880                (("libgio" all)
2881                 (string-append
2882                  (assoc-ref inputs "glib") "/lib/" all))))))))))
2883
2884 (define-public sbcl-cl-cffi-gtk-cairo
2885   (package
2886     (inherit sbcl-cl-cffi-gtk-boot0)
2887     (name "sbcl-cl-cffi-gtk-cairo")
2888     (inputs
2889      `(("cairo" ,cairo)
2890        ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
2891        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2892     (arguments
2893      `(#:asd-file "cairo/cl-cffi-gtk-cairo.asd"
2894        #:phases
2895        (modify-phases %standard-phases
2896          (add-after 'unpack 'fix-paths
2897            (lambda* (#:key inputs #:allow-other-keys)
2898              (substitute* "cairo/cairo.init.lisp"
2899                (("libcairo" all)
2900                 (string-append
2901                  (assoc-ref inputs "cairo") "/lib/" all))))))))))
2902
2903 (define-public sbcl-cl-cffi-gtk-pango
2904   (package
2905     (inherit sbcl-cl-cffi-gtk-boot0)
2906     (name "sbcl-cl-cffi-gtk-pango")
2907     (inputs
2908      `(("pango" ,pango)
2909        ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
2910        ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
2911        ("cl-cffi-gtk-cairo" ,sbcl-cl-cffi-gtk-cairo)
2912        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2913     (arguments
2914      `(#:asd-file "pango/cl-cffi-gtk-pango.asd"
2915        #:phases
2916        (modify-phases %standard-phases
2917          (add-after 'unpack 'fix-paths
2918            (lambda* (#:key inputs #:allow-other-keys)
2919              (substitute* "pango/pango.init.lisp"
2920                (("libpango" all)
2921                 (string-append
2922                  (assoc-ref inputs "pango") "/lib/" all))))))))))
2923
2924 (define-public sbcl-cl-cffi-gtk-gdk-pixbuf
2925   (package
2926     (inherit sbcl-cl-cffi-gtk-boot0)
2927     (name "sbcl-cl-cffi-gtk-gdk-pixbuf")
2928     (inputs
2929      `(("gdk-pixbuf" ,gdk-pixbuf)
2930        ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
2931        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2932     (arguments
2933      `(#:asd-file "gdk-pixbuf/cl-cffi-gtk-gdk-pixbuf.asd"
2934        #:phases
2935        (modify-phases %standard-phases
2936          (add-after 'unpack 'fix-paths
2937            (lambda* (#:key inputs #:allow-other-keys)
2938              (substitute* "gdk-pixbuf/gdk-pixbuf.init.lisp"
2939                (("libgdk_pixbuf" all)
2940                 (string-append
2941                  (assoc-ref inputs "gdk-pixbuf") "/lib/" all))))))))))
2942
2943 (define-public sbcl-cl-cffi-gtk-gdk
2944   (package
2945     (inherit sbcl-cl-cffi-gtk-boot0)
2946     (name "sbcl-cl-cffi-gtk-gdk")
2947     (inputs
2948      `(("gtk" ,gtk+)
2949        ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
2950        ("cl-cffi-gtk-gio" ,sbcl-cl-cffi-gtk-gio)
2951        ("cl-cffi-gtk-gdk-pixbuf" ,sbcl-cl-cffi-gtk-gdk-pixbuf)
2952        ("cl-cffi-gtk-cairo" ,sbcl-cl-cffi-gtk-cairo)
2953        ("cl-cffi-gtk-pango" ,sbcl-cl-cffi-gtk-pango)
2954        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2955     (arguments
2956      `(#:asd-file "gdk/cl-cffi-gtk-gdk.asd"
2957        #:phases
2958        (modify-phases %standard-phases
2959          (add-after 'unpack 'fix-paths
2960            (lambda* (#:key inputs #:allow-other-keys)
2961              (substitute* "gdk/gdk.init.lisp"
2962                (("libgdk" all)
2963                 (string-append
2964                  (assoc-ref inputs "gtk") "/lib/" all)))
2965              (substitute* "gdk/gdk.package.lisp"
2966                (("libgtk" all)
2967                 (string-append
2968                  (assoc-ref inputs "gtk") "/lib/" all))))))))))
2969
2970 (define-public sbcl-cl-cffi-gtk
2971   (package
2972     (inherit sbcl-cl-cffi-gtk-boot0)
2973     (name "sbcl-cl-cffi-gtk")
2974     (inputs
2975      `(("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
2976        ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
2977        ("cl-cffi-gtk-gio" ,sbcl-cl-cffi-gtk-gio)
2978        ("cl-cffi-gtk-gdk" ,sbcl-cl-cffi-gtk-gdk)
2979        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2980     (native-inputs
2981      `(("fiveam" ,sbcl-fiveam)))
2982     (arguments
2983      `(#:asd-file "gtk/cl-cffi-gtk.asd"
2984        #:test-asd-file "test/cl-cffi-gtk-test.asd"
2985        ;; TODO: Tests fail with memory fault.
2986        ;; See https://github.com/Ferada/cl-cffi-gtk/issues/24.
2987        #:tests? #f))))
2988
2989 (define-public cl-cffi-gtk
2990   (sbcl-package->cl-source-package sbcl-cl-cffi-gtk))
2991
2992 (define-public sbcl-cl-webkit
2993   (let ((commit "cd2a9008e0c152e54755e8a7f07b050fe36bab31"))
2994     (package
2995       (name "sbcl-cl-webkit")
2996       (version (git-version "2.4" "1" commit))
2997       (source
2998        (origin
2999          (method git-fetch)
3000          (uri (git-reference
3001                (url "https://github.com/jmercouris/cl-webkit")
3002                (commit commit)))
3003          (file-name (git-file-name "cl-webkit" version))
3004          (sha256
3005           (base32
3006            "0f5lyn9i7xrn3g1bddga377mcbawkbxydijpg389q4n04gqj0vwf"))))
3007       (build-system asdf-build-system/sbcl)
3008       (inputs
3009        `(("cffi" ,sbcl-cffi)
3010          ("cl-cffi-gtk" ,sbcl-cl-cffi-gtk)
3011          ("webkitgtk" ,webkitgtk)))
3012       (arguments
3013        `(#:asd-file "webkit2/cl-webkit2.asd"
3014          #:asd-system-name "cl-webkit2"
3015          #:phases
3016          (modify-phases %standard-phases
3017            (add-after 'unpack 'fix-paths
3018              (lambda* (#:key inputs #:allow-other-keys)
3019                (substitute* "webkit2/webkit2.init.lisp"
3020                  (("libwebkit2gtk" all)
3021                   (string-append
3022                    (assoc-ref inputs "webkitgtk") "/lib/" all))))))))
3023       (home-page "https://github.com/jmercouris/cl-webkit")
3024       (synopsis "Binding to WebKitGTK+ for Common Lisp")
3025       (description
3026        "@command{cl-webkit} is a binding to WebKitGTK+ for Common Lisp,
3027 currently targeting WebKit version 2.  The WebKitGTK+ library adds web
3028 browsing capabilities to an application, leveraging the full power of the
3029 WebKit browsing engine.")
3030       (license license:expat))))
3031
3032 (define-public cl-webkit
3033   (sbcl-package->cl-source-package sbcl-cl-webkit))
3034
3035 (define-public sbcl-lparallel
3036   (package
3037     (name "sbcl-lparallel")
3038     (version "2.8.4")
3039     (source
3040      (origin
3041        (method git-fetch)
3042        (uri (git-reference
3043              (url "https://github.com/lmj/lparallel/")
3044              (commit (string-append "lparallel-" version))))
3045        (file-name (git-file-name "lparallel" version))
3046        (sha256
3047         (base32
3048          "0g0aylrbbrqsz0ahmwhvnk4cmc2931fllbpcfgzsprwnqqd7vwq9"))))
3049     (build-system asdf-build-system/sbcl)
3050     (inputs
3051      `(("alexandria" ,sbcl-alexandria)
3052        ("bordeaux-threads" ,sbcl-bordeaux-threads)
3053        ("trivial-garbage" ,sbcl-trivial-garbage)))
3054     (home-page "https://lparallel.org/")
3055     (synopsis "Parallelism for Common Lisp")
3056     (description
3057      "@command{lparallel} is a library for parallel programming in Common
3058 Lisp, featuring:
3059
3060 @itemize
3061 @item a simple model of task submission with receiving queue,
3062 @item constructs for expressing fine-grained parallelism,
3063 @item asynchronous condition handling across thread boundaries,
3064 @item parallel versions of map, reduce, sort, remove, and many others,
3065 @item promises, futures, and delayed evaluation constructs,
3066 @item computation trees for parallelizing interconnected tasks,
3067 @item bounded and unbounded FIFO queues,
3068 @item high and low priority tasks,
3069 @item task killing by category,
3070 @item integrated timeouts.
3071 @end itemize\n")
3072     (license license:expat)))
3073
3074 (define-public cl-lparallel
3075   (sbcl-package->cl-source-package sbcl-lparallel))
3076
3077 (define-public ecl-lparallel
3078   (sbcl-package->ecl-package sbcl-lparallel))
3079
3080 (define-public sbcl-cl-markup
3081   (let ((commit "e0eb7debf4bdff98d1f49d0f811321a6a637b390"))
3082     (package
3083       (name "sbcl-cl-markup")
3084       (version (git-version "0.1" "1" commit))
3085       (source
3086        (origin
3087          (method git-fetch)
3088          (uri (git-reference
3089                (url "https://github.com/arielnetworks/cl-markup/")
3090                (commit commit)))
3091          (file-name (git-file-name "cl-markup" version))
3092          (sha256
3093           (base32
3094            "10l6k45971dl13fkdmva7zc6i453lmq9j4xax2ci6pjzlc6xjhp7"))))
3095       (build-system asdf-build-system/sbcl)
3096       (home-page "https://github.com/arielnetworks/cl-markup/")
3097       (synopsis "Markup generation library for Common Lisp")
3098       (description
3099        "A modern markup generation library for Common Lisp that features:
3100
3101 @itemize
3102 @item Fast (even faster through compiling the code)
3103 @item Safety
3104 @item Support for multiple document types (markup, xml, html, html5, xhtml)
3105 @item Output with doctype
3106 @item Direct output to stream
3107 @end itemize\n")
3108       (license license:lgpl3+))))
3109
3110 (define-public cl-markup
3111   (sbcl-package->cl-source-package sbcl-cl-markup))
3112
3113 (define-public ecl-cl-markup
3114   (sbcl-package->ecl-package sbcl-cl-markup))
3115
3116 (define-public sbcl-cl-css
3117   (let ((commit "8fe654c8f0cf95b300718101cce4feb517f78e2f"))
3118     (package
3119       (name "sbcl-cl-css")
3120       (version (git-version "0.1" "1" commit))
3121       (source
3122        (origin
3123          (method git-fetch)
3124          (uri (git-reference
3125                (url "https://github.com/inaimathi/cl-css/")
3126                (commit commit)))
3127          (file-name (git-file-name "cl-css" version))
3128          (sha256
3129           (base32
3130            "1lc42zi2sw11fl2589sc19nr5sd2p0wy7wgvgwaggxa5f3ajhsmd"))))
3131       (build-system asdf-build-system/sbcl)
3132       (home-page "https://github.com/inaimathi/cl-css/")
3133       (synopsis "Non-validating, inline CSS generator for Common Lisp")
3134       (description
3135        "This is a dead-simple, non validating, inline CSS generator for Common
3136 Lisp.  Its goals are axiomatic syntax, simple implementation to support
3137 portability, and boilerplate reduction in CSS.")
3138       (license license:expat))))
3139
3140 (define-public cl-css
3141   (sbcl-package->cl-source-package sbcl-cl-css))
3142
3143 (define-public ecl-cl-css
3144   (sbcl-package->ecl-package sbcl-cl-css))
3145
3146 (define-public sbcl-portable-threads
3147   (let ((commit "c0e61a1faeb0583c80fd3f20b16cc4c555226920"))
3148     (package
3149       (name "sbcl-portable-threads")
3150       (version (git-version "2.3" "1" commit))
3151       (source
3152        (origin
3153          (method git-fetch)
3154          (uri (git-reference
3155                (url "https://github.com/binghe/portable-threads/")
3156                (commit commit)))
3157          (file-name (git-file-name "portable-threads" version))
3158          (sha256
3159           (base32
3160            "03fmxyarc0xf4kavwkfa0a2spkyfrz6hbgbi9y4q7ny5aykdyfaq"))))
3161       (build-system asdf-build-system/sbcl)
3162       (arguments
3163        `(;; Tests seem broken.
3164          #:tests? #f))
3165       (home-page "https://github.com/binghe/portable-threads")
3166       (synopsis "Portable threads (and scheduled and periodic functions) API for Common Lisp")
3167       (description
3168        "Portable Threads (and Scheduled and Periodic Functions) API for Common
3169 Lisp (from GBBopen project).")
3170       (license license:asl2.0))))
3171
3172 (define-public cl-portable-threads
3173   (sbcl-package->cl-source-package sbcl-portable-threads))
3174
3175 (define-public ecl-portable-threada
3176   (sbcl-package->ecl-package sbcl-portable-threads))
3177
3178 (define sbcl-usocket-boot0
3179   ;; usocket's test rely on usocket-server which depends on usocket itself.
3180   ;; We break this cyclic dependency with -boot0 that packages usocket.
3181   (package
3182     (name "sbcl-usocket-boot0")
3183     (version "0.8.3")
3184     (source
3185      (origin
3186        (method git-fetch)
3187        (uri (git-reference
3188              (url "https://github.com/usocket/usocket/")
3189              (commit (string-append "v" version))))
3190        (file-name (git-file-name "usocket" version))
3191        (sha256
3192         (base32
3193          "0x746wr2324l6bn7skqzgkzcbj5kd0zp2ck0c8rldrw0rzabg826"))))
3194     (build-system asdf-build-system/sbcl)
3195     (inputs
3196      `(("split-sequence" ,sbcl-split-sequence)))
3197     (arguments
3198      `(#:tests? #f
3199        #:asd-system-name "usocket"))
3200     (home-page "https://common-lisp.net/project/usocket/")
3201     (synopsis "Universal socket library for Common Lisp (server side)")
3202     (description
3203      "This library strives to provide a portable TCP/IP and UDP/IP socket
3204 interface for as many Common Lisp implementations as possible, while keeping
3205 the abstraction and portability layer as thin as possible.")
3206     (license license:expat)))
3207
3208 (define-public sbcl-usocket-server
3209   (package
3210     (inherit sbcl-usocket-boot0)
3211     (name "sbcl-usocket-server")
3212     (inputs
3213      `(("bordeaux-threads" ,sbcl-bordeaux-threads)
3214        ("usocket" ,sbcl-usocket-boot0)))
3215     (arguments
3216      '(#:asd-system-name "usocket-server"))
3217     (synopsis "Universal socket library for Common Lisp (server side)")))
3218
3219 (define-public cl-usocket-server
3220   (sbcl-package->cl-source-package sbcl-usocket-server))
3221
3222 (define-public ecl-socket-server
3223   (sbcl-package->ecl-package sbcl-usocket-server))
3224
3225 (define-public sbcl-usocket
3226   (package
3227     (inherit sbcl-usocket-boot0)
3228     (name "sbcl-usocket")
3229     (arguments
3230      ;; FIXME: Tests need network access?
3231      `(#:tests? #f))
3232     (native-inputs
3233      ;; Testing only.
3234      `(("usocket-server" ,sbcl-usocket-server)
3235        ("rt" ,sbcl-rt)))))
3236
3237 (define-public cl-usocket
3238   (sbcl-package->cl-source-package sbcl-usocket))
3239
3240 (define-public ecl-usocket
3241   (sbcl-package->ecl-package sbcl-usocket))
3242
3243 (define-public sbcl-s-xml
3244   (package
3245     (name "sbcl-s-xml")
3246     (version "3")
3247     (source
3248      (origin
3249        (method url-fetch)
3250        (uri "https://common-lisp.net/project/s-xml/s-xml.tgz")
3251        (sha256
3252         (base32
3253          "061qcr0dzshsa38s5ma4ay924cwak2nq9gy59dw6v9p0qb58nzjf"))))
3254     (build-system asdf-build-system/sbcl)
3255     (home-page "https://common-lisp.net/project/s-xml/")
3256     (synopsis "Simple XML parser implemented in Common Lisp")
3257     (description
3258      "S-XML is a simple XML parser implemented in Common Lisp.  This XML
3259 parser implementation has the following features:
3260
3261 @itemize
3262 @item It works (handling many common XML usages).
3263 @item It is very small (the core is about 700 lines of code, including
3264 comments and whitespace).
3265 @item It has a core API that is simple, efficient and pure functional, much
3266 like that from SSAX (see also http://ssax.sourceforge.net).
3267 @item It supports different DOM models: an XSML-based one, an LXML-based one
3268 and a classic xml-element struct based one.
3269 @item It is reasonably time and space efficient (internally avoiding garbage
3270 generatation as much as possible).
3271 @item It does support CDATA.
3272 @item It should support the same character sets as your Common Lisp
3273 implementation.
3274 @item It does support XML name spaces.
3275 @end itemize
3276
3277 This XML parser implementation has the following limitations:
3278
3279 @itemize
3280 @item It does not support any special tags (like processing instructions).
3281 @item It is not validating, even skips DTD's all together.
3282 @end itemize\n")
3283     (license license:lgpl3+)))
3284
3285 (define-public cl-s-xml
3286   (sbcl-package->cl-source-package sbcl-s-xml))
3287
3288 (define-public ecl-s-xml
3289   (sbcl-package->ecl-package sbcl-s-xml))
3290
3291 (define-public sbcl-s-xml-rpc
3292   (package
3293     (name "sbcl-s-xml-rpc")
3294     (version "7")
3295     (source
3296      (origin
3297        (method url-fetch)
3298        (uri "https://common-lisp.net/project/s-xml-rpc/s-xml-rpc.tgz")
3299        (sha256
3300         (base32
3301          "02z7k163d51v0pzk8mn1xb6h5s6x64gjqkslhwm3a5x26k2gfs11"))))
3302     (build-system asdf-build-system/sbcl)
3303     (inputs
3304      `(("s-xml" ,sbcl-s-xml)))
3305     (home-page "https://common-lisp.net/project/s-xml-rpc/")
3306     (synopsis "Implementation of XML-RPC in Common Lisp for both client and server")
3307     (description
3308      "S-XML-RPC is an implementation of XML-RPC in Common Lisp for both
3309 client and server.")
3310     (license license:lgpl3+)))
3311
3312 (define-public cl-s-xml-rpc
3313   (sbcl-package->cl-source-package sbcl-s-xml-rpc))
3314
3315 (define-public ecl-s-xml-rpc
3316   (sbcl-package->ecl-package sbcl-s-xml-rpc))
3317
3318 (define-public sbcl-trivial-clipboard
3319   (let ((commit "5af3415d1484e6d69a1b5c178f24680d9fd01796"))
3320     (package
3321       (name "sbcl-trivial-clipboard")
3322       (version (git-version "0.0.0.0" "2" commit))
3323       (source
3324        (origin
3325          (method git-fetch)
3326          (uri (git-reference
3327                (url "https://github.com/snmsts/trivial-clipboard")
3328                (commit commit)))
3329          (file-name (git-file-name "trivial-clipboard" version))
3330          (sha256
3331           (base32
3332            "1gb515z5yq6h5548pb1fwhmb0hhq1ssyb78pvxh4alq799xipxs9"))))
3333       (build-system asdf-build-system/sbcl)
3334       (inputs
3335        `(("xclip" ,xclip)))
3336       (native-inputs
3337        `(("fiveam" ,sbcl-fiveam)))
3338       (arguments
3339        `(#:phases
3340          (modify-phases %standard-phases
3341            (add-after 'unpack 'fix-paths
3342              (lambda* (#:key inputs #:allow-other-keys)
3343                (substitute* "src/text.lisp"
3344                  (("\\(executable-find \"xclip\"\\)")
3345                   (string-append "(executable-find \""
3346                                  (assoc-ref inputs "xclip")
3347                                  "/bin/xclip\")"))))))))
3348       (home-page "https://github.com/snmsts/trivial-clipboard")
3349       (synopsis "Access system clipboard in Common Lisp")
3350       (description
3351        "@command{trivial-clipboard} gives access to the system clipboard.")
3352       (license license:expat))))
3353
3354 (define-public cl-trivial-clipboard
3355   (sbcl-package->cl-source-package sbcl-trivial-clipboard))
3356
3357 (define-public ecl-trivial-clipboard
3358   (sbcl-package->ecl-package sbcl-trivial-clipboard))
3359
3360 (define-public sbcl-trivial-backtrace
3361   (let ((commit "ca81c011b86424a381a7563cea3b924f24e6fbeb")
3362         (revision "1"))
3363     (package
3364      (name "sbcl-trivial-backtrace")
3365      (version (git-version "0.0.0" revision commit))
3366      (source
3367       (origin
3368        (method git-fetch)
3369        (uri (git-reference
3370              (url "https://github.com/gwkkwg/trivial-backtrace.git")
3371              (commit commit)))
3372        (file-name (git-file-name "trivial-backtrace" version))
3373        (sha256
3374         (base32 "10p41p43skj6cimdg8skjy7372s8v2xpkg8djjy0l8rm45i654k1"))))
3375      (build-system asdf-build-system/sbcl)
3376      (inputs
3377       `(("sbcl-lift" ,sbcl-lift)))
3378      (arguments
3379       `(#:phases
3380         (modify-phases %standard-phases
3381           (add-after 'check 'delete-test-results
3382             (lambda* (#:key outputs #:allow-other-keys)
3383               (let ((test-results (string-append (assoc-ref outputs "out")
3384                                                  "/share/common-lisp/"
3385                                                  (%lisp-type) "-source"
3386                                                  "/trivial-backtrace"
3387                                                  "/test-results")))
3388                 (when (file-exists? test-results)
3389                   (delete-file-recursively test-results)))
3390               #t)))))
3391      (home-page "https://common-lisp.net/project/trivial-backtrace/")
3392      (synopsis "Portable simple API to work with backtraces in Common Lisp")
3393      (description
3394       "On of the many things that didn't quite get into the Common Lisp
3395 standard was how to get a Lisp to output its call stack when something has
3396 gone wrong.  As such, each Lisp has developed its own notion of what to
3397 display, how to display it, and what sort of arguments can be used to
3398 customize it.  @code{trivial-backtrace} is a simple solution to generating a
3399 backtrace portably.")
3400      (license license:expat))))
3401
3402 (define-public cl-trivial-backtrace
3403   (sbcl-package->cl-source-package sbcl-trivial-backtrace))
3404
3405 (define-public sbcl-rfc2388
3406   (let ((commit "591bcf7e77f2c222c43953a80f8c297751dc0c4e")
3407         (revision "1"))
3408     (package
3409      (name "sbcl-rfc2388")
3410      (version (git-version "0.0.0" revision commit))
3411      (source
3412       (origin
3413        (method git-fetch)
3414        (uri (git-reference
3415              (url "https://github.com/jdz/rfc2388.git")
3416              (commit commit)))
3417        (file-name (git-file-name "rfc2388" version))
3418        (sha256
3419         (base32 "0phh5n3clhl9ji8jaxrajidn22d3f0aq87mlbfkkxlnx2pnw694k"))))
3420      (build-system asdf-build-system/sbcl)
3421      (home-page "https://github.com/jdz/rfc2388/")
3422      (synopsis "An implementation of RFC 2388 in Common Lisp")
3423      (description
3424       "This package contains an implementation of RFC 2388, which is used to
3425 process form data posted with HTTP POST method using enctype
3426 \"multipart/form-data\".")
3427      (license license:bsd-2))))
3428
3429 (define-public cl-rfc2388
3430   (sbcl-package->cl-source-package sbcl-rfc2388))
3431
3432 (define-public sbcl-md5
3433   (package
3434     (name "sbcl-md5")
3435     (version "2.0.4")
3436     (source
3437      (origin
3438        (method url-fetch)
3439        (uri (string-append
3440              "https://github.com/pmai/md5/archive/release-" version ".tar.gz"))
3441        (sha256
3442         (base32 "19yl9n0pjdz5gw4qi711lka97xcd9f81ylg434hk7jwn9f2s6w11"))))
3443     (build-system asdf-build-system/sbcl)
3444     (home-page "https://github.com/pmai/md5")
3445     (synopsis
3446      "Common Lisp implementation of the MD5 Message-Digest Algorithm (RFC 1321)")
3447     (description
3448      "This package implements The MD5 Message-Digest Algorithm, as defined in
3449 RFC 1321 by R. Rivest, published April 1992.")
3450     (license license:public-domain)))
3451
3452 (define-public cl-md5
3453   (sbcl-package->cl-source-package sbcl-md5))
3454
3455 (define-public sbcl-cl+ssl
3456   (let ((commit "141ae91416bc40f1618dc07e48429b84388aa599")
3457         (revision "1"))
3458     (package
3459       (name "sbcl-cl+ssl")
3460       (version (git-version "0.0.0" revision commit))
3461       (source
3462        (origin
3463          (method git-fetch)
3464          (uri (git-reference
3465                (url "https://github.com/cl-plus-ssl/cl-plus-ssl.git")
3466                (commit commit)))
3467          (file-name (git-file-name "cl+ssl" version))
3468          (sha256
3469           (base32 "1s0hg1h9sf8q89v0yrxmzg5f5sng29rgx3n21r9h9yql8351myan"))))
3470       (build-system asdf-build-system/sbcl)
3471       (arguments
3472        '(#:phases
3473          (modify-phases %standard-phases
3474            (add-after 'unpack 'fix-paths
3475              (lambda* (#:key inputs #:allow-other-keys)
3476                (substitute* "src/reload.lisp"
3477                  (("libssl.so" all)
3478                   (string-append
3479                    (assoc-ref inputs "openssl") "/lib/" all))))))))
3480       (inputs
3481        `(("openssl" ,openssl)
3482          ("sbcl-cffi" ,sbcl-cffi)
3483          ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)
3484          ("sbcl-flexi-streams" ,sbcl-flexi-streams)
3485          ("sbcl-bordeaux-threads" ,sbcl-bordeaux-threads)
3486          ("sbcl-trivial-garbage" ,sbcl-trivial-garbage)
3487          ("sbcl-alexandria" ,sbcl-alexandria)
3488          ("sbcl-trivial-features" ,sbcl-trivial-features)))
3489       (home-page "http://common-lisp.net/project/cl-plus-ssl/")
3490       (synopsis "Common Lisp bindings to OpenSSL")
3491       (description
3492        "This library is a fork of SSL-CMUCL.  The original SSL-CMUCL source
3493 code was written by Eric Marsden and includes contributions by Jochen Schmidt.
3494 Development into CL+SSL was done by David Lichteblau.")
3495       (license license:expat))))
3496
3497 (define-public cl-cl+ssl
3498   (sbcl-package->cl-source-package sbcl-cl+ssl))
3499
3500 (define-public sbcl-kmrcl
3501   (let ((version "1.109.0")
3502         (commit "5260068b2eb735af6796740c2db4955afac21636")
3503         (revision "1"))
3504     (package
3505       (name "sbcl-kmrcl")
3506       (version (git-version version revision commit))
3507       (source
3508        (origin
3509          (method git-fetch)
3510          (uri (git-reference
3511                (url "http://git.kpe.io/kmrcl.git/")
3512                (commit commit)))
3513          (file-name (git-file-name name version))
3514          (sha256
3515           (base32 "1va7xjgzfv674bpsli674i7zj3f7wg5kxic41kz18r6hh4n52dfv"))))
3516       (build-system asdf-build-system/sbcl)
3517       (arguments
3518        ;; Tests fail with: :FORCE and :FORCE-NOT arguments not allowed in a
3519        ;; nested call to ASDF/OPERATE:OPERATE unless identically to toplevel
3520        '(#:tests? #f))
3521       (inputs
3522        `(("sbcl-rt" ,sbcl-rt)))
3523       (home-page "http://files.kpe.io/kmrcl/")
3524       (synopsis "General utilities for Common Lisp programs")
3525       (description
3526        "KMRCL is a collection of utilities used by a number of Kevin
3527 Rosenberg's CL packages.")
3528       (license license:llgpl))))
3529
3530 (define-public cl-kmrcl
3531   (sbcl-package->cl-source-package sbcl-kmrcl))
3532
3533 (define-public sbcl-cl-base64
3534   (let ((version "3.3.3"))
3535     (package
3536       (name "sbcl-cl-base64")
3537       (version version)
3538       (source
3539        (origin
3540          (method git-fetch)
3541          (uri (git-reference
3542                (url "http://git.kpe.io/cl-base64.git")
3543                (commit (string-append "v" version))))
3544          (file-name (git-file-name "cl-base64" version))
3545          (sha256
3546           (base32 "1dw6j7n6gsd2qa0p0rbsjxj00acxx3i9ca1qkgl0liy8lpnwkypl"))))
3547       (build-system asdf-build-system/sbcl)
3548       (arguments
3549        ;; Tests fail with: :FORCE and :FORCE-NOT arguments not allowed
3550        ;; in a nested call to ASDF/OPERATE:OPERATE unless identically
3551        ;; to toplevel
3552        '(#:tests? #f))
3553       (inputs
3554        `(("sbcl-ptester" ,sbcl-ptester)
3555          ("sbcl-kmrcl" ,sbcl-kmrcl)))
3556       (home-page "http://files.kpe.io/cl-base64/")
3557       (synopsis
3558        "Common Lisp package to encode and decode base64 with URI support")
3559       (description
3560        "This package provides highly optimized base64 encoding and decoding.
3561 Besides conversion to and from strings, integer conversions are supported.
3562 Encoding with Uniform Resource Identifiers is supported by using a modified
3563 encoding table that uses only URI-compatible characters.")
3564       (license license:bsd-3))))
3565
3566 (define-public cl-base64
3567   (sbcl-package->cl-source-package sbcl-cl-base64))
3568
3569 (define-public sbcl-chunga
3570   (package
3571     (name "sbcl-chunga")
3572     (version "1.1.7")
3573     (source
3574      (origin
3575        (method git-fetch)
3576        (uri (git-reference
3577               (url "https://github.com/edicl/chunga.git")
3578               (commit (string-append "v" version))))
3579        (file-name (git-file-name name version))
3580        (sha256
3581         (base32 "0jzn3nyb3f22gm983rfk99smqs3mhb9ivjmasvhq9qla5cl9pyhd"))))
3582     (build-system asdf-build-system/sbcl)
3583     (inputs
3584      `(("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)))
3585     (home-page "https://edicl.github.io/chunga/")
3586     (synopsis "Portable chunked streams for Common Lisp")
3587     (description
3588      "Chunga implements streams capable of chunked encoding on demand as
3589 defined in RFC 2616.")
3590     (license license:bsd-2)))
3591
3592 (define-public cl-chunga
3593   (sbcl-package->cl-source-package sbcl-chunga))
3594
3595 (define-public sbcl-cl-who
3596   (let ((version "1.1.4")
3597         (commit "2c08caa4bafba720409af9171feeba3f32e86d32")
3598         (revision "1"))
3599     (package
3600       (name "sbcl-cl-who")
3601       (version (git-version version revision commit))
3602       (source
3603        (origin
3604          (method git-fetch)
3605          (uri (git-reference
3606                (url "https://github.com/edicl/cl-who.git")
3607                (commit commit)))
3608          (file-name (git-file-name name version))
3609          (sha256
3610           (base32
3611            "0yjb6sr3yazm288m318kqvj9xk8rm9n1lpimgf65ymqv0i5agxsb"))))
3612       (build-system asdf-build-system/sbcl)
3613       (native-inputs
3614        `(("sbcl-flexi-streams" ,sbcl-flexi-streams)))
3615       (home-page "https://edicl.github.io/cl-who/")
3616       (synopsis "Yet another Lisp markup language")
3617       (description
3618        "There are plenty of Lisp Markup Languages out there - every Lisp
3619 programmer seems to write at least one during his career - and CL-WHO (where
3620 WHO means \"with-html-output\" for want of a better acronym) is probably just
3621 as good or bad as the next one.")
3622       (license license:bsd-2))))
3623
3624 (define-public cl-cl-who
3625   (sbcl-package->cl-source-package sbcl-cl-who))
3626
3627 (define-public sbcl-chipz
3628   (let ((version "0.8")
3629         (commit "75dfbc660a5a28161c57f115adf74c8a926bfc4d")
3630         (revision "1"))
3631     (package
3632       (name "sbcl-chipz")
3633       (version (git-version version revision commit))
3634       (source
3635        (origin
3636          (method git-fetch)
3637          (uri (git-reference
3638                (url "https://github.com/froydnj/chipz.git")
3639                (commit commit)))
3640          (file-name (git-file-name name version))
3641          (sha256
3642           (base32
3643            "0plx4rs39zbs4gjk77h4a2q11zpy75fh9v8hnxrvsf8fnakajhwg"))))
3644       (build-system asdf-build-system/sbcl)
3645       (native-inputs
3646        `(("sbcl-flexi-streams" ,sbcl-flexi-streams)))
3647       (home-page "http://method-combination.net/lisp/chipz/")
3648       (synopsis
3649        "Common Lisp library for decompressing deflate, zlib, gzip, and bzip2
3650 data")
3651       (description
3652        "DEFLATE data, defined in RFC1951, forms the core of popular
3653 compression formats such as zlib (RFC 1950) and gzip (RFC 1952).  As such,
3654 Chipz also provides for decompressing data in those formats as well.  BZIP2 is
3655 the format used by the popular compression tool bzip2.")
3656       ;; The author describes it as "MIT-like"
3657       (license license:expat))))
3658
3659 (define-public cl-chipz
3660   (sbcl-package->cl-source-package sbcl-chipz))
3661
3662 (define-public sbcl-drakma
3663   (package
3664     (name "sbcl-drakma")
3665     (version "2.0.7")
3666     (source
3667      (origin
3668        (method git-fetch)
3669        (uri (git-reference
3670              (url "https://github.com/edicl/drakma.git")
3671              (commit (string-append "v" version))))
3672        (file-name (git-file-name name version))
3673        (sha256
3674         (base32
3675          "1441idnyif9xzx3ln1p3fg36k2v9h4wasjqrzc8y52j61420qpci"))))
3676     (build-system asdf-build-system/sbcl)
3677     (inputs
3678      `(("sbcl-puri" ,sbcl-puri)
3679        ("sbcl-cl-base64" ,sbcl-cl-base64)
3680        ("sbcl-chunga" ,sbcl-chunga)
3681        ("sbcl-flexi-streams" ,sbcl-flexi-streams)
3682        ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
3683        ("sbcl-chipz" ,sbcl-chipz)
3684        ("sbcl-usocket" ,sbcl-usocket)
3685        ("sbcl-cl+ssl" ,sbcl-cl+ssl)))
3686     (native-inputs
3687      `(("sbcl-fiveam" ,sbcl-fiveam)))
3688     (home-page "https://edicl.github.io/drakma/")
3689     (synopsis "HTTP client written in Common Lisp")
3690     (description
3691      "Drakma is a full-featured HTTP client implemented in Common Lisp.  It
3692 knows how to handle HTTP/1.1 chunking, persistent connections, re-usable
3693 sockets, SSL, continuable uploads, file uploads, cookies, and more.")
3694     (license license:bsd-2)))
3695
3696 (define-public cl-drakma
3697   (sbcl-package->cl-source-package sbcl-drakma))
3698
3699 (define-public ecl-drakma
3700   (sbcl-package->ecl-package sbcl-drakma))
3701
3702 (define-public sbcl-hunchentoot
3703   (package
3704     (name "sbcl-hunchentoot")
3705     (version "1.2.38")
3706     (source
3707      (origin
3708        (method git-fetch)
3709        (uri (git-reference
3710              (url "https://github.com/edicl/hunchentoot.git")
3711              (commit (string-append "v" version))))
3712        (file-name (git-file-name "hunchentoot" version))
3713        (sha256
3714         (base32 "1anpcad7w045m4rsjs1f3xdhjwx5cppq1h0vlb3q7dz81fi3i6yq"))))
3715     (build-system asdf-build-system/sbcl)
3716     (native-inputs
3717      `(("sbcl-cl-who" ,sbcl-cl-who)
3718        ("sbcl-drakma" ,sbcl-drakma)))
3719     (inputs
3720      `(("sbcl-chunga" ,sbcl-chunga)
3721        ("sbcl-cl-base64" ,sbcl-cl-base64)
3722        ("sbcl-cl-fad" ,sbcl-cl-fad)
3723        ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
3724        ("sbcl-flexi-streams" ,sbcl-flexi-streams)
3725        ("sbcl-cl+ssl" ,sbcl-cl+ssl)
3726        ("sbcl-md5" ,sbcl-md5)
3727        ("sbcl-rfc2388" ,sbcl-rfc2388)
3728        ("sbcl-trivial-backtrace" ,sbcl-trivial-backtrace)
3729        ("sbcl-usocket" ,sbcl-usocket)))
3730     (home-page "https://edicl.github.io/hunchentoot/")
3731     (synopsis "Web server written in Common Lisp")
3732     (description
3733      "Hunchentoot is a web server written in Common Lisp and at the same
3734 time a toolkit for building dynamic websites.  As a stand-alone web server,
3735 Hunchentoot is capable of HTTP/1.1 chunking (both directions), persistent
3736 connections (keep-alive), and SSL.")
3737     (license license:bsd-2)))
3738
3739 (define-public cl-hunchentoot
3740   (sbcl-package->cl-source-package sbcl-hunchentoot))
3741
3742 (define-public sbcl-trivial-types
3743   (package
3744     (name "sbcl-trivial-types")
3745     (version "0.0.1")
3746     (source
3747      (origin
3748        (method git-fetch)
3749        (uri (git-reference
3750              (url "https://github.com/m2ym/trivial-types.git")
3751              (commit "ee869f2b7504d8aa9a74403641a5b42b16f47d88")))
3752        (file-name (git-file-name name version))
3753        (sha256
3754         (base32 "1s4cp9bdlbn8447q7w7f1wkgwrbvfzp20mgs307l5pxvdslin341"))))
3755     (build-system asdf-build-system/sbcl)
3756     (home-page "https://github.com/m2ym/trivial-types")
3757     (synopsis "Trivial type definitions for Common Lisp")
3758     (description
3759      "TRIVIAL-TYPES provides missing but important type definitions such as
3760 PROPER-LIST, ASSOCIATION-LIST, PROPERTY-LIST and TUPLE.")
3761     (license license:llgpl)))
3762
3763 (define-public cl-trivial-types
3764   (sbcl-package->cl-source-package sbcl-trivial-types))
3765
3766 (define-public sbcl-cl-syntax
3767   (package
3768     (name "sbcl-cl-syntax")
3769     (version "0.0.3")
3770     (source
3771      (origin
3772        (method git-fetch)
3773        (uri (git-reference
3774              (url "https://github.com/m2ym/cl-syntax.git")
3775              (commit "03f0c329bbd55b8622c37161e6278366525e2ccc")))
3776        (file-name (git-file-name "cl-syntax" version))
3777        (sha256
3778         (base32 "17ran8xp77asagl31xv8w819wafh6whwfc9p6dgx22ca537gyl4y"))))
3779     (build-system asdf-build-system/sbcl)
3780     (arguments
3781      '(#:asd-file "cl-syntax.asd"
3782        #:asd-system-name "cl-syntax"))
3783     (inputs `(("sbcl-trivial-types" ,sbcl-trivial-types)
3784               ("sbcl-named-readtables" ,sbcl-named-readtables)))
3785     (home-page "https://github.com/m2ym/cl-syntax")
3786     (synopsis "Reader Syntax Coventions for Common Lisp and SLIME")
3787     (description
3788      "CL-SYNTAX provides Reader Syntax Coventions for Common Lisp and SLIME.")
3789     (license license:llgpl)))
3790
3791 (define-public cl-syntax
3792   (sbcl-package->cl-source-package sbcl-cl-syntax))
3793
3794 (define-public sbcl-cl-annot
3795   (let ((commit "c99e69c15d935eabc671b483349a406e0da9518d")
3796         (revision "1"))
3797     (package
3798       (name "sbcl-cl-annot")
3799       (version (git-version "0.0.0" revision commit))
3800       (source
3801        (origin
3802          (method git-fetch)
3803          (uri (git-reference
3804                (url "https://github.com/m2ym/cl-annot.git")
3805                (commit commit)))
3806          (file-name (git-file-name name version))
3807          (sha256
3808           (base32 "1wq1gs9jjd5m6iwrv06c2d7i5dvqsfjcljgbspfbc93cg5xahk4n"))))
3809       (build-system asdf-build-system/sbcl)
3810     (arguments
3811      '(#:asd-file "cl-annot.asd"
3812        #:asd-system-name "cl-annot"))
3813       (inputs
3814        `(("sbcl-alexandria" ,sbcl-alexandria)))
3815       (home-page "https://github.com/m2ym/cl-annot")
3816       (synopsis "Python-like Annotation Syntax for Common Lisp.")
3817       (description
3818        "@code{cl-annot} is an general annotation library for Common Lisp.")
3819       (license license:llgpl))))
3820
3821 (define-public cl-annot
3822   (sbcl-package->cl-source-package sbcl-cl-annot))
3823
3824 (define-public sbcl-cl-syntax-annot
3825   (package
3826     (name "sbcl-cl-syntax-annot")
3827     (version "0.0.3")
3828     (source
3829      (origin
3830        (method git-fetch)
3831        (uri (git-reference
3832              (url "https://github.com/m2ym/cl-syntax.git")
3833              (commit "03f0c329bbd55b8622c37161e6278366525e2ccc")))
3834        (file-name (git-file-name name version))
3835        (sha256
3836         (base32 "17ran8xp77asagl31xv8w819wafh6whwfc9p6dgx22ca537gyl4y"))))
3837     (build-system asdf-build-system/sbcl)
3838     (arguments
3839      '(#:asd-file "cl-syntax-annot.asd"
3840        #:asd-system-name "cl-syntax-annot"))
3841     (inputs
3842      `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
3843        ("sbcl-cl-annot" ,sbcl-cl-annot)))
3844     (home-page "https://github.com/m2ym/cl-syntax")
3845     (synopsis "Reader Syntax Coventions for Common Lisp and SLIME")
3846     (description
3847      "CL-SYNTAX provides Reader Syntax Coventions for Common Lisp and
3848 SLIME.")
3849     (license license:llgpl)))
3850
3851 (define-public cl-syntax-annot
3852   (sbcl-package->cl-source-package sbcl-cl-syntax-annot))
3853
3854 (define-public sbcl-cl-utilities
3855   (let ((commit "dce2d2f6387091ea90357a130fa6d13a6776884b")
3856         (revision "1"))
3857     (package
3858       (name "sbcl-cl-utilities")
3859       (version (git-version "0.0.0" revision commit))
3860       (source
3861        (origin
3862          (method url-fetch)
3863          (uri
3864           (string-append
3865            "https://gitlab.common-lisp.net/cl-utilities/cl-utilities/-/"
3866            "archive/" commit "/cl-utilities-" commit ".tar.gz"))
3867          (sha256
3868           (base32 "1r46v730yf96nk2vb24qmagv9x96xvd08abqwhf02ghgydv1a7z2"))))
3869       (build-system asdf-build-system/sbcl)
3870       (arguments
3871        '(#:asd-file "cl-utilities.asd"
3872          #:asd-system-name "cl-utilities"
3873          #:phases
3874          (modify-phases %standard-phases
3875            (add-after 'unpack 'fix-paths
3876              (lambda* (#:key inputs #:allow-other-keys)
3877                (substitute* "rotate-byte.lisp"
3878                  (("in-package :cl-utilities)" all)
3879                   "in-package :cl-utilities)\n\n#+sbcl\n(require :sb-rotate-byte)")))))))
3880       (home-page "http://common-lisp.net/project/cl-utilities")
3881       (synopsis "A collection of semi-standard utilities")
3882       (description
3883        "On Cliki.net <http://www.cliki.net/Common%20Lisp%20Utilities>, there
3884 is a collection of Common Lisp Utilities, things that everybody writes since
3885 they're not part of the official standard.  There are some very useful things
3886 there; the only problems are that they aren't implemented as well as you'd
3887 like (some aren't implemented at all) and they aren't conveniently packaged
3888 and maintained.  It takes quite a bit of work to carefully implement utilities
3889 for common use, commented and documented, with error checking placed
3890 everywhere some dumb user might make a mistake.")
3891       (license license:public-domain))))
3892
3893 (define-public cl-utilities
3894   (sbcl-package->cl-source-package sbcl-cl-utilities))
3895
3896 (define-public sbcl-map-set
3897   (let ((commit "7b4b545b68b8")
3898         (revision "1"))
3899     (package
3900       (name "sbcl-map-set")
3901       (version (git-version "0.0.0" revision commit))
3902       (source
3903        (origin
3904          (method url-fetch)
3905          (uri (string-append
3906                "https://bitbucket.org/tarballs_are_good/map-set/get/"
3907                commit ".tar.gz"))
3908          (sha256
3909           (base32 "1sx5j5qdsy5fklspfammwb16kjrhkggdavm922a9q86jm5l0b239"))))
3910       (build-system asdf-build-system/sbcl)
3911       (home-page "https://bitbucket.org/tarballs_are_good/map-set")
3912       (synopsis "Set-like data structure")
3913       (description
3914        "Implementation of a set-like data structure with constant time
3915 addition, removal, and random selection.")
3916       (license license:bsd-3))))
3917
3918 (define-public cl-map-set
3919   (sbcl-package->cl-source-package sbcl-map-set))
3920
3921 (define-public sbcl-quri
3922   (let ((commit "76b75103f21ead092c9f715512fa82441ef61185")
3923         (revision "1"))
3924     (package
3925       (name "sbcl-quri")
3926       (version (git-version "0.1.0" revision commit))
3927       (source
3928        (origin
3929          (method git-fetch)
3930          (uri (git-reference
3931                (url "https://github.com/fukamachi/quri.git")
3932                (commit commit)))
3933          (file-name (git-file-name name version))
3934          (sha256
3935           (base32 "1ccbxsgzdibmzq33mmbmmz9vwl6l03xh6nbpsh1hkdvdcl7q0a60"))))
3936       (build-system asdf-build-system/sbcl)
3937       (arguments
3938        ;; Tests fail with: Component QURI-ASD::QURI-TEST not found,
3939        ;; required by #<SYSTEM "quri">. Why?
3940        '(#:tests? #f))
3941       (native-inputs `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
3942                        ("sbcl-prove" ,sbcl-prove)))
3943       (inputs `(("sbcl-babel" ,sbcl-babel)
3944                 ("sbcl-split-sequence" ,sbcl-split-sequence)
3945                 ("sbcl-cl-utilities" ,sbcl-cl-utilities)
3946                 ("sbcl-alexandria" ,sbcl-alexandria)))
3947       (home-page "https://github.com/fukamachi/quri")
3948       (synopsis "Yet another URI library for Common Lisp")
3949       (description
3950        "QURI (pronounced \"Q-ree\") is yet another URI library for Common
3951 Lisp. It is intended to be a replacement of PURI.")
3952       (license license:bsd-3))))
3953
3954 (define-public cl-quri
3955   (sbcl-package->cl-source-package sbcl-quri))
3956
3957 (define-public sbcl-myway
3958   (let ((commit "286230082a11f879c18b93f17ca571c5f676bfb7")
3959         (revision "1"))
3960     (package
3961      (name "sbcl-myway")
3962      (version (git-version "0.1.0" revision commit))
3963      (source
3964       (origin
3965        (method git-fetch)
3966        (uri (git-reference
3967              (url "https://github.com/fukamachi/myway.git")
3968              (commit commit)))
3969        (file-name (git-file-name "myway" version))
3970        (sha256
3971         (base32 "0briia9bk3lbr0frnx39d1qg6i38dm4j6z9w3yga3d40k6df4a90"))))
3972      (build-system asdf-build-system/sbcl)
3973      (arguments
3974       ;; Tests fail with: Component MYWAY-ASD::MYWAY-TEST not found, required
3975       ;; by #<SYSTEM "myway">. Why?
3976       '(#:tests? #f))
3977      (native-inputs
3978       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
3979         ("sbcl-prove" ,sbcl-prove)))
3980      (inputs
3981       `(("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
3982         ("sbcl-quri" ,sbcl-quri)
3983         ("sbcl-map-set" ,sbcl-map-set)))
3984      (home-page "https://github.com/fukamachi/myway")
3985      (synopsis "Sinatra-compatible URL routing library for Common Lisp")
3986      (description "My Way is a Sinatra-compatible URL routing library.")
3987      (license license:llgpl))))
3988
3989 (define-public cl-myway
3990   (sbcl-package->cl-source-package sbcl-myway))
3991
3992 (define-public sbcl-xsubseq
3993   (let ((commit "5ce430b3da5cda3a73b9cf5cee4df2843034422b")
3994         (revision "1"))
3995     (package
3996      (name "sbcl-xsubseq")
3997      (version (git-version "0.0.1" revision commit))
3998      (source
3999       (origin
4000        (method git-fetch)
4001        (uri (git-reference
4002              (url "https://github.com/fukamachi/xsubseq")
4003              (commit commit)))
4004        (file-name (git-file-name name version))
4005        (sha256
4006         (base32 "1xz79q0p2mclf3sqjiwf6izdpb6xrsr350bv4mlmdlm6rg5r99px"))))
4007      (build-system asdf-build-system/sbcl)
4008      (arguments
4009       ;; Tests fail with: Component XSUBSEQ-ASD::XSUBSEQ-TEST not found,
4010       ;; required by #<SYSTEM "xsubseq">. Why?
4011       '(#:tests? #f))
4012      (native-inputs
4013       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4014         ("sbcl-prove" ,sbcl-prove)))
4015      (home-page "https://github.com/fukamachi/xsubseq")
4016      (synopsis "Efficient way to use \"subseq\"s in Common Lisp")
4017      (description
4018       "XSubseq provides functions to be able to handle \"subseq\"s more
4019 effieiently.")
4020      (license license:bsd-2))))
4021
4022 (define-public cl-xsubseq
4023   (sbcl-package->cl-source-package sbcl-xsubseq))
4024
4025 (define-public sbcl-smart-buffer
4026   (let ((commit "09b9a9a0b3abaa37abe9a730f5aac2643dca4e62")
4027         (revision "1"))
4028     (package
4029       (name "sbcl-smart-buffer")
4030       (version (git-version "0.0.1" revision commit))
4031       (source
4032        (origin
4033          (method git-fetch)
4034          (uri (git-reference
4035                (url "https://github.com/fukamachi/smart-buffer")
4036                (commit commit)))
4037          (file-name (git-file-name name version))
4038          (sha256
4039           (base32 "0qz1zzxx0wm5ff7gpgsq550a59p0qj594zfmm2rglj97dahj54l7"))))
4040       (build-system asdf-build-system/sbcl)
4041       (arguments
4042        ;; Tests fail with: Component SMART-BUFFER-ASD::SMART-BUFFER-TEST not
4043        ;; found, required by #<SYSTEM "smart-buffer">. Why?
4044        `(#:tests? #f))
4045       (native-inputs
4046        `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4047          ("sbcl-prove" ,sbcl-prove)))
4048       (inputs
4049        `(("sbcl-xsubseq" ,sbcl-xsubseq)
4050          ("sbcl-flexi-streams" ,sbcl-flexi-streams)))
4051       (home-page "https://github.com/fukamachi/smart-buffer")
4052       (synopsis "Smart octets buffer")
4053       (description
4054        "Smart-buffer provides an output buffer which changes the destination
4055 depending on content size.")
4056       (license license:bsd-3))))
4057
4058 (define-public cl-smart-buffer
4059   (sbcl-package->cl-source-package sbcl-smart-buffer))
4060
4061 (define-public sbcl-fast-http
4062   (let ((commit "f9e7597191bae380503e20724fd493a24d024935")
4063         (revision "1"))
4064     (package
4065       (name "sbcl-fast-http")
4066       (version (git-version "0.2.0" revision commit))
4067       (source
4068        (origin
4069          (method git-fetch)
4070          (uri (git-reference
4071                (url "https://github.com/fukamachi/fast-http")
4072                (commit commit)))
4073          (file-name (git-file-name name version))
4074          (sha256
4075           (base32 "0qdmwv2zm0sizxdb8nnclgwl0nfjcbjaimbakavikijw7lr9b4jp"))))
4076       (build-system asdf-build-system/sbcl)
4077       (arguments
4078        ;; Tests fail with: Component FAST-HTTP-ASD::FAST-HTTP-TEST not found,
4079        ;; required by #<SYSTEM "fast-http">. Why?
4080        `(#:tests? #f))
4081       (native-inputs
4082        `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4083          ("sbcl-prove" ,sbcl-prove)))
4084       (inputs
4085        `(("sbcl-alexandria" ,sbcl-alexandria)
4086          ("sbcl-proc-parse" ,sbcl-proc-parse)
4087          ("sbcl-xsubseq" ,sbcl-xsubseq)
4088          ("sbcl-smart-buffer" ,sbcl-smart-buffer)
4089          ("sbcl-cl-utilities" ,sbcl-cl-utilities)))
4090       (home-page "https://github.com/fukamachi/fast-http")
4091       (synopsis "HTTP request/response parser for Common Lisp")
4092       (description
4093        "@code{fast-http} is a HTTP request/response protocol parser for Common
4094 Lisp.")
4095       ;; Author specified the MIT license
4096       (license license:expat))))
4097
4098 (define-public cl-fast-http
4099   (sbcl-package->cl-source-package sbcl-fast-http))
4100
4101 (define-public sbcl-static-vectors
4102   (package
4103     (name "sbcl-static-vectors")
4104     (version "1.8.4")
4105     (source
4106      (origin
4107        (method git-fetch)
4108        (uri (git-reference
4109              (url "https://github.com/sionescu/static-vectors.git")
4110              (commit (string-append "v" version))))
4111        (file-name (git-file-name name version))
4112        (sha256
4113         (base32 "0qvf9z6bhwhm8n45fjwkm7j8dcb58szfvndky65cyn4lpdval7m1"))))
4114     (native-inputs
4115      `(("sbcl-fiveam" ,sbcl-fiveam)))
4116     (inputs
4117      `(("sbcl-cffi-grovel" ,sbcl-cffi-grovel)
4118        ("sbcl-cffi" ,sbcl-cffi)))
4119     (build-system asdf-build-system/sbcl)
4120     (home-page "https://github.com/sionescu/static-vectors")
4121     (synopsis "Allocate SIMPLE-ARRAYs in static memory")
4122     (description
4123      "With @code{static-vectors}, you can create vectors allocated in static
4124 memory.")
4125     (license license:expat)))
4126
4127 (define-public cl-static-vectors
4128   (sbcl-package->cl-source-package sbcl-static-vectors))
4129
4130 (define-public ecl-static-vectors
4131   (sbcl-package->ecl-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 sbcl-fare-quasiquote-extras
5966   (package
5967     (inherit sbcl-fare-quasiquote)
5968     (name "sbcl-fare-quasiquote-extras")
5969     (build-system asdf-build-system/sbcl)
5970     (inputs
5971      `(("fare-quasiquote-optima" ,sbcl-fare-quasiquote-optima)
5972        ("fare-quasiquote-readtable" ,sbcl-fare-quasiquote-readtable)))
5973     (arguments
5974      `(#:phases
5975        (modify-phases %standard-phases
5976          (replace 'build
5977            (lambda* (#:key outputs #:allow-other-keys)
5978              (let* ((out (assoc-ref outputs "out"))
5979                     (lib (string-append out "/lib/" (%lisp-type))))
5980                (mkdir-p lib)
5981                (install-file "fare-quasiquote-extras.asd" lib)
5982                #t)))
5983          (add-after 'create-asd-file 'fix-asd-file
5984            (lambda* (#:key outputs #:allow-other-keys)
5985              (let* ((out (assoc-ref outputs "out"))
5986                     (lib (string-append out "/lib/" (%lisp-type)))
5987                     (asd (string-append lib "/fare-quasiquote-extras.asd")))
5988                (substitute* asd
5989                  ((":class")
5990                   "")
5991                  (("asdf/bundle:prebuilt-system")
5992                   "")
5993                  ((":components")
5994                   "")
5995                  (("\\(\\(:compiled-file \"fare-quasiquote-extras--system\"\\)\\)")
5996                   "")))
5997              #t)))))
5998     (description "This library combines @code{fare-quasiquote-readtable} and
5999 @code{fare-quasiquote-optima}.")))
6000
6001 (define-public cl-fare-quasiquote-extras
6002   (package
6003     (inherit cl-fare-quasiquote)
6004     (name "cl-fare-quasiquote-extras")
6005     (build-system asdf-build-system/source)
6006     (propagated-inputs
6007      `(("fare-quasiquote" ,cl-fare-quasiquote)
6008        ("fare-quasiquote-optima" ,cl-fare-quasiquote-optima)
6009        ("fare-quasiquote-readtable" ,cl-fare-quasiquote-readtable)))
6010     (description "This library combines @code{fare-quasiquote-readtable} and
6011 @code{fare-quasiquote-optima}.")))
6012
6013 (define-public sbcl-trivia.level0
6014   (let ((commit "574901ac376ae54c9d37169fd5efab9b3b8fcc63")
6015         (revision "1"))
6016     (package
6017       (name "sbcl-trivia.level0")
6018       (build-system asdf-build-system/sbcl)
6019       (version (git-version "0.0.0" revision commit))
6020       (home-page "https://github.com/guicho271828/trivia")
6021       (source
6022        (origin
6023          (method git-fetch)
6024          (uri (git-reference
6025                (url home-page)
6026                (commit commit)))
6027          (file-name (git-file-name name version))
6028          (sha256
6029           (base32
6030            "0hf53n71xzr9sjwrxis5fivx3drclf4s39h5ck8vh21ndqj9zvdk"))))
6031       (inputs
6032        `(("alexandria" ,sbcl-alexandria)))
6033       (synopsis "Pattern matching in Common Lisp")
6034       (description "Trivia is a pattern matching compiler that is compatible
6035 with Optima, another pattern matching library for Common Lisp.  It is meant to
6036 be faster and more extensible than Optima.")
6037       (license license:llgpl))))
6038
6039 (define-public sbcl-trivia.level1
6040   (package
6041     (inherit sbcl-trivia.level0)
6042     (name "sbcl-trivia.level1")
6043     (inputs
6044      `(("trivia.level0" ,sbcl-trivia.level0)))
6045     (description "Trivia is a pattern matching compiler that is compatible
6046 with Optima, another pattern matching library for Common Lisp.  It is meant to
6047 be faster and more extensible than Optima.
6048
6049 This system contains the core patterns of Trivia.")))
6050
6051 (define-public sbcl-trivia.level2
6052   (package
6053     (inherit sbcl-trivia.level0)
6054     (name "sbcl-trivia.level2")
6055     (inputs
6056      `(("trivia.level1" ,sbcl-trivia.level1)
6057        ("lisp-namespace" ,sbcl-lisp-namespace)
6058        ("trivial-cltl2" ,sbcl-trivial-cltl2)
6059        ("closer-mop" ,sbcl-closer-mop)))
6060     (description "Trivia is a pattern matching compiler that is compatible
6061 with Optima, another pattern matching library for Common Lisp.  It is meant to
6062 be faster and more extensible than Optima.
6063
6064 This system contains a non-optimized pattern matcher compatible with Optima,
6065 with extensible optimizer interface.")))
6066
6067 (define-public sbcl-trivia.trivial
6068   (package
6069     (inherit sbcl-trivia.level0)
6070     (name "sbcl-trivia.trivial")
6071     (inputs
6072      `(("trivia.level2" ,sbcl-trivia.level2)))
6073     (arguments
6074      `(#:phases
6075        (modify-phases %standard-phases
6076          (replace 'create-asd-file
6077            (lambda* (#:key outputs inputs #:allow-other-keys)
6078              (let* ((out (assoc-ref outputs "out"))
6079                     (lib (string-append out "/lib/" (%lisp-type)))
6080                     (level2 (assoc-ref inputs "trivia.level2")))
6081                (mkdir-p lib)
6082                (install-file "trivia.trivial.asd" lib)
6083                ;; XXX: This .asd does not have any component and the build
6084                ;; system fails to work in this case.  We should update the
6085                ;; build system to handle component-less .asd.
6086                ;; TODO: How do we append to file in Guile?  It seems that
6087                ;; (open-file ... "a") gets a "Permission denied".
6088                (substitute* (string-append lib "/trivia.trivial.asd")
6089                  (("\"\\)")
6090                   (string-append "\")
6091
6092 (progn (asdf/source-registry:ensure-source-registry)
6093        (setf (gethash
6094                \"trivia.level2\"
6095                asdf/source-registry:*source-registry*)
6096              #p\""
6097                                  level2
6098                                  "/share/common-lisp/sbcl-bundle-systems/trivia.level2.asd\"))")))))))))
6099     (description "Trivia is a pattern matching compiler that is compatible
6100 with Optima, another pattern matching library for Common Lisp.  It is meant to
6101 be faster and more extensible than Optima.
6102
6103 This system contains the base level system of Trivia with a trivial optimizer.")))
6104
6105 (define-public sbcl-trivia.balland2006
6106   (package
6107     (inherit sbcl-trivia.level0)
6108     (name "sbcl-trivia.balland2006")
6109     (inputs
6110      `(("trivia.trivial" ,sbcl-trivia.trivial)
6111        ("iterate" ,sbcl-iterate)
6112        ("type-i" ,sbcl-type-i)
6113        ("alexandria" ,sbcl-alexandria)))
6114     (arguments
6115      ;; Tests are done in trivia itself.
6116      `(#:tests? #f))
6117     (description "Trivia is a pattern matching compiler that is compatible
6118 with Optima, another pattern matching library for Common Lisp.  It is meant to
6119 be faster and more extensible than Optima.
6120
6121 This system contains the base level system of Trivia with a trivial optimizer.")))
6122
6123 (define-public sbcl-trivia.ppcre
6124   (package
6125     (inherit sbcl-trivia.level0)
6126     (name "sbcl-trivia.ppcre")
6127     (inputs
6128      `(("trivia.trivial" ,sbcl-trivia.trivial)
6129        ("cl-ppcre" ,sbcl-cl-ppcre)))
6130     (description "Trivia is a pattern matching compiler that is compatible
6131 with Optima, another pattern matching library for Common Lisp.  It is meant to
6132 be faster and more extensible than Optima.
6133
6134 This system contains the PPCRE extension.")))
6135
6136 (define-public sbcl-trivia.quasiquote
6137   (package
6138     (inherit sbcl-trivia.level0)
6139     (name "sbcl-trivia.quasiquote")
6140     (inputs
6141      `(("trivia.trivial" ,sbcl-trivia.trivial)
6142        ("fare-quasiquote" ,sbcl-fare-quasiquote)
6143        ("fare-quasiquote-readtable" ,sbcl-fare-quasiquote-readtable)))
6144     (description "Trivia is a pattern matching compiler that is compatible
6145 with Optima, another pattern matching library for Common Lisp.  It is meant to
6146 be faster and more extensible than Optima.
6147
6148 This system contains the fare-quasiquote extension.")))
6149
6150 (define-public sbcl-trivia.cffi
6151   (package
6152     (inherit sbcl-trivia.level0)
6153     (name "sbcl-trivia.cffi")
6154     (inputs
6155      `(("cffi" ,sbcl-cffi)
6156        ("trivia.trivial" ,sbcl-trivia.trivial)))
6157     (description "Trivia is a pattern matching compiler that is compatible
6158 with Optima, another pattern matching library for Common Lisp.  It is meant to
6159 be faster and more extensible than Optima.
6160
6161 This system contains the CFFI foreign slot access extension.")))
6162
6163 (define-public sbcl-trivia
6164   (package
6165     (inherit sbcl-trivia.level0)
6166     (name "sbcl-trivia")
6167     (inputs
6168      `(("trivia.balland2006" ,sbcl-trivia.balland2006)))
6169     (native-inputs
6170      `(("fiveam" ,sbcl-fiveam)
6171        ("trivia.ppcre" ,sbcl-trivia.ppcre)
6172        ("trivia.quasiquote" ,sbcl-trivia.quasiquote)
6173        ("trivia.cffi" ,sbcl-trivia.cffi)
6174        ("optima" ,sbcl-optima)))
6175     (arguments
6176      `(#:test-asd-file "trivia.test.asd"
6177        #:phases
6178        (modify-phases %standard-phases
6179          (add-after 'create-asd 'remove-component
6180            ;; XXX: The original .asd has no components, but our build system
6181            ;; creates an entry nonetheless.  We need to remove it for the
6182            ;; generated .asd to load properly.  See trivia.trivial for a
6183            ;; similar problem.
6184            (lambda* (#:key outputs #:allow-other-keys)
6185              (let* ((out (assoc-ref outputs "out"))
6186                     (asd (string-append out "/lib/" (%lisp-type) "/trivia.asd")))
6187                (substitute* asd
6188                  (("  :components
6189 ")
6190                   ""))
6191                (substitute* asd
6192                  ((" *\\(\\(:compiled-file \"trivia--system\"\\)\\)")
6193                   ""))))))))
6194     (description "Trivia is a pattern matching compiler that is compatible
6195 with Optima, another pattern matching library for Common Lisp.  It is meant to
6196 be faster and more extensible than Optima.")))
6197
6198 (define-public cl-trivia
6199   (sbcl-package->cl-source-package sbcl-trivia))
6200
6201 (define-public sbcl-mk-string-metrics
6202   (package
6203     (name "sbcl-mk-string-metrics")
6204     (version "0.1.2")
6205     (home-page "https://github.com/cbaggers/mk-string-metrics/")
6206     (source (origin
6207               (method git-fetch)
6208               (uri (git-reference
6209                     (url home-page)
6210                     (commit version)))
6211               (sha256
6212                (base32 "0bg0bv2mfd4k0g3x72x563hvmrx18xavaffr6xk5rh4if5j7kcf6"))
6213               (file-name (git-file-name name version))))
6214     (build-system asdf-build-system/sbcl)
6215     (synopsis "Calculate various string metrics efficiently in Common Lisp")
6216     (description "This library implements efficient algorithms that calculate
6217 various string metrics in Common Lisp:
6218
6219 @itemize
6220 @item Damerau-Levenshtein distance
6221 @item Hamming distance
6222 @item Jaccard similarity coefficient
6223 @item Jaro distance
6224 @item Jaro-Winkler distance
6225 @item Levenshtein distance
6226 @item Normalized Damerau-Levenshtein distance
6227 @item Normalized Levenshtein distance
6228 @item Overlap coefficient
6229 @end itemize\n")
6230     (license license:x11)))
6231
6232 (define-public cl-mk-string-metrics
6233   (sbcl-package->cl-source-package sbcl-mk-string-metrics))
6234
6235 (define-public sbcl-cl-str
6236   (let ((commit "3d5ec86e3a0199e5973aacde951086dfd754b5e5"))
6237     (package
6238       (name "sbcl-cl-str")
6239       (version (git-version "0.8" "1" commit))
6240       (home-page "https://github.com/vindarel/cl-str")
6241       (source (origin
6242                 (method git-fetch)
6243                 (uri (git-reference
6244                       (url home-page)
6245                       (commit commit)))
6246                 (sha256
6247                  (base32 "0szzzbygw9h985yxz909vvqrp69pmpcpahn7hn350lnyjislk9ga"))
6248                 (file-name (git-file-name name version))))
6249       (build-system asdf-build-system/sbcl)
6250       (inputs
6251        `(("cl-ppcre" ,sbcl-cl-ppcre)
6252          ("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)))
6253       (native-inputs
6254        `(("prove" ,sbcl-prove)
6255          ("prove-asdf" ,sbcl-prove-asdf)))
6256       (arguments
6257        `(#:asd-file "str.asd"
6258          #:asd-system-name "str"
6259          #:test-asd-file "str.test.asd"))
6260       (synopsis "Modern, consistent and terse Common Lisp string manipulation library")
6261       (description "A modern and consistent Common Lisp string manipulation
6262 library that focuses on modernity, simplicity and discoverability:
6263 @code{(str:trim s)} instead of @code{(string-trim '(#\\Space ...) s)}), or
6264 @code{str:concat strings} instead of an unusual format construct; one
6265 discoverable library instead of many; consistency and composability, where
6266 @code{s} is always the last argument, which makes it easier to feed pipes and
6267 arrows.")
6268       (license license:expat))))
6269
6270 (define-public cl-str
6271   (sbcl-package->cl-source-package sbcl-cl-str))
6272
6273 (define-public sbcl-cl-xmlspam
6274   (let ((commit "ea06abcca2a73a9779bcfb09081e56665f94e22a"))
6275     (package
6276       (name "sbcl-cl-xmlspam")
6277       (build-system asdf-build-system/sbcl)
6278       (version (git-version "0.0.0" "1" commit))
6279       (home-page "https://github.com/rogpeppe/cl-xmlspam")
6280       (source
6281        (origin
6282          (method git-fetch)
6283          (uri (git-reference
6284                (url home-page)
6285                (commit commit)))
6286          (file-name (string-append name "-" version))
6287          (sha256
6288           (base32
6289            "0w4rqvrgdgk3fwfq3kx4r7wwdr2bv3b6n3bdqwsiriw9psqzpz2s"))))
6290       (inputs
6291        `(("cxml" ,sbcl-cxml)
6292          ("cl-ppcre" ,sbcl-cl-ppcre)))
6293       (synopsis "Concise, regexp-like pattern matching on streaming XML for Common Lisp")
6294       (description "CXML does an excellent job at parsing XML elements, but what
6295 do you do when you have a XML file that's larger than you want to fit in
6296 memory, and you want to extract some information from it?  Writing code to deal
6297 with SAX events, or even using Klacks, quickly becomes tedious.
6298 @code{cl-xmlspam} (for XML Stream PAttern Matcher) is designed to make it easy
6299 to write code that mirrors the structure of the XML that it's parsing.  It
6300 also makes it easy to shift paradigms when necessary - the usual Lisp control
6301 constructs can be used interchangeably with pattern matching, and the full
6302 power of CXML is available when necessary.")
6303       (license license:bsd-3))))
6304
6305 ;; TODO: dbus uses ASDF's package-inferred-system which is not supported by
6306 ;; asdf-build-system/sbcl as of 2019-08-02.  We should fix
6307 ;; asdf-build-system/sbcl.
6308 (define-public cl-dbus
6309   (let ((commit "24b452df3a45ca5dc95015500f34baad175c981a")
6310         (revision "1"))
6311     (package
6312       (name "cl-dbus")
6313       (build-system asdf-build-system/source)
6314       (version (git-version "20190408" revision commit))
6315       (home-page "https://github.com/death/dbus")
6316       (source
6317        (origin
6318          (method git-fetch)
6319          (uri (git-reference
6320                (url home-page)
6321                (commit commit)))
6322          (file-name (git-file-name name version))
6323          (sha256
6324           (base32
6325            "0fw2q866yddbf23nk9pxphm9gsasx35vjyss82xzvndnjmzlqfl5"))))
6326       ;; Inputs must be propagated or else packages depending on this won't have the necessary packages.
6327       (propagated-inputs
6328        `(("alexandria" ,sbcl-alexandria)
6329          ("trivial-garbage" ,sbcl-trivial-garbage)
6330          ("babel" ,sbcl-babel)
6331          ("iolib" ,sbcl-iolib)
6332          ("iolib+multiplex" ,(@@ (gnu packages lisp-xyz) sbcl-iolib+multiplex))
6333          ("iolib+syscalls" ,(@@ (gnu packages lisp-xyz) sbcl-iolib+syscalls))
6334          ("iolib+streams" ,(@@ (gnu packages lisp-xyz) sbcl-iolib+streams))
6335          ("iolib+sockets" ,(@@ (gnu packages lisp-xyz) sbcl-iolib+sockets))
6336          ("ieee-floats" ,sbcl-ieee-floats)
6337          ("flexi-streams" ,sbcl-flexi-streams)
6338          ("cl-xmlspam" ,sbcl-cl-xmlspam)
6339          ("ironclad" ,sbcl-ironclad)))
6340       (synopsis "D-Bus client library for Common Lisp")
6341       (description "This is a Common Lisp library that allows to publish D-Bus
6342 objects as well as send and notify other objects connected to a bus.")
6343       (license license:bsd-2))))
6344
6345 (define-public sbcl-cl-hooks
6346   (let ((commit "5b638083f3b4f1221a52631d9c8a0a265565cac7")
6347         (revision "1"))
6348     (package
6349       (name "sbcl-cl-hooks")
6350       (build-system asdf-build-system/sbcl)
6351       (version (git-version "0.2.1" revision commit))
6352       (home-page "https://github.com/scymtym/architecture.hooks")
6353       (source
6354        (origin
6355          (method git-fetch)
6356          (uri (git-reference
6357                (url home-page)
6358                (commit commit)))
6359          (file-name (git-file-name name version))
6360          (sha256
6361           (base32
6362            "0bg3l0a28lw5gqqjp6p6b5nhwqk46sgkb7184w5qbfngw1hk8x9y"))))
6363       (inputs
6364        `(("alexandria" ,sbcl-alexandria)
6365          ("let-plus" ,sbcl-let-plus)
6366          ("trivial-garbage" ,sbcl-trivial-garbage)
6367          ("closer-mop" ,sbcl-closer-mop)))
6368       (native-inputs
6369        `(("fiveam" ,sbcl-fiveam)))
6370       (synopsis "Hooks extension point mechanism (as in Emacs) for Common Lisp")
6371       (description "A hook, in the present context, is a certain kind of
6372 extension point in a program that allows interleaving the execution of
6373 arbitrary code with the execution of a the program without introducing any
6374 coupling between the two.  Hooks are used extensively in the extensible editor
6375 Emacs.
6376
6377 In the Common LISP Object System (CLOS), a similar kind of extensibility is
6378 possible using the flexible multi-method dispatch mechanism.  It may even seem
6379 that the concept of hooks does not provide any benefits over the possibilities
6380 of CLOS.  However, there are some differences:
6381
6382 @itemize
6383
6384 @item There can be only one method for each combination of specializers and
6385 qualifiers.  As a result this kind of extension point cannot be used by
6386 multiple extensions independently.
6387 @item Removing code previously attached via a @code{:before}, @code{:after} or
6388 @code{:around} method can be cumbersome.
6389 @item There could be other or even multiple extension points besides @code{:before}
6390 and @code{:after} in a single method.
6391 @item Attaching codes to individual objects using eql specializers can be
6392 cumbersome.
6393 @item Introspection of code attached a particular extension point is
6394 cumbersome since this requires enumerating and inspecting the methods of a
6395 generic function.
6396 @end itemize
6397
6398 This library tries to complement some of these weaknesses of method-based
6399 extension-points via the concept of hooks.")
6400       (license license:llgpl))))
6401
6402 (define-public cl-hooks
6403   (sbcl-package->cl-source-package sbcl-cl-hooks))
6404
6405 (define-public ecl-cl-hooks
6406   (sbcl-package->ecl-package sbcl-cl-hooks))
6407
6408 (define-public sbcl-s-sysdeps
6409   (let ((commit "d28246b5dffef9e73a0e0e6cfbc4e878006fe34d")
6410         (revision "1"))
6411     (package
6412       (name "sbcl-s-sysdeps")
6413       (build-system asdf-build-system/sbcl)
6414       (version (git-version "1" revision commit))
6415       (home-page "https://github.com/svenvc/s-sysdeps")
6416       (source
6417        (origin
6418          (method git-fetch)
6419          (uri (git-reference
6420                (url home-page)
6421                (commit commit)))
6422          (file-name (git-file-name name version))
6423          (sha256
6424           (base32
6425            "14b69b81yrxmjlvmm3lfxk04x5v7hqz4fql121334wh72czznfh9"))))
6426       (synopsis "Common Lisp abstraction layer over platform dependent functionality")
6427       (description "@code{s-sysdeps} is an abstraction layer over platform
6428 dependent functionality.  This simple package is used as a building block in a
6429 number of other open source projects.
6430
6431 @code{s-sysdeps} abstracts:
6432
6433 @itemize
6434 @item managing processes,
6435 @item implementing a standard TCP/IP server,
6436 @item opening a client TCP/IP socket stream,
6437 @item working with process locks.
6438 @end itemize\n")
6439       (license license:llgpl))))
6440
6441 (define-public cl-s-sysdeps
6442   (sbcl-package->cl-source-package sbcl-s-sysdeps))
6443
6444 (define-public ecl-s-sysdeps
6445   (sbcl-package->ecl-package sbcl-s-sysdeps))
6446
6447 (define-public sbcl-cl-prevalence
6448   (let ((commit "c163c227ed85d430b82cb1e3502f72d4f88e3cfa")
6449         (revision "1"))
6450     (package
6451       (name "sbcl-cl-prevalence")
6452       (build-system asdf-build-system/sbcl)
6453       (version (git-version "5" revision commit))
6454       (home-page "https://github.com/40ants/cl-prevalence")
6455       (source
6456        (origin
6457          (method git-fetch)
6458          (uri (git-reference
6459                (url home-page)
6460                (commit commit)))
6461          (file-name (git-file-name name version))
6462          (sha256
6463           (base32
6464            "1i9zj1q2ahgwch56an21yzbgkynz0kab9fyxkq9mg8p3xrv38jjn"))))
6465       (inputs
6466        `(("s-sysdeps" ,sbcl-s-sysdeps)
6467          ("s-xml" ,sbcl-s-xml)))
6468       (synopsis "Implementation of object prevalence for Common Lisp")
6469       (description "This Common Lisp library implements object prevalence (see
6470 @url{https://en.wikipedia.org/wiki/System_prevalence}).  It allows
6471 for (de)serializing to and from s-exps as well as XML.  Serialization of arbitrary
6472 classes and cyclic data structures are supported.")
6473       (license license:llgpl))))
6474
6475 (define-public cl-prevalence
6476   (sbcl-package->cl-source-package sbcl-cl-prevalence))
6477
6478 (define-public ecl-cl-prevalence
6479   (sbcl-package->ecl-package sbcl-cl-prevalence))
6480
6481 (define-public sbcl-series
6482   (let ((commit "da9061b336119d1e5214aff9117171d494d5a58a")
6483         (revision "1"))
6484     (package
6485       (name "sbcl-series")
6486       (version (git-version "2.2.11" revision commit))
6487       (source
6488        (origin
6489          (method git-fetch)
6490          (uri (git-reference
6491                (url "git://git.code.sf.net/p/series/series")
6492                (commit commit)))
6493          (file-name (git-file-name name version))
6494          (sha256
6495           (base32
6496            "07hk2lhfx42zk018pxqvn4gs77vd4n4g8m4xxbqaxgca76mifwfw"))))
6497       (build-system asdf-build-system/sbcl)
6498       (arguments
6499        ;; Disable the tests, they are apparently buggy and I didn't find
6500        ;; a simple way to make them run and pass.
6501        '(#:tests? #f))
6502       (synopsis "Series data structure for Common Lisp")
6503       (description
6504        "This Common Lisp library provides a series data structure much like
6505 a sequence, with similar kinds of operations.  The difference is that in many
6506 situations, operations on series may be composed functionally and yet execute
6507 iteratively, without the need to construct intermediate series values
6508 explicitly.  In this manner, series provide both the clarity of a functional
6509 programming style and the efficiency of an iterative programming style.")
6510       (home-page "http://series.sourceforge.net/")
6511       (license license:expat))))
6512
6513 (define-public cl-series
6514   (sbcl-package->cl-source-package sbcl-series))
6515
6516 (define-public ecl-series
6517   (sbcl-package->ecl-package sbcl-series))
6518
6519 (define-public sbcl-periods
6520   (let ((commit "983d4a57325db3c8def942f163133cec5391ec28")
6521         (revision "1"))
6522     (package
6523       (name "sbcl-periods")
6524       (version (git-version "0.0.2" revision commit))
6525       (source
6526        (origin
6527          (method git-fetch)
6528          (uri (git-reference
6529                (url "https://github.com/jwiegley/periods.git")
6530                (commit commit)))
6531          (file-name (git-file-name name version))
6532          (sha256
6533           (base32
6534            "0z30jr3lxz3cmi019fsl4lgcgwf0yqpn95v9zkkkwgymdrkd4lga"))))
6535       (build-system asdf-build-system/sbcl)
6536       (inputs
6537        `(("local-time" ,sbcl-local-time)))
6538       (synopsis "Common Lisp library for manipulating date/time objects")
6539       (description
6540        "Periods is a Common Lisp library providing a set of utilities for
6541 manipulating times, distances between times, and both contiguous and
6542 discontiguous ranges of time.")
6543       (home-page "https://github.com/jwiegley/periods")
6544       (license license:bsd-3))))
6545
6546 (define-public cl-periods
6547   (sbcl-package->cl-source-package sbcl-periods))
6548
6549 (define-public ecl-periods
6550   (sbcl-package->ecl-package sbcl-periods))
6551
6552 (define-public sbcl-periods-series
6553   (package
6554     (inherit sbcl-periods)
6555     (name "sbcl-periods-series")
6556     (inputs
6557      `(("periods" ,sbcl-periods)
6558        ("series" ,sbcl-series)))
6559     (arguments
6560      '(#:asd-file "periods-series.asd"
6561        #:asd-system-name "periods-series"))
6562     (description
6563      "Periods-series is an extension of the periods Common Lisp library
6564 providing functions compatible with the series Common Lisp library.")))
6565
6566 (define-public cl-periods-series
6567   (sbcl-package->cl-source-package sbcl-periods-series))
6568
6569 (define-public ecl-periods-series
6570   (sbcl-package->ecl-package sbcl-periods-series))
6571
6572 (define-public sbcl-metatilities-base
6573   (let ((commit "6eaa9e3ff0939a93a92109dd0fcd218de85417d5")
6574         (revision "1"))
6575     (package
6576       (name "sbcl-metatilities-base")
6577       (version (git-version "0.6.6" revision commit))
6578       (source
6579        (origin
6580          (method git-fetch)
6581          (uri (git-reference
6582                (url "https://github.com/gwkkwg/metatilities-base.git")
6583                (commit commit)))
6584          (file-name (git-file-name name version))
6585          (sha256
6586           (base32
6587            "0xpa86pdzlnf4v5g64j3ifaplx71sx2ha8b7vvakswi652679ma0"))))
6588       (build-system asdf-build-system/sbcl)
6589       (native-inputs
6590        `(("lift" ,sbcl-lift)))
6591       (synopsis "Core of the metatilities Common Lisp library")
6592       (description
6593        "Metatilities-base is the core of the metatilities Common Lisp library
6594 which implements a set of utilities.")
6595       (home-page "https://common-lisp.net/project/metatilities-base/")
6596       (license license:expat))))
6597
6598 (define-public cl-metatilities-base
6599   (sbcl-package->cl-source-package sbcl-metatilities-base))
6600
6601 (define-public ecl-metatilities-base
6602   (sbcl-package->ecl-package sbcl-metatilities-base))
6603
6604 (define-public sbcl-cl-containers
6605   (let ((commit "810927e19d933bcf38ffeb7a23ce521efc432d45")
6606         (revision "1"))
6607     (package
6608       (name "sbcl-cl-containers")
6609       (version (git-version "0.12.1" revision commit))
6610       (source
6611        (origin
6612          (method git-fetch)
6613          (uri (git-reference
6614                (url "https://github.com/gwkkwg/cl-containers.git")
6615                (commit commit)))
6616          (file-name (git-file-name name version))
6617          (sha256
6618           (base32
6619            "1s9faxw7svhbjpkhfrz2qxgjm3cvyjb8wpyb4m8dx4i5g7vvprkv"))))
6620       (build-system asdf-build-system/sbcl)
6621       (native-inputs
6622        `(("lift" ,sbcl-lift)))
6623       (inputs
6624        `(("metatilities-base" ,sbcl-metatilities-base)))
6625       (arguments
6626        '(#:phases
6627          (modify-phases %standard-phases
6628            (add-after 'unpack 'relax-version-checks
6629              (lambda _
6630                (substitute* "cl-containers.asd"
6631                  (("\\(:version \"metatilities-base\" \"0\\.6\\.6\"\\)")
6632                   "\"metatilities-base\""))
6633                (substitute* "cl-containers-test.asd"
6634                  (("\\(:version \"lift\" \"1\\.7\\.0\"\\)")
6635                   "\"lift\""))
6636                #t)))))
6637       (synopsis "Container library for Common Lisp")
6638       (description
6639        "Common Lisp ships with a set of powerful built in data structures
6640 including the venerable list, full featured arrays, and hash-tables.
6641 CL-containers enhances and builds on these structures by adding containers
6642 that are not available in native Lisp (for example: binary search trees,
6643 red-black trees, sparse arrays and so on), and by providing a standard
6644 interface so that they are simpler to use and so that changing design
6645 decisions becomes significantly easier.")
6646       (home-page "https://common-lisp.net/project/cl-containers/")
6647       (license license:expat))))
6648
6649 (define-public cl-containers
6650   (sbcl-package->cl-source-package sbcl-cl-containers))
6651
6652 (define-public ecl-cl-containers
6653   (sbcl-package->ecl-package sbcl-cl-containers))
6654
6655 (define-public sbcl-xlunit
6656   (let ((commit "3805d34b1d8dc77f7e0ee527a2490194292dd0fc")
6657         (revision "1"))
6658     (package
6659       (name "sbcl-xlunit")
6660       (version (git-version "0.6.3" revision commit))
6661       (source
6662        (origin
6663          (method git-fetch)
6664          (uri (git-reference
6665                (url "http://git.kpe.io/xlunit.git")
6666                (commit commit)))
6667          (file-name (git-file-name name version))
6668          (sha256
6669           (base32
6670            "0argfmp9nghs4sihyj3f8ch9qfib2b7ll07v5m9ziajgzsfl5xw3"))))
6671       (build-system asdf-build-system/sbcl)
6672       (arguments
6673        '(#:phases
6674          (modify-phases %standard-phases
6675            (add-after 'unpack 'fix-tests
6676              (lambda _
6677                (substitute* "xlunit.asd"
6678                  ((" :force t") ""))
6679                #t)))))
6680       (synopsis "Unit testing package for Common Lisp")
6681       (description
6682        "The XLUnit package is a toolkit for building test suites.  It is based
6683 on the XPTest package by Craig Brozensky and the JUnit package by Kent Beck.")
6684       (home-page "http://quickdocs.org/xlunit/")
6685       (license license:bsd-3))))
6686
6687 (define-public cl-xlunit
6688   (sbcl-package->cl-source-package sbcl-xlunit))
6689
6690 (define-public ecl-xlunit
6691   (sbcl-package->ecl-package sbcl-xlunit))
6692
6693 (define-public sbcl-fprog
6694   (let ((commit "7016d1a98215f82605d1c158e7a16504ca1f4636")
6695         (revision "1"))
6696     (package
6697       (name "sbcl-fprog")
6698       (version (git-version "1.0.0" revision commit))
6699       (source
6700        (origin
6701          (method git-fetch)
6702          (uri (git-reference
6703                (url "https://github.com/jwiegley/cambl.git")
6704                (commit commit)))
6705          (file-name (git-file-name name version))
6706          (sha256
6707           (base32
6708            "103mry04j2k9vznsxm7wcvccgxkil92cdrv52miwcmxl8daa4jiz"))))
6709       (build-system asdf-build-system/sbcl)
6710       (synopsis "Functional programming utilities for Common Lisp")
6711       (description
6712        "@code{fprog} is a Common Lisp library allowing iteration over
6713 immutable lists sharing identical sublists.")
6714       (home-page "https://github.com/jwiegley/cambl")
6715       (license license:bsd-3))))
6716
6717 (define-public cl-fprog
6718   (sbcl-package->cl-source-package sbcl-fprog))
6719
6720 (define-public ecl-fprog
6721   (sbcl-package->ecl-package sbcl-fprog))
6722
6723 (define-public sbcl-cambl
6724   (let ((commit "7016d1a98215f82605d1c158e7a16504ca1f4636")
6725         (revision "1"))
6726     (package
6727       (inherit sbcl-fprog)
6728       (name "sbcl-cambl")
6729       (version (git-version "4.0.0" revision commit))
6730       (native-inputs
6731        `(("xlunit" ,sbcl-xlunit)))
6732       (inputs
6733        `(("alexandria" ,sbcl-alexandria)
6734          ("cl-containers" ,sbcl-cl-containers)
6735          ("local-time" ,sbcl-local-time)
6736          ("periods" ,sbcl-periods)
6737          ("fprog" ,sbcl-fprog)))
6738       (synopsis "Commoditized amounts and balances for Common Lisp")
6739       (description
6740        "CAMBL is a Common Lisp library providing a convenient facility for
6741 working with commoditized values.  It does not allow compound units (and so is
6742 not suited for scientific operations) but does work rather nicely for the
6743 purpose of financial calculations."))))
6744
6745 (define-public cl-cambl
6746   (sbcl-package->cl-source-package sbcl-cambl))
6747
6748 (define-public ecl-cambl
6749   (sbcl-package->ecl-package sbcl-cambl))
6750
6751 (define-public sbcl-cl-ledger
6752   (let ((commit "08e0be41795e804cd36142e51756ad0b1caa377b")
6753         (revision "1"))
6754     (package
6755       (name "sbcl-cl-ledger")
6756       (version (git-version "4.0.0" revision commit))
6757       (source
6758        (origin
6759          (method git-fetch)
6760          (uri (git-reference
6761                (url "https://github.com/ledger/cl-ledger.git")
6762                (commit commit)))
6763          (file-name (git-file-name name version))
6764          (sha256
6765           (base32
6766            "1via0qf6wjcyxnfbmfxjvms0ik9j8rqbifgpmnhrzvkhrq9pv8h1"))))
6767       (build-system asdf-build-system/sbcl)
6768       (inputs
6769        `(("cambl" ,sbcl-cambl)
6770          ("cl-ppcre" ,sbcl-cl-ppcre)
6771          ("local-time" ,sbcl-local-time)
6772          ("periods-series" ,sbcl-periods-series)))
6773       (arguments
6774        '(#:phases
6775          (modify-phases %standard-phases
6776            (add-after 'unpack 'fix-system-definition
6777              (lambda _
6778                (substitute* "cl-ledger.asd"
6779                  (("  :build-operation program-op") "")
6780                  (("  :build-pathname \"cl-ledger\"") "")
6781                  (("  :entry-point \"ledger::main\"") ""))
6782                #t)))))
6783       (synopsis "Common Lisp port of the Ledger accounting system")
6784       (description
6785        "CL-Ledger is a Common Lisp port of the Ledger double-entry accounting
6786 system.")
6787       (home-page "https://github.com/ledger/cl-ledger")
6788       (license license:bsd-3))))
6789
6790 (define-public cl-ledger
6791   (sbcl-package->cl-source-package sbcl-cl-ledger))
6792
6793 (define-public ecl-cl-ledger
6794   (sbcl-package->ecl-package sbcl-cl-ledger))
6795
6796 (define-public sbcl-bst
6797   (let ((commit "34f9c7e8e0a9f2c952fe310ab36cb630d5d9c15a")
6798         (revision "1"))
6799     (package
6800       (name "sbcl-bst")
6801       (version (git-version "1.1" revision commit))
6802       (source
6803        (origin
6804          (method git-fetch)
6805          (uri (git-reference
6806                (url "https://github.com/glv2/bst.git")
6807                (commit commit)))
6808          (file-name (git-file-name name version))
6809          (sha256
6810           (base32
6811            "1amxns7hvvh4arwbh8ciwfzplg127vh37dnbamv1m1kmmnmihfc8"))))
6812       (build-system asdf-build-system/sbcl)
6813       (native-inputs
6814        `(("alexandria" ,sbcl-alexandria)
6815          ("fiveam" ,sbcl-fiveam)))
6816       (synopsis "Binary search tree for Common Lisp")
6817       (description
6818        "BST is a Common Lisp library for working with binary search trees that
6819 can contain any kind of values.")
6820       (home-page "https://github.com/glv2/bst")
6821       (license license:gpl3))))
6822
6823 (define-public cl-bst
6824   (sbcl-package->cl-source-package sbcl-bst))
6825
6826 (define-public ecl-bst
6827   (sbcl-package->ecl-package sbcl-bst))
6828
6829 (define-public sbcl-cl-octet-streams
6830   (package
6831     (name "sbcl-cl-octet-streams")
6832     (version "1.0")
6833     (source
6834      (origin
6835        (method git-fetch)
6836        (uri (git-reference
6837              (url "https://github.com/glv2/cl-octet-streams.git")
6838              (commit (string-append "v" version))))
6839        (file-name (git-file-name name version))
6840        (sha256
6841         (base32
6842          "1d7mn6ydv0j2x4r7clpc9ijjwrnfpxmvhifv8n5j7jh7s744sf8d"))))
6843     (build-system asdf-build-system/sbcl)
6844     (native-inputs
6845      `(("fiveam" ,sbcl-fiveam)))
6846     (inputs
6847      `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
6848     (synopsis "In-memory octet streams for Common Lisp")
6849     (description
6850      "CL-octet-streams is a library implementing in-memory octet
6851 streams for Common Lisp.  It was inspired by the trivial-octet-streams and
6852 cl-plumbing libraries.")
6853     (home-page "https://github.com/glv2/cl-octet-streams")
6854     (license license:gpl3+)))
6855
6856 (define-public cl-octet-streams
6857   (sbcl-package->cl-source-package sbcl-cl-octet-streams))
6858
6859 (define-public ecl-cl-octet-streams
6860   (sbcl-package->ecl-package sbcl-cl-octet-streams))
6861
6862 (define-public sbcl-lzlib
6863   (let ((commit "0de1db7129fef9a58a059d35a2fa2ecfc5b47b47")
6864         (revision "1"))
6865     (package
6866       (name "sbcl-lzlib")
6867       (version (git-version "1.0" revision commit))
6868       (source
6869        (origin
6870          (method git-fetch)
6871          (uri (git-reference
6872                (url "https://github.com/glv2/cl-lzlib.git")
6873                (commit commit)))
6874          (file-name (git-file-name name version))
6875          (sha256
6876           (base32
6877            "12ny7vj52fgnd8hb8fc8mry92vq4c1x72x2350191m4476j95clz"))))
6878       (build-system asdf-build-system/sbcl)
6879       (native-inputs
6880        `(("fiveam" ,sbcl-fiveam)))
6881       (inputs
6882        `(("cffi" ,sbcl-cffi)
6883          ("cl-octet-streams" ,sbcl-cl-octet-streams)
6884          ("lzlib" ,lzlib)))
6885       (arguments
6886        '(#:phases
6887          (modify-phases %standard-phases
6888            (add-after 'unpack 'fix-paths
6889              (lambda* (#:key inputs #:allow-other-keys)
6890                (substitute* "src/lzlib.lisp"
6891                  (("liblz\\.so")
6892                   (string-append (assoc-ref inputs "lzlib") "/lib/liblz.so")))
6893                #t)))))
6894       (synopsis "Common Lisp library for lzip (de)compression")
6895       (description
6896        "This Common Lisp library provides functions for lzip (LZMA)
6897 compression/decompression using bindings to the lzlib C library.")
6898       (home-page "https://github.com/glv2/cl-lzlib")
6899       (license license:gpl3+))))
6900
6901 (define-public cl-lzlib
6902   (sbcl-package->cl-source-package sbcl-lzlib))
6903
6904 (define-public ecl-lzlib
6905   (sbcl-package->ecl-package sbcl-lzlib))
6906
6907 (define-public sbcl-chanl
6908   (let ((commit "56e90a126c78b39bb621a01585e8d3b985238e8c")
6909         (revision "1"))
6910     (package
6911       (name "sbcl-chanl")
6912       (version (git-version "0.4.1" revision commit))
6913       (source
6914        (origin
6915          (method git-fetch)
6916          (uri (git-reference
6917                (url "https://github.com/zkat/chanl.git")
6918                (commit commit)))
6919          (file-name (git-file-name name version))
6920          (sha256
6921           (base32
6922            "0b1cf6c12qx5cy1fw2z42jgh566rp3l8nv5qf0qqc569s7bgmrh4"))))
6923       (build-system asdf-build-system/sbcl)
6924       (native-inputs
6925        `(("fiveam" ,sbcl-fiveam)))
6926       (inputs
6927        `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
6928       (synopsis "Portable channel-based concurrency for Common Lisp")
6929       (description "Common Lisp library for channel-based concurrency.  In
6930 a nutshell, you create various threads sequentially executing tasks you need
6931 done, and use channel objects to communicate and synchronize the state of these
6932 threads.")
6933       (home-page "https://github.com/zkat/chanl")
6934       (license (list license:expat license:bsd-3)))))
6935
6936 (define-public cl-chanl
6937   (sbcl-package->cl-source-package sbcl-chanl))
6938
6939 (define-public ecl-chanl
6940   (sbcl-package->ecl-package sbcl-chanl))
6941
6942 (define-public sbcl-cl-store
6943   (let ((commit "c787337a16ea8cf8a06227f35933a4ec774746b3")
6944         (revision "1"))
6945     (package
6946       (name "sbcl-cl-store")
6947       (version (git-version "0.8.11" revision commit))
6948       (source
6949        (origin
6950          (method git-fetch)
6951          (uri (git-reference
6952                (url "https://github.com/skypher/cl-store.git")
6953                (commit commit)))
6954          (file-name (git-file-name name version))
6955          (sha256
6956           (base32
6957            "194srkg8nrym19c6i7zbnkzshc1qhqa82m53qnkirz9fw928bqxr"))))
6958       (build-system asdf-build-system/sbcl)
6959       (native-inputs
6960        `(("rt" ,sbcl-rt)))
6961       (synopsis "Common Lisp library to serialize data")
6962       (description
6963        "CL-STORE is a portable serialization package which should give you the
6964 ability to store all Common Lisp data types into streams.")
6965       (home-page "https://www.common-lisp.net/project/cl-store/")
6966       (license license:expat))))
6967
6968 (define-public cl-store
6969   (sbcl-package->cl-source-package sbcl-cl-store))
6970
6971 (define-public ecl-cl-store
6972   (sbcl-package->ecl-package sbcl-cl-store))
6973
6974 (define-public sbcl-cl-gobject-introspection
6975   (let ((commit "7b703e2384945ea0ac39d9b766de434a08d81560")
6976         (revision "0"))
6977     (package
6978       (name "sbcl-cl-gobject-introspection")
6979       (version (git-version "0.3" revision commit))
6980       (home-page "https://github.com/andy128k/cl-gobject-introspection")
6981       (source
6982        (origin
6983          (method git-fetch)
6984          (uri (git-reference
6985                (url home-page)
6986                (commit commit)))
6987          (file-name (git-file-name name version))
6988          (sha256
6989           (base32
6990            "1zcqd2qj14f6b38vys8gr89s6cijsp9r8j43xa8lynilwva7bwyh"))))
6991       (build-system asdf-build-system/sbcl)
6992       (inputs
6993        `(("alexandria" ,sbcl-alexandria)
6994          ("cffi" ,sbcl-cffi)
6995          ("iterate" ,sbcl-iterate)
6996          ("trivial-garbage" ,sbcl-trivial-garbage)
6997          ("glib" ,glib)
6998          ("gobject-introspection" ,gobject-introspection)))
6999       (native-inputs
7000        `(("fiveam" ,sbcl-fiveam)))
7001       (arguments
7002        ;; TODO: Tests fail, see
7003        ;; https://github.com/andy128k/cl-gobject-introspection/issues/70.
7004        '(#:tests? #f
7005          #:phases
7006          (modify-phases %standard-phases
7007            (add-after (quote unpack) (quote fix-paths)
7008              (lambda* (#:key inputs #:allow-other-keys)
7009                (substitute* "src/init.lisp"
7010                  (("libgobject-2\\.0\\.so")
7011                   (string-append (assoc-ref inputs "glib") "/lib/libgobject-2.0.so"))
7012                  (("libgirepository-1\\.0\\.so")
7013                   (string-append (assoc-ref inputs "gobject-introspection")
7014                                  "/lib/libgirepository-1.0.so")))
7015                #t)))))
7016       (synopsis "Common Lisp bindings to GObject Introspection")
7017       (description
7018        "This library is a bridge between Common Lisp and GObject
7019 Introspection, which enables Common Lisp programs to access the full interface
7020 of C+GObject libraries without the need of writing dedicated bindings.")
7021       (license (list license:bsd-3
7022                      ;; Tests are under a different license.
7023                      license:llgpl)))))
7024
7025 (define-public cl-gobject-introspection
7026   (sbcl-package->cl-source-package sbcl-cl-gobject-introspection))
7027
7028 (define-public sbcl-string-case
7029   (let ((commit "718c761e33749e297cd2809c7ba3ade1985c49f7")
7030         (revision "0"))
7031     (package
7032       (name "sbcl-string-case")
7033       (version (git-version "0.0.2" revision commit))
7034       (home-page "https://github.com/pkhuong/string-case")
7035       (source
7036        (origin
7037          (method git-fetch)
7038          (uri (git-reference
7039                (url home-page)
7040                (commit commit)))
7041          (file-name (git-file-name name version))
7042          (sha256
7043           (base32
7044            "1n5i3yh0h5s636rcnwn7jwqy3rjflikra04lymimhpcshhjsk0md"))))
7045       (build-system asdf-build-system/sbcl)
7046       (synopsis "Efficient string= case in Common Lisp")
7047       (description
7048        "@code{string-case} is a Common Lisp macro that generates specialised decision
7049 trees to dispatch on string equality.")
7050       (license license:bsd-3))))
7051
7052 (define-public cl-string-case
7053   (sbcl-package->cl-source-package sbcl-string-case))
7054
7055 (define-public ecl-string-case
7056   (sbcl-package->ecl-package sbcl-string-case))
7057
7058 (define-public sbcl-global-vars
7059   (let ((commit "c749f32c9b606a1457daa47d59630708ac0c266e")
7060         (revision "0"))
7061     (package
7062       (name "sbcl-global-vars")
7063       (version (git-version "1.0.0" revision commit))
7064       (home-page "https://github.com/lmj/global-vars")
7065       (source
7066        (origin
7067          (method git-fetch)
7068          (uri (git-reference
7069                (url home-page)
7070                (commit commit)))
7071          (file-name (git-file-name name version))
7072          (sha256
7073           (base32
7074            "06m3xc8l3pgsapl8fvsi9wf6y46zs75cp9zn7zh6dc65v4s5wz3d"))))
7075       (build-system asdf-build-system/sbcl)
7076       (synopsis "Efficient global variables in Common Lisp")
7077       (description
7078        "In Common Lisp, a special variable that is never dynamically bound
7079 typically serves as a stand-in for a global variable.  The @code{global-vars}
7080 library provides true global variables that are implemented by some compilers.
7081 An attempt to rebind a global variable properly results in a compiler error.
7082 That is, a global variable cannot be dynamically bound.
7083
7084 Global variables therefore allow us to communicate an intended usage that
7085 differs from special variables.  Global variables are also more efficient than
7086 special variables, especially in the presence of threads.")
7087       (license license:expat))))
7088
7089 (define-public cl-global-vars
7090   (sbcl-package->cl-source-package sbcl-global-vars))
7091
7092 (define-public ecl-global-vars
7093   (sbcl-package->ecl-package sbcl-global-vars))
7094
7095 (define-public sbcl-trivial-file-size
7096   (let ((commit "1c1d672a01a446ba0391dbb4ffc40be3b0476f23")
7097         (revision "0"))
7098     (package
7099       (name "sbcl-trivial-file-size")
7100       (version (git-version "0.0.0" revision commit))
7101       (home-page "https://github.com/ruricolist/trivial-file-size")
7102       (source
7103        (origin
7104          (method git-fetch)
7105          (uri (git-reference
7106                (url home-page)
7107                (commit commit)))
7108          (file-name (git-file-name name version))
7109          (sha256
7110           (base32
7111            "17pp86c9zs4y7i1sh7q9gbfw9iqv6655k7fz8qbj9ly1ypgxp4qs"))))
7112       (build-system asdf-build-system/sbcl)
7113       (native-inputs
7114        `(("fiveam" ,sbcl-fiveam)))
7115       (synopsis "Size of a file in bytes in Common Lisp")
7116       (description
7117        "The canonical way to determine the size of a file in bytes, using Common Lisp,
7118 is to open the file with an element type of (unsigned-byte 8) and then
7119 calculate the length of the stream.  This is less than ideal.  In most cases
7120 it is better to get the size of the file from its metadata, using a system
7121 call.
7122
7123 This library exports a single function, file-size-in-octets.  It returns the
7124 size of a file in bytes, using system calls when possible.")
7125       (license license:expat))))
7126
7127 (define-public cl-trivial-file-size
7128   (sbcl-package->cl-source-package sbcl-trivial-file-size))
7129
7130 (define-public ecl-trivial-file-size
7131   (sbcl-package->ecl-package sbcl-trivial-file-size))
7132
7133 (define-public sbcl-trivial-macroexpand-all
7134   (let ((commit "933270ac7107477de1bc92c1fd641fe646a7a8a9")
7135         (revision "0"))
7136     (package
7137       (name "sbcl-trivial-macroexpand-all")
7138       (version (git-version "0.0.0" revision commit))
7139       (home-page "https://github.com/cbaggers/trivial-macroexpand-all")
7140       (source
7141        (origin
7142          (method git-fetch)
7143          (uri (git-reference
7144                (url home-page)
7145                (commit commit)))
7146          (file-name (git-file-name name version))
7147          (sha256
7148           (base32
7149            "191hnn4b5j4i3crydmlzbm231kj0h7l8zj6mzj69r1npbzkas4bd"))))
7150       (build-system asdf-build-system/sbcl)
7151       (native-inputs
7152        `(("fiveam" ,sbcl-fiveam)))
7153       (synopsis "Portable macroexpand-all for Common Lisp")
7154       (description
7155        "This library provides a macroexpand-all function that calls the
7156 implementation specific equivalent.")
7157       (license license:unlicense))))
7158
7159 (define-public cl-trivial-macroexpand-all
7160   (sbcl-package->cl-source-package sbcl-trivial-macroexpand-all))
7161
7162 (define-public ecl-trivial-macroexpand-all
7163   (sbcl-package->ecl-package sbcl-trivial-macroexpand-all))
7164
7165 (define-public sbcl-serapeum
7166   (let ((commit "65837f8a0d65b36369ec8d000fff5c29a395b5fe")
7167         (revision "0"))
7168     (package
7169       (name "sbcl-serapeum")
7170       (version (git-version "0.0.0" revision commit))
7171       (home-page "https://github.com/ruricolist/serapeum")
7172       (source
7173        (origin
7174          (method git-fetch)
7175          (uri (git-reference
7176                (url home-page)
7177                (commit commit)))
7178          (file-name (git-file-name name version))
7179          (sha256
7180           (base32
7181            "0clwf81r2lvk1rbfvk91s9zmbkas9imf57ilqclw12mxaxlfsnbw"))))
7182       (build-system asdf-build-system/sbcl)
7183       (inputs
7184        `(("alexandria" ,sbcl-alexandria)
7185          ("trivia" ,sbcl-trivia)
7186          ("trivia.quasiquote" ,sbcl-trivia.quasiquote)
7187          ("split-sequence" ,sbcl-split-sequence)
7188          ("string-case" ,sbcl-string-case)
7189          ("parse-number" ,sbcl-parse-number)
7190          ("trivial-garbage" ,sbcl-trivial-garbage)
7191          ("bordeaux-threads" ,sbcl-bordeaux-threads)
7192          ("named-readtables" ,sbcl-named-readtables)
7193          ("fare-quasiquote-extras" ,sbcl-fare-quasiquote-extras)
7194          ("parse-declarations-1.0" ,sbcl-parse-declarations)
7195          ("global-vars" ,sbcl-global-vars)
7196          ("trivial-file-size" ,sbcl-trivial-file-size)
7197          ("trivial-macroexpand-all" ,sbcl-trivial-macroexpand-all)))
7198       (native-inputs
7199        `(("fiveam" ,sbcl-fiveam)
7200          ("local-time" ,sbcl-local-time)))
7201       (arguments
7202        '(#:phases
7203          (modify-phases %standard-phases
7204            (add-after 'unpack 'disable-failing-tests
7205              (lambda* (#:key inputs #:allow-other-keys)
7206                (substitute* "serapeum.asd"
7207                  ;; Guix does not have Quicklisp, and probably never will.
7208                  (("\\(:file \"quicklisp\"\\)") ""))
7209                #t)))))
7210       (synopsis "Common Lisp utility library beyond Alexandria")
7211       (description
7212        "Serapeum is a conservative library of Common Lisp utilities.  It is a
7213 supplement, not a competitor, to Alexandria.")
7214       (license license:expat))))
7215
7216 (define-public cl-serapeum
7217   (sbcl-package->cl-source-package sbcl-serapeum))
7218
7219 (define-public sbcl-arrows
7220   (let ((commit "df7cf0067e0132d9697ac8b1a4f1b9c88d4f5382")
7221         (revision "0"))
7222     (package
7223       (name "sbcl-arrows")
7224       (version (git-version "0.2.0" revision commit))
7225       (source
7226        (origin
7227          (method git-fetch)
7228          (uri (git-reference
7229                (url "https://gitlab.com/Harleqin/arrows.git")
7230                (commit commit)))
7231          (file-name (git-file-name name version))
7232          (sha256
7233           (base32
7234            "042k9vkssrqx9nhp14wdzm942zgdxvp35mba0p2syz98i75im2yy"))))
7235       (build-system asdf-build-system/sbcl)
7236       (native-inputs
7237        `(("hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
7238       (synopsis "Clojure-like arrow macros for Common Lisp")
7239       (description
7240        "This library implements the @code{->} and @code{->>} macros from
7241 Clojure, as well as several expansions on the idea.")
7242       (home-page "https://gitlab.com/Harleqin/arrows")
7243       (license license:public-domain))))
7244
7245 (define-public cl-arrows
7246   (sbcl-package->cl-source-package sbcl-arrows))
7247
7248 (define-public ecl-arrows
7249   (sbcl-package->ecl-package sbcl-arrows))
7250
7251 (define-public sbcl-simple-parallel-tasks
7252   (let ((commit "db460f7a3f7bbfe2d3a2223ed21e162068d04dda")
7253         (revision "0"))
7254     (package
7255       (name "sbcl-simple-parallel-tasks")
7256       (version (git-version "1.0" revision commit))
7257       (source
7258        (origin
7259          (method git-fetch)
7260          (uri (git-reference
7261                (url "https://github.com/glv2/simple-parallel-tasks.git")
7262                (commit commit)))
7263          (file-name (git-file-name name version))
7264          (sha256
7265           (base32
7266            "0amw3qk23wnlyrsgzszs6rs7y4zvxv8dr03rnqhc60mnm8ds4dd5"))))
7267       (build-system asdf-build-system/sbcl)
7268       (native-inputs
7269        `(("fiveam" ,sbcl-fiveam)))
7270       (inputs
7271        `(("chanl" ,sbcl-chanl)))
7272       (synopsis "Common Lisp library to evaluate some forms in parallel")
7273       (description "This is a simple Common Lisp library to evaluate some
7274 forms in parallel.")
7275       (home-page "https://github.com/glv2/simple-parallel-tasks")
7276       (license license:gpl3))))
7277
7278 (define-public cl-simple-parallel-tasks
7279   (sbcl-package->cl-source-package sbcl-simple-parallel-tasks))
7280
7281 (define-public ecl-simple-parallel-tasks
7282   (sbcl-package->ecl-package sbcl-simple-parallel-tasks))
7283
7284 (define-public sbcl-cl-heap
7285   (package
7286     (name "sbcl-cl-heap")
7287     (version "0.1.6")
7288     (source
7289      (origin
7290        (method url-fetch)
7291        (uri (string-append "https://common-lisp.net/project/cl-heap/releases/"
7292                            "cl-heap_" version ".tar.gz"))
7293        (sha256
7294         (base32
7295          "163hb07p2nxz126rpq3cj5dyala24n0by5i5786n2qcr1w0bak4i"))))
7296     (build-system asdf-build-system/sbcl)
7297     (native-inputs
7298      `(("xlunit" ,sbcl-xlunit)))
7299     (arguments
7300      `(#:test-asd-file "cl-heap-tests.asd"))
7301     (synopsis "Heap and priority queue data structures for Common Lisp")
7302     (description
7303      "CL-HEAP provides various implementations of heap data structures (a
7304 binary heap and a Fibonacci heap) as well as an efficient priority queue.")
7305     (home-page "https://common-lisp.net/project/cl-heap/")
7306     (license license:gpl3+)))
7307
7308 (define-public cl-heap
7309   (sbcl-package->cl-source-package sbcl-cl-heap))
7310
7311 (define-public ecl-cl-heap
7312   (sbcl-package->ecl-package sbcl-cl-heap))
7313
7314 (define-public sbcl-curry-compose-reader-macros
7315   (let ((commit "beaa92dedf392726c042184bfd6149fa8d9e6ac2")
7316         (revision "0"))
7317     (package
7318       (name "sbcl-curry-compose-reader-macros")
7319       (version (git-version "1.0.0" revision commit))
7320       (source
7321        (origin
7322          (method git-fetch)
7323          (uri
7324           (git-reference
7325            (url "https://github.com/eschulte/curry-compose-reader-macros.git")
7326            (commit commit)))
7327          (file-name (git-file-name name version))
7328          (sha256
7329           (base32
7330            "0rv9bl8xrad5wfcg5zs1dazvnpmvqz6297lbn8bywsrcfnlf7h98"))))
7331       (build-system asdf-build-system/sbcl)
7332       (inputs
7333        `(("alexandria" ,sbcl-alexandria)
7334          ("named-readtables" ,sbcl-named-readtables)))
7335       (synopsis "Reader macros for partial application and composition")
7336       (description
7337        "This Common Lisp library provides reader macros for concise expression
7338 of function partial application and composition.")
7339       (home-page "https://eschulte.github.io/curry-compose-reader-macros/")
7340       (license license:public-domain))))
7341
7342 (define-public cl-curry-compose-reader-macros
7343   (sbcl-package->cl-source-package sbcl-curry-compose-reader-macros))
7344
7345 (define-public ecl-curry-compose-reader-macros
7346   (sbcl-package->ecl-package sbcl-curry-compose-reader-macros))
7347
7348 (define-public sbcl-yason
7349   (package
7350     (name "sbcl-yason")
7351     (version "0.7.7")
7352     (source
7353      (origin
7354        (method git-fetch)
7355        (uri (git-reference
7356              (url "https://github.com/phmarek/yason.git")
7357              (commit (string-append "v" version))))
7358        (file-name (git-file-name name version))
7359        (sha256
7360         (base32
7361          "0479rbjgbj80jpk5bby18inlv1kfp771a82rlcq5psrz65qqa9bj"))))
7362     (build-system asdf-build-system/sbcl)
7363     (inputs
7364      `(("alexandria" ,sbcl-alexandria)
7365        ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
7366     (synopsis "Common Lisp JSON parser/encoder")
7367     (description
7368      "YASON is a Common Lisp library for encoding and decoding data in the
7369 JSON interchange format.")
7370     (home-page "https://github.com/phmarek/yason")
7371     (license license:bsd-3)))
7372
7373 (define-public cl-yason
7374   (sbcl-package->cl-source-package sbcl-yason))
7375
7376 (define-public ecl-yason
7377   (sbcl-package->ecl-package sbcl-yason))
7378
7379 (define-public sbcl-stefil
7380   (let ((commit "0398548ec95dceb50fc2c2c03e5fb0ce49b86c7a")
7381         (revision "0"))
7382     (package
7383       (name "sbcl-stefil")
7384       (version (git-version "0.1" revision commit))
7385       (source
7386        (origin
7387          (method git-fetch)
7388          (uri (git-reference
7389                (url "https://gitlab.common-lisp.net/stefil/stefil.git")
7390                (commit commit)))
7391          (file-name (git-file-name name version))
7392          (sha256
7393           (base32
7394            "0bqz64q2szzhf91zyqyssmvrz7da6442rs01808pf3wrdq28bclh"))))
7395       (build-system asdf-build-system/sbcl)
7396       (inputs
7397        `(("alexandria" ,sbcl-alexandria)
7398          ("iterate" ,sbcl-iterate)
7399          ("metabang-bind" ,sbcl-metabang-bind)))
7400       (propagated-inputs
7401        ;; Swank doesn't have a pre-compiled package, therefore we must
7402        ;; propagate its sources.
7403        `(("swank" ,cl-slime-swank)))
7404       (arguments
7405        '(#:phases
7406          (modify-phases %standard-phases
7407            (add-after 'unpack 'drop-unnecessary-dependency
7408              (lambda _
7409                (substitute* "package.lisp"
7410                  ((":stefil-system") ""))
7411                #t)))))
7412       (home-page "https://common-lisp.net/project/stefil/index-old.shtml")
7413       (synopsis "Simple test framework")
7414       (description
7415        "Stefil is a simple test framework for Common Lisp, with a focus on
7416 interactive development.")
7417       (license license:public-domain))))
7418
7419 (define-public cl-stefil
7420   (sbcl-package->cl-source-package sbcl-stefil))
7421
7422 (define-public sbcl-graph
7423   (let ((commit "78bf9ec930d8eae4f0861b5be76765fb1e45e24f")
7424         (revision "0"))
7425     (package
7426       (name "sbcl-graph")
7427       (version (git-version "0.0.0" revision commit))
7428       (source
7429        (origin
7430          (method git-fetch)
7431          (uri
7432           (git-reference
7433            (url "https://github.com/eschulte/graph.git")
7434            (commit commit)))
7435          (file-name (git-file-name name version))
7436          (sha256
7437           (base32
7438            "1qpij4xh8bqwc2myahpilcbh916v7vg0acz2fij14d3y0jm02h0g"))
7439          (patches (search-patches "sbcl-graph-asdf-definitions.patch"))))
7440       (build-system asdf-build-system/sbcl)
7441       (native-inputs
7442        `(("stefil" ,sbcl-stefil)))
7443       (inputs
7444        `(("alexandria" ,sbcl-alexandria)
7445          ("cl-heap" ,sbcl-cl-heap)
7446          ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
7447          ("metabang-bind" ,sbcl-metabang-bind)
7448          ("named-readtables" ,sbcl-named-readtables)))
7449       (arguments
7450        '(#:test-asd-file "graph-test.asd"))
7451       (synopsis "Graph data structure and algorithms for Common Lisp")
7452       (description
7453        "The GRAPH Common Lisp library provides a data structures to represent
7454 graphs, as well as some graph manipulation and analysis algorithms (shortest
7455 path, maximum flow, minimum spanning tree, etc.).")
7456       (home-page "https://eschulte.github.io/graph/")
7457       (license license:gpl3+))))
7458
7459 (define-public cl-graph
7460   (sbcl-package->cl-source-package sbcl-graph))
7461
7462 (define-public sbcl-graph-dot
7463   (package
7464     (inherit sbcl-graph)
7465     (name "sbcl-graph-dot")
7466     (inputs
7467      `(("alexandria" ,sbcl-alexandria)
7468        ("cl-ppcre" ,sbcl-cl-ppcre)
7469        ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
7470        ("graph" ,sbcl-graph)
7471        ("metabang-bind" ,sbcl-metabang-bind)
7472        ("named-readtables" ,sbcl-named-readtables)))
7473     (arguments
7474      (substitute-keyword-arguments (package-arguments sbcl-graph)
7475        ((#:asd-file _ "") "graph-dot.asd")
7476        ((#:asd-system-name _ #f) "graph-dot")))
7477     (synopsis "Serialize graphs to and from DOT format")))
7478
7479 (define-public sbcl-graph-json
7480   (package
7481     (inherit sbcl-graph)
7482     (name "sbcl-graph-json")
7483     (inputs
7484      `(("alexandria" ,sbcl-alexandria)
7485        ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
7486        ("graph" ,sbcl-graph)
7487        ("metabang-bind" ,sbcl-metabang-bind)
7488        ("named-readtables" ,sbcl-named-readtables)
7489        ("yason" ,sbcl-yason)))
7490     (arguments
7491      (substitute-keyword-arguments (package-arguments sbcl-graph)
7492        ((#:asd-file _ "") "graph-json.asd")
7493        ((#:asd-system-name _ #f) "graph-json")))
7494     (synopsis "Serialize graphs to and from JSON format")))
7495
7496 (define-public sbcl-trivial-indent
7497   (let ((commit "2d016941751647c6cc5bd471751c2cf68861c94a")
7498         (revision "0"))
7499     (package
7500       (name "sbcl-trivial-indent")
7501       (version (git-version "1.0.0" revision commit))
7502       (source
7503        (origin
7504          (method git-fetch)
7505          (uri
7506           (git-reference
7507            (url "https://github.com/Shinmera/trivial-indent")
7508            (commit commit)))
7509          (file-name (git-file-name name version))
7510          (sha256
7511           (base32
7512            "1sj90nqz17w4jq0ixz00gb9g5g6d2s7l8r17zdby27gxxh51w266"))))
7513       (build-system asdf-build-system/sbcl)
7514       (synopsis "Simple Common Lisp library to allow indentation hints for SWANK")
7515       (description
7516        "This library allows you to define custom indentation hints for your
7517 macros if the one recognised by SLIME automatically produces unwanted
7518 results.")
7519       (home-page "https://shinmera.github.io/trivial-indent/")
7520       (license license:zlib))))
7521
7522 (define-public cl-trivial-indent
7523   (sbcl-package->cl-source-package sbcl-trivial-indent))
7524
7525 (define-public sbcl-documentation-utils
7526   (let ((commit "98630dd5f7e36ae057fa09da3523f42ccb5d1f55")
7527         (revision "0"))
7528     (package
7529       (name "sbcl-documentation-utils")
7530       (version (git-version "1.2.0" revision commit))
7531       (source
7532        (origin
7533          (method git-fetch)
7534          (uri
7535           (git-reference
7536            (url "https://github.com/Shinmera/documentation-utils.git")
7537            (commit commit)))
7538          (file-name (git-file-name name version))
7539          (sha256
7540           (base32
7541            "098qhkqskmmrh4wix34mawf7p5c87yql28r51r75yjxj577k5idq"))))
7542       (build-system asdf-build-system/sbcl)
7543       (inputs
7544        `(("trivial-indent" ,sbcl-trivial-indent)))
7545       (synopsis "Few simple tools to document Common Lisp libraries")
7546       (description
7547        "This is a small library to help you with managing the Common Lisp
7548 docstrings for your library.")
7549       (home-page "https://shinmera.github.io/documentation-utils/")
7550       (license license:zlib))))
7551
7552 (define-public cl-documentation-utils
7553   (sbcl-package->cl-source-package sbcl-documentation-utils))
7554
7555 (define-public ecl-documentation-utils
7556   (sbcl-package->ecl-package sbcl-documentation-utils))
7557
7558 (define-public sbcl-form-fiddle
7559   (let ((commit "e0c23599dbb8cff3e83e012f3d86d0764188ad18")
7560         (revision "0"))
7561     (package
7562       (name "sbcl-form-fiddle")
7563       (version (git-version "1.1.0" revision commit))
7564       (source
7565        (origin
7566          (method git-fetch)
7567          (uri
7568           (git-reference
7569            (url "https://github.com/Shinmera/form-fiddle")
7570            (commit commit)))
7571          (file-name (git-file-name name version))
7572          (sha256
7573           (base32
7574            "041iznc9mpfyrl0sv5893ys9pbb2pvbn9g3clarqi7gsfj483jln"))))
7575       (build-system asdf-build-system/sbcl)
7576       (inputs
7577        `(("documentation-utils" ,sbcl-documentation-utils)))
7578       (synopsis "Utilities to destructure Common Lisp lambda forms")
7579       (description
7580        "Often times we need to destructure a form definition in a Common Lisp
7581 macro.  This library provides a set of simple utilities to help with that.")
7582       (home-page "https://shinmera.github.io/form-fiddle/")
7583       (license license:zlib))))
7584
7585 (define-public cl-form-fiddle
7586   (sbcl-package->cl-source-package sbcl-form-fiddle))
7587
7588 (define-public sbcl-parachute
7589   (let ((commit "ca04dd8e43010a6dfffa26dbe1d62af86008d666")
7590         (revision "0"))
7591     (package
7592       (name "sbcl-parachute")
7593       (version (git-version "1.1.1" revision commit))
7594       (source
7595        (origin
7596          (method git-fetch)
7597          (uri
7598           (git-reference
7599            (url "https://github.com/Shinmera/parachute")
7600            (commit commit)))
7601          (file-name (git-file-name name version))
7602          (sha256
7603           (base32
7604            "1mvsm3r0r6a2bg75nw0q7n9vlby3ch45qjl7hnb5k1z2n5x5lh60"))))
7605       (build-system asdf-build-system/sbcl)
7606       (inputs
7607        `(("documentation-utils" ,sbcl-documentation-utils)
7608          ("form-fiddle" ,sbcl-form-fiddle)))
7609       (synopsis "Extensible and cross-compatible testing framework for Common Lisp")
7610       (description
7611        "Parachute is a simple-to-use and extensible testing framework.
7612 In Parachute, things are organised as a bunch of named tests within a package.
7613 Each test can contain a bunch of test forms that make up its body.")
7614       (home-page "https://shinmera.github.io/parachute/")
7615       (license license:zlib))))
7616
7617 (define-public cl-parachute
7618   (sbcl-package->cl-source-package sbcl-parachute))
7619
7620 (define-public sbcl-array-utils
7621   (let ((commit "f90eb9070d0b2205af51126a35033574725e5c56")
7622         (revision "0"))
7623     (package
7624       (name "sbcl-array-utils")
7625       (version (git-version "1.1.1" revision commit))
7626       (source
7627        (origin
7628          (method git-fetch)
7629          (uri
7630           (git-reference
7631            (url "https://github.com/Shinmera/array-utils")
7632            (commit commit)))
7633          (file-name (git-file-name name version))
7634          (sha256
7635           (base32
7636            "0zhwfbpr53vs1ii4sx75dz2k9yhh1xpwdqqpg8nmfndxkmhpbi3x"))))
7637       (build-system asdf-build-system/sbcl)
7638       (native-inputs
7639        `(("parachute" ,sbcl-parachute)))
7640       (inputs
7641        `(("documentation-utils" ,sbcl-documentation-utils)))
7642       (synopsis "Tiny collection of array and vector utilities for Common Lisp")
7643       (description
7644        "A miniature toolkit that contains some useful shifting/popping/pushing
7645 functions for arrays and vectors.  Originally from Plump.")
7646       (home-page "https://shinmera.github.io/array-utils/")
7647       (license license:zlib))))
7648
7649 (define-public cl-array-utils
7650   (sbcl-package->cl-source-package sbcl-array-utils))
7651
7652 (define-public sbcl-plump
7653   (let ((commit "16f1231bf706cfbc54d9e55a853ca945e4452a08")
7654         (revision "0"))
7655     (package
7656       (name "sbcl-plump")
7657       (version (git-version "2.0.0" revision commit))
7658       (source
7659        (origin
7660          (method git-fetch)
7661          (uri
7662           (git-reference
7663            (url "https://github.com/Shinmera/plump")
7664            (commit commit)))
7665          (file-name (git-file-name name version))
7666          (sha256
7667           (base32
7668            "0705k8pbip51v74rccgwscwph439f2pma9f915qf1h4bhjx999ip"))))
7669       (build-system asdf-build-system/sbcl)
7670       (inputs
7671        `(("array-utils" ,sbcl-array-utils)
7672          ("documentation-utils" ,sbcl-documentation-utils)))
7673       (synopsis "Lenient XML / XHTML / HTML parser for Common Lisp")
7674       (description
7675        "Plump is a parser for HTML/XML-like documents, focusing on being
7676 lenient towards invalid markup.  It can handle things like invalid attributes,
7677 bad closing tag order, unencoded entities, inexistent tag types, self-closing
7678 tags and so on.  It parses documents to a class representation and offers a
7679 small set of DOM functions to manipulate it.  It can be extended to parse to
7680 your own classes.")
7681       (home-page "https://shinmera.github.io/plump/")
7682       (license license:zlib))))
7683
7684 (define-public cl-plump
7685   (sbcl-package->cl-source-package sbcl-plump))
7686
7687 (define-public sbcl-antik-base
7688   (let ((commit "e4711a69b3d6bf37b5727af05c3cfd03e8428ba3")
7689         (revision "1"))
7690     (package
7691       (name "sbcl-antik-base")
7692       (version (git-version "0.0.0" revision commit))
7693       (source
7694        (origin
7695          (method git-fetch)
7696          (uri (git-reference
7697                (url "https://gitlab.common-lisp.net/antik/antik.git")
7698                (commit commit)))
7699          (file-name (git-file-name name version))
7700          (sha256
7701           (base32
7702            "047ga2c38par2xbgg4qx6hwv06qhf1c1f67as8xvir6s80lip1km"))))
7703       (build-system asdf-build-system/sbcl)
7704       (inputs
7705        `(("alexandria" ,sbcl-alexandria)
7706          ("cl-ppcre" ,sbcl-cl-ppcre)
7707          ("iterate" ,sbcl-iterate)
7708          ("metabang-bind" ,sbcl-metabang-bind)
7709          ("named-readtables" ,sbcl-named-readtables)
7710          ("split-sequence" ,sbcl-split-sequence)))
7711       (native-inputs
7712        `(("lisp-unit" ,sbcl-lisp-unit)))
7713       (synopsis "Scientific and engineering computation in Common Lisp")
7714       (description
7715        "Antik provides a foundation for scientific and engineering
7716 computation in Common Lisp.  It is designed not only to facilitate
7717 numerical computations, but to permit the use of numerical computation
7718 libraries and the interchange of data and procedures, whether
7719 foreign (non-Lisp) or Lisp libraries.  It is named after the
7720 Antikythera mechanism, one of the oldest examples of a scientific
7721 computer known.")
7722       (home-page "https://common-lisp.net/project/antik/")
7723       (license license:gpl3))))
7724
7725 (define-public cl-antik-base
7726   (sbcl-package->cl-source-package sbcl-antik-base))
7727
7728 (define-public ecl-antik-base
7729   (sbcl-package->ecl-package sbcl-antik-base))
7730
7731 (define-public sbcl-foreign-array
7732   (package
7733     (inherit sbcl-antik-base)
7734     (name "sbcl-foreign-array")
7735     (arguments
7736      (substitute-keyword-arguments (package-arguments sbcl-antik-base)
7737        ((#:asd-file _ "") "foreign-array.asd")
7738        ((#:asd-system-name _ #f) "foreign-array")))
7739     (inputs
7740      `(("antik-base" ,sbcl-antik-base)
7741        ("cffi" ,sbcl-cffi)
7742        ("trivial-garbage" ,sbcl-trivial-garbage)
7743        ("static-vectors" ,sbcl-static-vectors)))
7744     (synopsis "Common Lisp library providing access to foreign arrays")))
7745
7746 (define-public cl-foreign-array
7747   (sbcl-package->cl-source-package sbcl-foreign-array))
7748
7749 (define-public ecl-foreign-array
7750   (sbcl-package->ecl-package sbcl-foreign-array))
7751
7752 (define-public sbcl-physical-dimension
7753   (package
7754     (inherit sbcl-antik-base)
7755     (name "sbcl-physical-dimension")
7756     (inputs
7757      `(("fare-utils" ,sbcl-fare-utils)
7758        ("foreign-array" ,sbcl-foreign-array)
7759        ("trivial-utf-8" ,sbcl-trivial-utf-8)))
7760     (arguments
7761      (substitute-keyword-arguments (package-arguments sbcl-antik-base)
7762        ((#:asd-file _ "") "physical-dimension.asd")
7763        ((#:asd-system-name _ #f) "physical-dimension")))
7764     (synopsis
7765      "Common Lisp library providing computations with physical units")))
7766
7767 (define-public cl-physical-dimension
7768   (sbcl-package->cl-source-package sbcl-physical-dimension))
7769
7770 (define-public sbcl-science-data
7771   (package
7772     (inherit sbcl-antik-base)
7773     (name "sbcl-science-data")
7774     (inputs
7775      `(("physical-dimension" ,sbcl-physical-dimension)
7776        ("drakma" ,sbcl-drakma)))
7777     (arguments
7778      (substitute-keyword-arguments (package-arguments sbcl-antik-base)
7779        ((#:asd-file _ "") "science-data.asd")
7780        ((#:asd-system-name _ #f) "science-data")))
7781     (synopsis
7782      "Common Lisp library for scientific and engineering numerical data")))
7783
7784 (define-public cl-science-data
7785   (sbcl-package->cl-source-package sbcl-science-data))
7786
7787 (define-public sbcl-gsll
7788   (let ((commit "1a8ada22f9cf5ed7372d352b2317f4ccdb6ab308")
7789         (revision "1"))
7790     (package
7791       (name "sbcl-gsll")
7792       (version (git-version "0.0.0" revision commit))
7793       (source
7794        (origin
7795          (method git-fetch)
7796          (uri (git-reference
7797                (url "https://gitlab.common-lisp.net/antik/gsll.git")
7798                (commit commit)))
7799          (file-name (git-file-name name version))
7800          (sha256
7801           (base32
7802            "0z5nypfk26hxihb08p085644afawicrgb4xvadh3lmrn46qbjfn4"))))
7803       (build-system asdf-build-system/sbcl)
7804       (native-inputs
7805        `(("lisp-unit" ,sbcl-lisp-unit)))
7806       (inputs
7807        `(("alexandria" ,sbcl-alexandria)
7808          ("cffi-grovel" ,sbcl-cffi-grovel)
7809          ("cffi-libffi" ,sbcl-cffi-libffi)
7810          ("foreign-array" ,sbcl-foreign-array)
7811          ("gsl" ,gsl)
7812          ("metabang-bind" ,sbcl-metabang-bind)
7813          ("trivial-features" ,sbcl-trivial-features)
7814          ("trivial-garbage" ,sbcl-trivial-garbage)))
7815       (arguments
7816        `(#:tests? #f
7817          #:phases
7818          (modify-phases %standard-phases
7819            (add-after 'unpack 'fix-cffi-paths
7820              (lambda* (#:key inputs #:allow-other-keys)
7821                (substitute* "gsll.asd"
7822                  ((":depends-on \\(#:foreign-array")
7823                   ":depends-on (#:foreign-array #:cffi-libffi"))
7824                (substitute* "init/init.lisp"
7825                  (("libgslcblas.so" all)
7826                   (string-append
7827                    (assoc-ref inputs "gsl") "/lib/" all)))
7828                (substitute* "init/init.lisp"
7829                  (("libgsl.so" all)
7830                   (string-append
7831                    (assoc-ref inputs "gsl") "/lib/" all))))))))
7832       (synopsis "GNU Scientific Library for Lisp")
7833       (description
7834        "The GNU Scientific Library for Lisp (GSLL) allows the use of the
7835 GNU Scientific Library (GSL) from Common Lisp.  This library provides a
7836 full range of common mathematical operations useful to scientific and
7837 engineering applications.  The design of the GSLL interface is such
7838 that access to most of the GSL library is possible in a Lisp-natural
7839 way; the intent is that the user not be hampered by the restrictions
7840 of the C language in which GSL has been written.  GSLL thus provides
7841 interactive use of GSL for getting quick answers, even for someone not
7842 intending to program in Lisp.")
7843       (home-page "https://common-lisp.net/project/gsll/")
7844       (license license:gpl3))))
7845
7846 (define-public cl-gsll
7847   (sbcl-package->cl-source-package sbcl-gsll))
7848
7849 (define-public sbcl-antik
7850   (package
7851     (inherit sbcl-antik-base)
7852     (name "sbcl-antik")
7853     (inputs
7854      `(("gsll" ,sbcl-gsll)
7855        ("physical-dimension" ,sbcl-physical-dimension)))
7856     (arguments
7857      (substitute-keyword-arguments (package-arguments sbcl-antik-base)
7858        ((#:asd-file _ "") "antik.asd")
7859        ((#:asd-system-name _ #f) "antik")))))
7860
7861 (define-public cl-antik
7862   (sbcl-package->cl-source-package sbcl-antik))
7863
7864 (define-public sbcl-cl-interpol
7865   (let ((commit "1fd288d861db85bc4677cff3cdd6af75fda1afb4")
7866         (revision "1"))
7867     (package
7868       (name "sbcl-cl-interpol")
7869       (version (git-version "0.2.6" revision commit))
7870       (source
7871        (origin
7872          (method git-fetch)
7873          (uri (git-reference
7874                (url "https://github.com/edicl/cl-interpol.git")
7875                (commit commit)))
7876          (file-name (git-file-name name version))
7877          (sha256
7878           (base32
7879            "1hnikak52hmcq1r5f616m6qq1108qnkw80pja950nv1fq5p0ppjn"))))
7880       (build-system asdf-build-system/sbcl)
7881       (inputs
7882        `(("cl-unicode" ,sbcl-cl-unicode)
7883          ("named-readtables" ,sbcl-named-readtables)))
7884       (native-inputs
7885        `(("flexi-streams" ,sbcl-flexi-streams)))
7886       (synopsis "String interpolation for Common Lisp")
7887       (description
7888        "CL-INTERPOL is a library for Common Lisp which modifies the
7889 reader so that you can have interpolation within strings similar to
7890 Perl or Unix Shell scripts.  It also provides various ways to insert
7891 arbitrary characters into literal strings even if your editor/IDE
7892 doesn't support them.")
7893       (home-page "https://edicl.github.io/cl-interpol/")
7894       (license license:bsd-3))))
7895
7896 (define-public cl-interpol
7897   (sbcl-package->cl-source-package sbcl-cl-interpol))
7898
7899 (define-public ecl-cl-interpol
7900   (sbcl-package->ecl-package sbcl-cl-interpol))
7901
7902 (define sbcl-symbol-munger-boot0
7903   ;; There is a cyclical dependency between symbol-munger and lisp-unit2.
7904   ;; See https://github.com/AccelerationNet/symbol-munger/issues/4
7905   (let ((commit "cc2bb4b7acd454d756484aec81ba487648385fc3")
7906         (revision "1"))
7907     (package
7908       (name "sbcl-symbol-munger-boot0")
7909       (version (git-version "0.0.1" revision commit))
7910       (source
7911        (origin
7912          (method git-fetch)
7913          (uri (git-reference
7914                (url "https://github.com/AccelerationNet/symbol-munger.git")
7915                (commit commit)))
7916          (file-name (git-file-name name version))
7917          (sha256
7918           (base32
7919            "0diav5ricqsybqvbp4bkxyj3bn3v9n7xb2pqqc4vg1algsw2pyjl"))))
7920       (build-system asdf-build-system/sbcl)
7921       (arguments
7922        `(#:asd-file "symbol-munger.asd"
7923          #:asd-system-name "symbol-munger"))
7924       (inputs
7925        `(("iterate" ,sbcl-iterate)
7926          ("alexandria" ,sbcl-alexandria)))
7927       (native-inputs
7928        `(("lisp-unit" ,sbcl-lisp-unit)))
7929       (synopsis
7930        "Capitalization and spacing conversion functions for Common Lisp")
7931       (description
7932        "This is a Common Lisp library to change the capitalization and spacing
7933 of a string or a symbol.  It can convert to and from Lisp, english, underscore
7934 and camel-case rules.")
7935       (home-page "https://github.com/AccelerationNet/symbol-munger")
7936       ;; The package declares a BSD license, but all of the license
7937       ;; text is MIT.
7938       ;; See https://github.com/AccelerationNet/symbol-munger/issues/5
7939       (license license:expat))))
7940
7941 (define sbcl-lisp-unit2-boot0
7942   ;; There is a cyclical dependency between symbol-munger and lisp-unit2.
7943   ;; See https://github.com/AccelerationNet/symbol-munger/issues/4
7944   (let ((commit "fb9721524d1e4e73abb223ee036d74ce14a5505c")
7945         (revision "1"))
7946     (package
7947       (name "sbcl-lisp-unit2-boot0")
7948       (version (git-version "0.2.0" revision commit))
7949       (source
7950        (origin
7951          (method git-fetch)
7952          (uri (git-reference
7953                (url "https://github.com/AccelerationNet/lisp-unit2.git")
7954                (commit commit)))
7955          (file-name (git-file-name name version))
7956          (sha256
7957           (base32
7958            "1rsqy8y0jqll6xn9a593848f5wvd5ribv4csry1ly0hmdhfnqzlp"))))
7959       (build-system asdf-build-system/sbcl)
7960       (arguments
7961        `(#:asd-file "lisp-unit2.asd"
7962          #:asd-system-name "lisp-unit2"))
7963       (inputs
7964        `(("alexandria" ,sbcl-alexandria)
7965          ("cl-interpol" ,sbcl-cl-interpol)
7966          ("iterate" ,sbcl-iterate)
7967          ("symbol-munger-boot0" ,sbcl-symbol-munger-boot0)))
7968       (synopsis "Test Framework for Common Lisp")
7969       (description
7970        "LISP-UNIT2 is a Common Lisp library that supports unit testing in the
7971 style of JUnit for Java.  It is a new version of the lisp-unit library written
7972 by Chris Riesbeck.")
7973       (home-page "https://github.com/AccelerationNet/lisp-unit2")
7974       (license license:expat))))
7975
7976 (define-public sbcl-symbol-munger
7977   (let ((commit "97598d4c3c53fd5da72ab78908fbd5d8c7a13416")
7978         (revision "1"))
7979     (package
7980       (name "sbcl-symbol-munger")
7981       (version (git-version "0.0.1" revision commit))
7982       (source
7983        (origin
7984          (method git-fetch)
7985          (uri (git-reference
7986                (url "https://github.com/AccelerationNet/symbol-munger.git")
7987                (commit commit)))
7988          (file-name (git-file-name name version))
7989          (sha256
7990           (base32
7991            "0y8jywjy0ldyhp7bxf16fdvdd2qgqnd7nlhlqfpfnzxcqk4xy1km"))))
7992       (build-system asdf-build-system/sbcl)
7993       (inputs
7994        `(("alexandria" ,sbcl-alexandria)
7995          ("iterate" ,sbcl-iterate)))
7996       (native-inputs
7997        `(("lisp-unit2-boot0" ,sbcl-lisp-unit2-boot0)))
7998       (synopsis
7999        "Capitalization and spacing conversion functions for Common Lisp")
8000       (description
8001        "This is a Common Lisp library to change the capitalization and spacing
8002 of a string or a symbol.  It can convert to and from Lisp, english, underscore
8003 and camel-case rules.")
8004       (home-page "https://github.com/AccelerationNet/symbol-munger")
8005       ;; The package declares a BSD license, but all of the license
8006       ;; text is MIT.
8007       ;; See https://github.com/AccelerationNet/symbol-munger/issues/5
8008       (license license:expat))))
8009
8010 (define-public cl-symbol-munger
8011   (sbcl-package->cl-source-package sbcl-symbol-munger))
8012
8013 (define-public ecl-symbol-munger
8014   (sbcl-package->ecl-package sbcl-symbol-munger))
8015
8016 (define-public sbcl-lisp-unit2
8017   (package
8018     (inherit sbcl-lisp-unit2-boot0)
8019     (name "sbcl-lisp-unit2")
8020     (inputs
8021      `(("alexandria" ,sbcl-alexandria)
8022        ("cl-interpol" ,sbcl-cl-interpol)
8023        ("iterate" ,sbcl-iterate)
8024        ("symbol-munger" ,sbcl-symbol-munger)))))
8025
8026 (define-public cl-lisp-unit2
8027   (sbcl-package->cl-source-package sbcl-lisp-unit2))
8028
8029 (define-public ecl-lisp-unit2
8030   (sbcl-package->ecl-package sbcl-lisp-unit2))
8031
8032 (define-public sbcl-cl-csv
8033   (let ((commit "3eba29c8364b033fbe0d189c2500559278b6a362")
8034         (revision "1"))
8035     (package
8036       (name "sbcl-cl-csv")
8037       (version (git-version "1.0.6" revision commit))
8038       (source
8039        (origin
8040          (method git-fetch)
8041          (uri (git-reference
8042                (url "https://github.com/AccelerationNet/cl-csv.git")
8043                (commit commit)))
8044          (file-name (git-file-name name version))
8045          (sha256
8046           (base32
8047            "07h4ni89jzx93clx453hlnnb5g53hhlcmz5hghqv6ysam48lc8g6"))))
8048       (build-system asdf-build-system/sbcl)
8049       (arguments
8050        ;; See: https://github.com/AccelerationNet/cl-csv/pull/34
8051        `(#:tests? #f))
8052       (inputs
8053        `(("alexandria" ,sbcl-alexandria)
8054          ("cl-interpol" ,sbcl-cl-interpol)
8055          ("iterate" ,sbcl-iterate)))
8056       (native-inputs
8057        `(("lisp-unit2" ,sbcl-lisp-unit2)))
8058       (synopsis "Common lisp library for comma-separated values")
8059       (description
8060        "This is a Common Lisp library providing functions to read/write CSV
8061 from/to strings, streams and files.")
8062       (home-page "https://github.com/AccelerationNet/cl-csv")
8063       (license license:bsd-3))))
8064
8065 (define-public cl-csv
8066   (sbcl-package->cl-source-package sbcl-cl-csv))
8067
8068 (define-public ecl-cl-csv
8069   (sbcl-package->ecl-package sbcl-cl-csv))
8070
8071 (define-public sbcl-external-program
8072   (let ((commit "5888b8f1fd3953feeeacecbba4384ddda584a749")
8073         (revision "1"))
8074     (package
8075       (name "sbcl-external-program")
8076       (version (git-version "0.0.6" revision commit))
8077       (source
8078        (origin
8079          (method git-fetch)
8080          (uri (git-reference
8081                (url "https://github.com/sellout/external-program.git")
8082                (commit commit)))
8083          (file-name (git-file-name name version))
8084          (sha256
8085           (base32
8086            "0vww1x3yilb3bjwg6k184vaj4vxyxw4vralhnlm6lk4xac67kc9z"))))
8087       (build-system asdf-build-system/sbcl)
8088       (inputs
8089        `(("trivial-features" ,sbcl-trivial-features)))
8090       (native-inputs
8091        `(("fiveam" ,sbcl-fiveam)))
8092       (synopsis "Common Lisp library for running external programs")
8093       (description
8094        "EXTERNAL-PROGRAM enables running programs outside the Lisp
8095 process.  It is an attempt to make the RUN-PROGRAM functionality in
8096 implementations like SBCL and CCL as portable as possible without
8097 sacrificing much in the way of power.")
8098       (home-page "https://github.com/sellout/external-program")
8099       (license license:llgpl))))
8100
8101 (define-public cl-external-program
8102   (sbcl-package->cl-source-package sbcl-external-program))
8103
8104 (define-public ecl-external-program
8105   (sbcl-package->ecl-package sbcl-external-program))
8106
8107 (define sbcl-cl-ana-boot0
8108   (let ((commit "fa7cee4c50aa1c859652813049ba0da7c18a0df9")
8109         (revision "1"))
8110     (package
8111      (name "sbcl-cl-ana-boot0")
8112      (version (git-version "0.0.0" revision commit))
8113      (source
8114       (origin
8115        (method git-fetch)
8116        (uri (git-reference
8117              (url "https://github.com/ghollisjr/cl-ana.git")
8118              (commit commit)))
8119        (file-name (git-file-name name version))
8120        (sha256
8121         (base32
8122          "0mr47l57m276dbpap7irr4fcnk5fgknhf6mgv4043s8h73amk5qh"))))
8123      (build-system asdf-build-system/sbcl)
8124      (synopsis "Common Lisp data analysis library")
8125      (description
8126       "CL-ANA is a data analysis library in Common Lisp providing tabular and
8127 binned data analysis along with nonlinear least squares fitting and
8128 visualization.")
8129      (home-page "https://github.com/ghollisjr/cl-ana")
8130      (license license:gpl3))))
8131
8132 (define-public sbcl-cl-ana.pathname-utils
8133   (package
8134     (inherit sbcl-cl-ana-boot0)
8135     (name "sbcl-cl-ana.pathname-utils")
8136     (arguments
8137      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8138        ((#:asd-file _ "") "pathname-utils/cl-ana.pathname-utils.asd")
8139        ((#:asd-system-name _ #f) "cl-ana.pathname-utils")))))
8140
8141 (define-public cl-ana.pathname-utils
8142   (sbcl-package->cl-source-package sbcl-cl-ana.pathname-utils))
8143
8144 (define-public ecl-cl-ana.pathname-utils
8145   (sbcl-package->ecl-package sbcl-cl-ana.pathname-utils))
8146
8147 (define-public sbcl-cl-ana.package-utils
8148   (package
8149     (inherit sbcl-cl-ana-boot0)
8150     (name "sbcl-cl-ana.package-utils")
8151     (inputs
8152      `(("alexandria" ,sbcl-alexandria)))
8153     (arguments
8154      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8155        ((#:asd-file _ "") "package-utils/cl-ana.package-utils.asd")
8156        ((#:asd-system-name _ #f) "cl-ana.package-utils")))))
8157
8158 (define-public cl-ana.package-utils
8159   (sbcl-package->cl-source-package sbcl-cl-ana.package-utils))
8160
8161 (define-public ecl-cl-ana.package-utils
8162   (sbcl-package->ecl-package sbcl-cl-ana.package-utils))
8163
8164 (define-public sbcl-cl-ana.string-utils
8165   (package
8166     (inherit sbcl-cl-ana-boot0)
8167     (name "sbcl-cl-ana.string-utils")
8168     (inputs
8169      `(("split-sequence" ,sbcl-split-sequence)))
8170     (arguments
8171      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8172        ((#:asd-file _ "") "string-utils/cl-ana.string-utils.asd")
8173        ((#:asd-system-name _ #f) "cl-ana.string-utils")))))
8174
8175 (define-public cl-ana.string-utils
8176   (sbcl-package->cl-source-package sbcl-cl-ana.string-utils))
8177
8178 (define-public ecl-cl-ana.string-utils
8179   (sbcl-package->ecl-package sbcl-cl-ana.string-utils))
8180
8181 (define-public sbcl-cl-ana.functional-utils
8182   (package
8183     (inherit sbcl-cl-ana-boot0)
8184     (name "sbcl-cl-ana.functional-utils")
8185     (arguments
8186      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8187        ((#:asd-file _ "") "functional-utils/cl-ana.functional-utils.asd")
8188        ((#:asd-system-name _ #f) "cl-ana.functional-utils")))))
8189
8190 (define-public cl-ana.functional-utils
8191   (sbcl-package->cl-source-package sbcl-cl-ana.functional-utils))
8192
8193 (define-public ecl-cl-ana.functional-utils
8194   (sbcl-package->ecl-package sbcl-cl-ana.functional-utils))
8195
8196 (define-public sbcl-cl-ana.list-utils
8197   (package
8198     (inherit sbcl-cl-ana-boot0)
8199     (name "sbcl-cl-ana.list-utils")
8200     (inputs
8201      `(("alexandria" ,sbcl-alexandria)
8202        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
8203        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)))
8204     (arguments
8205      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8206        ((#:asd-file _ "") "list-utils/cl-ana.list-utils.asd")
8207        ((#:asd-system-name _ #f) "cl-ana.list-utils")))))
8208
8209 (define-public cl-ana.list-utils
8210   (sbcl-package->cl-source-package sbcl-cl-ana.list-utils))
8211
8212 (define-public ecl-cl-ana.list-utils
8213   (sbcl-package->ecl-package sbcl-cl-ana.list-utils))
8214
8215 (define-public sbcl-cl-ana.generic-math
8216   (package
8217     (inherit sbcl-cl-ana-boot0)
8218     (name "sbcl-cl-ana.generic-math")
8219     (inputs
8220      `(("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8221        ("cl-ana.package-utils" ,sbcl-cl-ana.package-utils)))
8222     (arguments
8223      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8224        ((#:asd-file _ "") "generic-math/cl-ana.generic-math.asd")
8225        ((#:asd-system-name _ #f) "cl-ana.generic-math")))))
8226
8227 (define-public cl-ana.generic-math
8228   (sbcl-package->cl-source-package sbcl-cl-ana.generic-math))
8229
8230 (define-public ecl-cl-ana.generic-math
8231   (sbcl-package->ecl-package sbcl-cl-ana.generic-math))
8232
8233 (define-public sbcl-cl-ana.math-functions
8234   (package
8235     (inherit sbcl-cl-ana-boot0)
8236     (name "sbcl-cl-ana.math-functions")
8237     (inputs
8238      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8239        ("gsll" ,sbcl-gsll)))
8240     (arguments
8241      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8242        ((#:asd-file _ "") "math-functions/cl-ana.math-functions.asd")
8243        ((#:asd-system-name _ #f) "cl-ana.math-functions")))))
8244
8245 (define-public cl-ana.math-functions
8246   (sbcl-package->cl-source-package sbcl-cl-ana.math-functions))
8247
8248 (define-public sbcl-cl-ana.calculus
8249   (package
8250     (inherit sbcl-cl-ana-boot0)
8251     (name "sbcl-cl-ana.calculus")
8252     (inputs
8253      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)))
8254     (arguments
8255      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8256        ((#:asd-file _ "") "calculus/cl-ana.calculus.asd")
8257        ((#:asd-system-name _ #f) "cl-ana.calculus")))))
8258
8259 (define-public cl-ana.calculus
8260   (sbcl-package->cl-source-package sbcl-cl-ana.calculus))
8261
8262 (define-public ecl-cl-ana.calculus
8263   (sbcl-package->ecl-package sbcl-cl-ana.calculus))
8264
8265 (define-public sbcl-cl-ana.symbol-utils
8266   (package
8267     (inherit sbcl-cl-ana-boot0)
8268     (name "sbcl-cl-ana.symbol-utils")
8269     (inputs
8270      `(("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)))
8271     (arguments
8272      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8273        ((#:asd-file _ "") "symbol-utils/cl-ana.symbol-utils.asd")
8274        ((#:asd-system-name _ #f) "cl-ana.symbol-utils")))))
8275
8276 (define-public cl-ana.symbol-utils
8277   (sbcl-package->cl-source-package sbcl-cl-ana.symbol-utils))
8278
8279 (define-public ecl-cl-ana.symbol-utils
8280   (sbcl-package->ecl-package sbcl-cl-ana.symbol-utils))
8281
8282 (define-public sbcl-cl-ana.macro-utils
8283   (package
8284     (inherit sbcl-cl-ana-boot0)
8285     (name "sbcl-cl-ana.macro-utils")
8286     (inputs
8287      `(("alexandria" ,sbcl-alexandria)
8288        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8289        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8290        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8291        ("split-sequence" ,sbcl-split-sequence)))
8292     (arguments
8293      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8294        ((#:asd-file _ "") "macro-utils/cl-ana.macro-utils.asd")
8295        ((#:asd-system-name _ #f) "cl-ana.macro-utils")))))
8296
8297 (define-public cl-ana.macro-utils
8298   (sbcl-package->cl-source-package sbcl-cl-ana.macro-utils))
8299
8300 (define-public ecl-cl-ana.macro-utils
8301   (sbcl-package->ecl-package sbcl-cl-ana.macro-utils))
8302
8303 (define-public sbcl-cl-ana.binary-tree
8304   (package
8305     (inherit sbcl-cl-ana-boot0)
8306     (name "sbcl-cl-ana.binary-tree")
8307     (inputs
8308      `(("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
8309        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8310        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)))
8311     (arguments
8312      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8313        ((#:asd-file _ "") "binary-tree/cl-ana.binary-tree.asd")
8314        ((#:asd-system-name _ #f) "cl-ana.binary-tree")))))
8315
8316 (define-public cl-ana.binary-tree
8317   (sbcl-package->cl-source-package sbcl-cl-ana.binary-tree))
8318
8319 (define-public ecl-cl-ana.binary-tree
8320   (sbcl-package->ecl-package sbcl-cl-ana.binary-tree))
8321
8322 (define-public sbcl-cl-ana.tensor
8323   (package
8324     (inherit sbcl-cl-ana-boot0)
8325     (name "sbcl-cl-ana.tensor")
8326     (inputs
8327      `(("alexandria" ,sbcl-alexandria)
8328        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8329        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8330        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8331        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)))
8332     (arguments
8333      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8334        ((#:asd-file _ "") "tensor/cl-ana.tensor.asd")
8335        ((#:asd-system-name _ #f) "cl-ana.tensor")))))
8336
8337 (define-public cl-ana.tensor
8338   (sbcl-package->cl-source-package sbcl-cl-ana.tensor))
8339
8340 (define-public ecl-cl-ana.tensor
8341   (sbcl-package->ecl-package sbcl-cl-ana.tensor))
8342
8343 (define-public sbcl-cl-ana.error-propogation
8344   (package
8345     (inherit sbcl-cl-ana-boot0)
8346     (name "sbcl-cl-ana.error-propogation")
8347     (inputs
8348      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8349        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)))
8350     (arguments
8351      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8352        ((#:asd-file _ "") "error-propogation/cl-ana.error-propogation.asd")
8353        ((#:asd-system-name _ #f) "cl-ana.error-propogation")))))
8354
8355 (define-public cl-ana.error-propogation
8356   (sbcl-package->cl-source-package sbcl-cl-ana.error-propogation))
8357
8358 (define-public sbcl-cl-ana.quantity
8359   (package
8360     (inherit sbcl-cl-ana-boot0)
8361     (name "sbcl-cl-ana.quantity")
8362     (inputs
8363      `(("alexandria" ,sbcl-alexandria)
8364        ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
8365        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8366        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8367        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8368        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)))
8369     (arguments
8370      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8371        ((#:asd-file _ "") "quantity/cl-ana.quantity.asd")
8372        ((#:asd-system-name _ #f) "cl-ana.quantity")))))
8373
8374 (define-public cl-ana.quantity
8375   (sbcl-package->cl-source-package sbcl-cl-ana.quantity))
8376
8377 (define-public sbcl-cl-ana.table
8378   (package
8379     (inherit sbcl-cl-ana-boot0)
8380     (name "sbcl-cl-ana.table")
8381     (inputs
8382      `(("alexandria" ,sbcl-alexandria)
8383        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
8384        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8385        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8386        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8387        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)))
8388     (arguments
8389      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8390        ((#:asd-file _ "") "table/cl-ana.table.asd")
8391        ((#:asd-system-name _ #f) "cl-ana.table")))))
8392
8393 (define-public cl-ana.table
8394   (sbcl-package->cl-source-package sbcl-cl-ana.table))
8395
8396 (define-public ecl-cl-ana.table
8397   (sbcl-package->ecl-package sbcl-cl-ana.table))
8398
8399 (define-public sbcl-cl-ana.table-utils
8400   (package
8401     (inherit sbcl-cl-ana-boot0)
8402     (name "sbcl-cl-ana.table-utils")
8403     (inputs
8404      `(("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8405        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8406        ("cl-ana.table" ,sbcl-cl-ana.table)))
8407     (arguments
8408      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8409        ((#:asd-file _ "") "table-utils/cl-ana.table-utils.asd")
8410        ((#:asd-system-name _ #f) "cl-ana.table-utils")))))
8411
8412 (define-public cl-ana.table-utils
8413   (sbcl-package->cl-source-package sbcl-cl-ana.table-utils))
8414
8415 (define-public ecl-cl-ana.table-utils
8416   (sbcl-package->ecl-package sbcl-cl-ana.table-utils))
8417
8418 (define-public sbcl-cl-ana.hdf-cffi
8419   (package
8420     (inherit sbcl-cl-ana-boot0)
8421     (name "sbcl-cl-ana.hdf-cffi")
8422     (inputs
8423      `(("cffi" ,sbcl-cffi)
8424        ("hdf5" ,hdf5-parallel-openmpi)))
8425     (arguments
8426      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8427        ((#:asd-file _ "") "hdf-cffi/cl-ana.hdf-cffi.asd")
8428        ((#:asd-system-name _ #f) "cl-ana.hdf-cffi")
8429        ((#:phases phases '%standard-phases)
8430         `(modify-phases ,phases
8431            (add-after 'unpack 'fix-paths
8432              (lambda* (#:key inputs #:allow-other-keys)
8433                (substitute* "hdf-cffi/hdf-cffi.lisp"
8434                  (("/usr/lib/i386-linux-gnu/hdf5/serial/libhdf5.so")
8435                   (string-append
8436                    (assoc-ref inputs "hdf5")
8437                    "/lib/libhdf5.so")))))))))))
8438
8439 (define-public cl-ana.hdf-cffi
8440   (sbcl-package->cl-source-package sbcl-cl-ana.hdf-cffi))
8441
8442 (define-public ecl-cl-ana.hdf-cffi
8443   (sbcl-package->ecl-package sbcl-cl-ana.hdf-cffi))
8444
8445 (define-public sbcl-cl-ana.int-char
8446   (package
8447     (inherit sbcl-cl-ana-boot0)
8448     (name "sbcl-cl-ana.int-char")
8449     (arguments
8450      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8451        ((#:asd-file _ "") "int-char/cl-ana.int-char.asd")
8452        ((#:asd-system-name _ #f) "cl-ana.int-char")))))
8453
8454 (define-public cl-ana.int-char
8455   (sbcl-package->cl-source-package sbcl-cl-ana.int-char))
8456
8457 (define-public ecl-cl-ana.int-char
8458   (sbcl-package->ecl-package sbcl-cl-ana.int-char))
8459
8460 (define-public sbcl-cl-ana.memoization
8461   (package
8462     (inherit sbcl-cl-ana-boot0)
8463     (name "sbcl-cl-ana.memoization")
8464     (inputs
8465      `(("alexandria" ,sbcl-alexandria)))
8466     (arguments
8467      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8468        ((#:asd-file _ "") "memoization/cl-ana.memoization.asd")
8469        ((#:asd-system-name _ #f) "cl-ana.memoization")))))
8470
8471 (define-public cl-ana.memoization
8472   (sbcl-package->cl-source-package sbcl-cl-ana.memoization))
8473
8474 (define-public ecl-cl-ana.memoization
8475   (sbcl-package->ecl-package sbcl-cl-ana.memoization))
8476
8477 (define-public sbcl-cl-ana.typespec
8478   (package
8479     (inherit sbcl-cl-ana-boot0)
8480     (name "sbcl-cl-ana.typespec")
8481     (inputs
8482      `(("alexandria" ,sbcl-alexandria)
8483        ("cffi" ,sbcl-cffi)
8484        ("cl-ana.int-char" ,sbcl-cl-ana.int-char)
8485        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8486        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
8487        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8488        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8489        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)))
8490     (arguments
8491      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8492        ((#:asd-file _ "") "typespec/cl-ana.typespec.asd")
8493        ((#:asd-system-name _ #f) "cl-ana.typespec")))))
8494
8495 (define-public cl-ana.typespec
8496   (sbcl-package->cl-source-package sbcl-cl-ana.typespec))
8497
8498 (define-public ecl-cl-ana.typespec
8499   (sbcl-package->ecl-package sbcl-cl-ana.typespec))
8500
8501 (define-public sbcl-cl-ana.hdf-typespec
8502   (package
8503     (inherit sbcl-cl-ana-boot0)
8504     (name "sbcl-cl-ana.hdf-typespec")
8505     (inputs
8506      `(("alexandria" ,sbcl-alexandria)
8507        ("cffi" ,sbcl-cffi)
8508        ("cl-ana.hdf-cffi" ,sbcl-cl-ana.hdf-cffi)
8509        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8510        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
8511        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8512        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8513        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
8514     (arguments
8515      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8516        ((#:asd-file _ "") "hdf-typespec/cl-ana.hdf-typespec.asd")
8517        ((#:asd-system-name _ #f) "cl-ana.hdf-typespec")))))
8518
8519 (define-public cl-ana.hdf-typespec
8520   (sbcl-package->cl-source-package sbcl-cl-ana.hdf-typespec))
8521
8522 (define-public ecl-cl-ana.hdf-typespec
8523   (sbcl-package->ecl-package sbcl-cl-ana.hdf-typespec))
8524
8525 (define-public sbcl-cl-ana.hdf-utils
8526   (package
8527     (inherit sbcl-cl-ana-boot0)
8528     (name "sbcl-cl-ana.hdf-utils")
8529     (inputs
8530      `(("alexandria" ,sbcl-alexandria)
8531        ("cffi" ,sbcl-cffi)
8532        ("cl-ana.hdf-cffi" ,sbcl-cl-ana.hdf-cffi)
8533        ("cl-ana.hdf-typespec" ,sbcl-cl-ana.hdf-typespec)
8534        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8535        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
8536        ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
8537        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8538        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
8539     (arguments
8540      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8541        ((#:asd-file _ "") "hdf-utils/cl-ana.hdf-utils.asd")
8542        ((#:asd-system-name _ #f) "cl-ana.hdf-utils")))))
8543
8544 (define-public cl-ana.hdf-utils
8545   (sbcl-package->cl-source-package sbcl-cl-ana.hdf-utils))
8546
8547 (define-public ecl-cl-ana.hdf-utils
8548   (sbcl-package->ecl-package sbcl-cl-ana.hdf-utils))
8549
8550 (define-public sbcl-cl-ana.typed-table
8551   (package
8552     (inherit sbcl-cl-ana-boot0)
8553     (name "sbcl-cl-ana.typed-table")
8554     (inputs
8555      `(("alexandria" ,sbcl-alexandria)
8556        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8557        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8558        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8559        ("cl-ana.table" ,sbcl-cl-ana.table)
8560        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
8561     (arguments
8562      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8563        ((#:asd-file _ "") "typed-table/cl-ana.typed-table.asd")
8564        ((#:asd-system-name _ #f) "cl-ana.typed-table")))))
8565
8566 (define-public cl-ana.typed-table
8567   (sbcl-package->cl-source-package sbcl-cl-ana.typed-table))
8568
8569 (define-public ecl-cl-ana.typed-table
8570   (sbcl-package->ecl-package sbcl-cl-ana.typed-table))
8571
8572 (define-public sbcl-cl-ana.hdf-table
8573   (package
8574     (inherit sbcl-cl-ana-boot0)
8575     (name "sbcl-cl-ana.hdf-table")
8576     (inputs
8577      `(("alexandria" ,sbcl-alexandria)
8578        ("cl-ana.binary-tree" ,sbcl-cl-ana.binary-tree)
8579        ("cl-ana.hdf-cffi" ,sbcl-cl-ana.hdf-cffi)
8580        ("cl-ana.hdf-typespec" ,sbcl-cl-ana.hdf-typespec)
8581        ("cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
8582        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8583        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
8584        ("cl-ana.table" ,sbcl-cl-ana.table)
8585        ("cl-ana.typed-table" ,sbcl-cl-ana.typed-table)
8586        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
8587     (arguments
8588      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8589        ((#:asd-file _ "") "hdf-table/cl-ana.hdf-table.asd")
8590        ((#:asd-system-name _ #f) "cl-ana.hdf-table")))))
8591
8592 (define-public cl-ana.hdf-table
8593   (sbcl-package->cl-source-package sbcl-cl-ana.hdf-table))
8594
8595 (define-public ecl-cl-ana.hdf-table
8596   (sbcl-package->ecl-package sbcl-cl-ana.hdf-table))
8597
8598 (define-public sbcl-cl-ana.gsl-cffi
8599   (package
8600     (inherit sbcl-cl-ana-boot0)
8601     (name "sbcl-cl-ana.gsl-cffi")
8602     (inputs
8603      `(("cffi" ,sbcl-cffi)
8604        ("gsl" ,gsl)))
8605     (arguments
8606      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8607        ((#:asd-file _ "") "gsl-cffi/cl-ana.gsl-cffi.asd")
8608        ((#:asd-system-name _ #f) "cl-ana.gsl-cffi")
8609        ((#:phases phases '%standard-phases)
8610         `(modify-phases ,phases
8611            (add-after 'unpack 'fix-paths
8612              (lambda* (#:key inputs #:allow-other-keys)
8613                (substitute* "gsl-cffi/gsl-cffi.lisp"
8614                  (("define-foreign-library gsl-cffi" all)
8615                   (string-append all " (:unix "
8616                                  (assoc-ref inputs "gsl")
8617                                  "/lib/libgsl.so)")))))))))))
8618
8619 (define-public cl-ana.gsl-cffi
8620   (sbcl-package->cl-source-package sbcl-cl-ana.gsl-cffi))
8621
8622 (define-public ecl-cl-ana.gsl-cffi
8623   (sbcl-package->ecl-package sbcl-cl-ana.gsl-cffi))
8624
8625 (define-public sbcl-cl-ana.ntuple-table
8626   (package
8627     (inherit sbcl-cl-ana-boot0)
8628     (name "sbcl-cl-ana.ntuple-table")
8629     (inputs
8630      `(("alexandria" ,sbcl-alexandria)
8631        ("cffi" ,sbcl-cffi)
8632        ("cl-ana.gsl-cffi" ,sbcl-cl-ana.gsl-cffi)
8633        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8634        ("cl-ana.table" ,sbcl-cl-ana.table)
8635        ("cl-ana.typed-table" ,sbcl-cl-ana.typed-table)
8636        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)
8637        ("gsll" ,sbcl-gsll)))
8638     (arguments
8639      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8640        ((#:asd-file _ "") "ntuple-table/cl-ana.ntuple-table.asd")
8641        ((#:asd-system-name _ #f) "cl-ana.ntuple-table")))))
8642
8643 (define-public cl-ana.ntuple-table
8644   (sbcl-package->cl-source-package sbcl-cl-ana.ntuple-table))
8645
8646 (define-public sbcl-cl-ana.csv-table
8647   (package
8648     (inherit sbcl-cl-ana-boot0)
8649     (name "sbcl-cl-ana.csv-table")
8650     (inputs
8651      `(("alexandria" ,sbcl-alexandria)
8652        ("antik" ,sbcl-antik)
8653        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8654        ("cl-ana.table" ,sbcl-cl-ana.table)
8655        ("cl-csv" ,sbcl-cl-csv)
8656        ("iterate" ,sbcl-iterate)))
8657     (arguments
8658      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8659        ((#:asd-file _ "") "csv-table/cl-ana.csv-table.asd")
8660        ((#:asd-system-name _ #f) "cl-ana.csv-table")))))
8661
8662 (define-public cl-ana.csv-table
8663   (sbcl-package->cl-source-package sbcl-cl-ana.csv-table))
8664
8665 (define-public sbcl-cl-ana.reusable-table
8666   (package
8667     (inherit sbcl-cl-ana-boot0)
8668     (name "sbcl-cl-ana.reusable-table")
8669     (inputs
8670      `(("alexandria" ,sbcl-alexandria)
8671        ("cl-ana.table" ,sbcl-cl-ana.table)))
8672     (arguments
8673      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8674        ((#:asd-file _ "") "reusable-table/cl-ana.reusable-table.asd")
8675        ((#:asd-system-name _ #f) "cl-ana.reusable-table")))))
8676
8677 (define-public cl-ana.reusable-table
8678   (sbcl-package->cl-source-package sbcl-cl-ana.reusable-table))
8679
8680 (define-public ecl-cl-ana.reusable-table
8681   (sbcl-package->ecl-package sbcl-cl-ana.reusable-table))
8682
8683 (define-public sbcl-cl-ana.linear-algebra
8684   (package
8685     (inherit sbcl-cl-ana-boot0)
8686     (name "sbcl-cl-ana.linear-algebra")
8687     (inputs
8688      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8689        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8690        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
8691        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
8692        ("gsll" ,sbcl-gsll)))
8693     (arguments
8694      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8695        ((#:asd-file _ "") "linear-algebra/cl-ana.linear-algebra.asd")
8696        ((#:asd-system-name _ #f) "cl-ana.linear-algebra")))))
8697
8698 (define-public cl-ana.linear-algebra
8699   (sbcl-package->cl-source-package sbcl-cl-ana.linear-algebra))
8700
8701 (define-public sbcl-cl-ana.lorentz
8702   (package
8703     (inherit sbcl-cl-ana-boot0)
8704     (name "sbcl-cl-ana.lorentz")
8705     (inputs
8706      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8707        ("cl-ana.linear-algebra" ,sbcl-cl-ana.linear-algebra)
8708        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
8709        ("iterate" ,sbcl-iterate)))
8710     (arguments
8711      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8712        ((#:asd-file _ "") "lorentz/cl-ana.lorentz.asd")
8713        ((#:asd-system-name _ #f) "cl-ana.lorentz")))))
8714
8715 (define-public cl-ana.lorentz
8716   (sbcl-package->cl-source-package sbcl-cl-ana.lorentz))
8717
8718 (define-public sbcl-cl-ana.clos-utils
8719   (package
8720     (inherit sbcl-cl-ana-boot0)
8721     (name "sbcl-cl-ana.clos-utils")
8722     (inputs
8723      `(("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8724        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8725        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
8726        ("closer-mop" ,sbcl-closer-mop)))
8727     (arguments
8728      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8729        ((#:asd-file _ "") "clos-utils/cl-ana.clos-utils.asd")
8730        ((#:asd-system-name _ #f) "cl-ana.clos-utils")))))
8731
8732 (define-public cl-ana.clos-utils
8733   (sbcl-package->cl-source-package sbcl-cl-ana.clos-utils))
8734
8735 (define-public ecl-cl-ana.clos-utils
8736   (sbcl-package->ecl-package sbcl-cl-ana.clos-utils))
8737
8738 (define-public sbcl-cl-ana.hash-table-utils
8739   (package
8740     (inherit sbcl-cl-ana-boot0)
8741     (name "sbcl-cl-ana.hash-table-utils")
8742     (arguments
8743      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8744        ((#:asd-file _ "") "hash-table-utils/cl-ana.hash-table-utils.asd")
8745        ((#:asd-system-name _ #f) "cl-ana.hash-table-utils")))))
8746
8747 (define-public cl-ana.hash-table-utils
8748   (sbcl-package->cl-source-package sbcl-cl-ana.hash-table-utils))
8749
8750 (define-public ecl-cl-ana.hash-table-utils
8751   (sbcl-package->ecl-package sbcl-cl-ana.hash-table-utils))
8752
8753 (define-public sbcl-cl-ana.map
8754   (package
8755     (inherit sbcl-cl-ana-boot0)
8756     (name "sbcl-cl-ana.map")
8757     (inputs
8758      `(("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)))
8759     (arguments
8760      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8761        ((#:asd-file _ "") "map/cl-ana.map.asd")
8762        ((#:asd-system-name _ #f) "cl-ana.map")))))
8763
8764 (define-public cl-ana.map
8765   (sbcl-package->cl-source-package sbcl-cl-ana.map))
8766
8767 (define-public ecl-cl-ana.map
8768   (sbcl-package->ecl-package sbcl-cl-ana.map))
8769
8770 (define-public sbcl-cl-ana.fitting
8771   (package
8772     (inherit sbcl-cl-ana-boot0)
8773     (name "sbcl-cl-ana.fitting")
8774     (inputs
8775      `(("alexandria" ,sbcl-alexandria)
8776        ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
8777        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8778        ("cl-ana.map" ,sbcl-cl-ana.map)
8779        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
8780        ("gsll" ,sbcl-gsll)))
8781     (arguments
8782      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8783        ((#:asd-file _ "") "fitting/cl-ana.fitting.asd")
8784        ((#:asd-system-name _ #f) "cl-ana.fitting")))))
8785
8786 (define-public cl-ana.fitting
8787   (sbcl-package->cl-source-package sbcl-cl-ana.fitting))
8788
8789 (define-public sbcl-cl-ana.histogram
8790   (package
8791     (inherit sbcl-cl-ana-boot0)
8792     (name "sbcl-cl-ana.histogram")
8793     (inputs
8794      `(("alexandria" ,sbcl-alexandria)
8795        ("iterate" ,sbcl-iterate)
8796        ("cl-ana.binary-tree" ,sbcl-cl-ana.binary-tree)
8797        ("cl-ana.clos-utils" ,sbcl-cl-ana.clos-utils)
8798        ("cl-ana.fitting" ,sbcl-cl-ana.fitting)
8799        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
8800        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8801        ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
8802        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8803        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8804        ("cl-ana.map" ,sbcl-cl-ana.map)
8805        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)))
8806     (arguments
8807      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8808        ((#:asd-file _ "") "histogram/cl-ana.histogram.asd")
8809        ((#:asd-system-name _ #f) "cl-ana.histogram")))))
8810
8811 (define-public cl-ana.histogram
8812   (sbcl-package->cl-source-package sbcl-cl-ana.histogram))
8813
8814 (define-public sbcl-cl-ana.file-utils
8815   (package
8816     (inherit sbcl-cl-ana-boot0)
8817     (name "sbcl-cl-ana.file-utils")
8818     (inputs
8819      `(("external-program" ,sbcl-external-program)
8820        ("split-sequence" ,sbcl-split-sequence)))
8821     (arguments
8822      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8823        ((#:asd-file _ "") "file-utils/cl-ana.file-utils.asd")
8824        ((#:asd-system-name _ #f) "cl-ana.file-utils")))))
8825
8826 (define-public cl-ana.file-utils
8827   (sbcl-package->cl-source-package sbcl-cl-ana.file-utils))
8828
8829 (define-public ecl-cl-ana.file-utils
8830   (sbcl-package->ecl-package sbcl-cl-ana.file-utils))
8831
8832 (define-public sbcl-cl-ana.statistics
8833   (package
8834     (inherit sbcl-cl-ana-boot0)
8835     (name "sbcl-cl-ana.statistics")
8836     (inputs
8837      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8838        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
8839        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8840        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8841        ("cl-ana.map" ,sbcl-cl-ana.map)))
8842     (arguments
8843      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8844        ((#:asd-file _ "") "statistics/cl-ana.statistics.asd")
8845        ((#:asd-system-name _ #f) "cl-ana.statistics")))))
8846
8847 (define-public cl-ana.statistics
8848   (sbcl-package->cl-source-package sbcl-cl-ana.statistics))
8849
8850 (define-public sbcl-cl-ana.gnuplot-interface
8851   (package
8852     (inherit sbcl-cl-ana-boot0)
8853     (name "sbcl-cl-ana.gnuplot-interface")
8854     (inputs
8855      `(("external-program" ,sbcl-external-program)))
8856     (arguments
8857      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8858        ((#:asd-file _ "") "gnuplot-interface/cl-ana.gnuplot-interface.asd")
8859        ((#:asd-system-name _ #f) "cl-ana.gnuplot-interface")))))
8860
8861 (define-public cl-ana.gnuplot-interface
8862   (sbcl-package->cl-source-package sbcl-cl-ana.gnuplot-interface))
8863
8864 (define-public ecl-cl-ana.gnuplot-interface
8865   (sbcl-package->ecl-package sbcl-cl-ana.gnuplot-interface))
8866
8867 (define-public sbcl-cl-ana.plotting
8868   (package
8869     (inherit sbcl-cl-ana-boot0)
8870     (name "sbcl-cl-ana.plotting")
8871     (inputs
8872      `(("alexandria" ,sbcl-alexandria)
8873        ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
8874        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
8875        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8876        ("cl-ana.gnuplot-interface" ,sbcl-cl-ana.gnuplot-interface)
8877        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
8878        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8879        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8880        ("cl-ana.map" ,sbcl-cl-ana.map)
8881        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
8882        ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
8883        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8884        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
8885        ("external-program" ,sbcl-external-program)
8886        ("split-sequence" ,sbcl-split-sequence)))
8887     (arguments
8888      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8889        ((#:asd-file _ "") "plotting/cl-ana.plotting.asd")
8890        ((#:asd-system-name _ #f) "cl-ana.plotting")))))
8891
8892 (define-public cl-ana.plotting
8893   (sbcl-package->cl-source-package sbcl-cl-ana.plotting))
8894
8895 (define-public sbcl-cl-ana.table-viewing
8896   (package
8897     (inherit sbcl-cl-ana-boot0)
8898     (name "sbcl-cl-ana.table-viewing")
8899     (inputs
8900      `(("alexandria" ,sbcl-alexandria)
8901        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8902        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
8903        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8904        ("cl-ana.plotting" ,sbcl-cl-ana.plotting)
8905        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8906        ("cl-ana.table" ,sbcl-cl-ana.table)))
8907     (arguments
8908      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8909        ((#:asd-file _ "") "table-viewing/cl-ana.table-viewing.asd")
8910        ((#:asd-system-name _ #f) "cl-ana.table-viewing")))))
8911
8912 (define-public cl-ana.table-viewing
8913   (sbcl-package->cl-source-package sbcl-cl-ana.table-viewing))
8914
8915 (define-public sbcl-cl-ana.serialization
8916   (package
8917     (inherit sbcl-cl-ana-boot0)
8918     (name "sbcl-cl-ana.serialization")
8919     (inputs
8920      `(("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
8921        ("cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
8922        ("cl-ana.hdf-table" ,sbcl-cl-ana.hdf-table)
8923        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
8924        ("cl-ana.int-char" ,sbcl-cl-ana.int-char)
8925        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8926        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
8927     (arguments
8928      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8929        ((#:asd-file _ "") "serialization/cl-ana.serialization.asd")
8930        ((#:asd-system-name _ #f) "cl-ana.serialization")))))
8931
8932 (define-public cl-ana.serialization
8933   (sbcl-package->cl-source-package sbcl-cl-ana.serialization))
8934
8935 (define-public sbcl-cl-ana.makeres
8936   (package
8937     (inherit sbcl-cl-ana-boot0)
8938     (name "sbcl-cl-ana.makeres")
8939     (inputs
8940      `(("alexandria" ,sbcl-alexandria)
8941        ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
8942        ("cl-ana.file-utils" ,sbcl-cl-ana.file-utils)
8943        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
8944        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8945        ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
8946        ("cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
8947        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
8948        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8949        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8950        ("cl-ana.map" ,sbcl-cl-ana.map)
8951        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
8952        ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
8953        ("cl-ana.plotting" ,sbcl-cl-ana.plotting)
8954        ("cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
8955        ("cl-ana.serialization" ,sbcl-cl-ana.serialization)
8956        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8957        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8958        ("cl-ana.table" ,sbcl-cl-ana.table)
8959        ("external-program" ,sbcl-external-program)))
8960     (native-inputs
8961      `(("cl-fad" ,sbcl-cl-fad)))
8962     (arguments
8963      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8964        ((#:asd-file _ "") "makeres/cl-ana.makeres.asd")
8965        ((#:asd-system-name _ #f) "cl-ana.makeres")))))
8966
8967 (define-public cl-ana.makeres
8968   (sbcl-package->cl-source-package sbcl-cl-ana.makeres))
8969
8970 (define-public sbcl-cl-ana.makeres-macro
8971   (package
8972     (inherit sbcl-cl-ana-boot0)
8973     (name "sbcl-cl-ana.makeres-macro")
8974     (inputs
8975      `(("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8976        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)))
8977     (arguments
8978      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8979        ((#:asd-file _ "") "makeres-macro/cl-ana.makeres-macro.asd")
8980        ((#:asd-system-name _ #f) "cl-ana.makeres-macro")))))
8981
8982 (define-public cl-ana.makeres-macro
8983   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-macro))
8984
8985 (define-public sbcl-cl-ana.makeres-block
8986   (package
8987     (inherit sbcl-cl-ana-boot0)
8988     (name "sbcl-cl-ana.makeres-block")
8989     (inputs
8990      `(("alexandria" ,sbcl-alexandria)
8991        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8992        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8993        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)))
8994     (arguments
8995      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8996        ((#:asd-file _ "") "makeres-block/cl-ana.makeres-block.asd")
8997        ((#:asd-system-name _ #f) "cl-ana.makeres-block")))))
8998
8999 (define-public cl-ana.makeres-block
9000   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-block))
9001
9002 (define-public sbcl-cl-ana.makeres-progress
9003   (package
9004     (inherit sbcl-cl-ana-boot0)
9005     (name "sbcl-cl-ana.makeres-progress")
9006     (inputs
9007      `(("alexandria" ,sbcl-alexandria)
9008        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9009        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)))
9010     (arguments
9011      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9012        ((#:asd-file _ "") "makeres-progress/cl-ana.makeres-progress.asd")
9013        ((#:asd-system-name _ #f) "cl-ana.makeres-progress")))))
9014
9015 (define-public cl-ana.makeres-progress
9016   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-progress))
9017
9018 (define-public sbcl-cl-ana.makeres-table
9019   (package
9020     (inherit sbcl-cl-ana-boot0)
9021     (name "sbcl-cl-ana.makeres-table")
9022     (inputs
9023      `(("cl-ana.csv-table" ,sbcl-cl-ana.csv-table)
9024        ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
9025        ("cl-ana.hdf-table" ,sbcl-cl-ana.hdf-table)
9026        ("cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
9027        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9028        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9029        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)
9030        ("cl-ana.makeres-macro" ,sbcl-cl-ana.makeres-macro)
9031        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
9032        ("cl-ana.ntuple-table" ,sbcl-cl-ana.ntuple-table)
9033        ("cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
9034        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
9035        ("cl-ana.table" ,sbcl-cl-ana.table)))
9036     (native-inputs
9037      `(("cl-fad" ,sbcl-cl-fad)))
9038     (arguments
9039      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9040        ((#:asd-file _ "") "makeres-table/cl-ana.makeres-table.asd")
9041        ((#:asd-system-name _ #f) "cl-ana.makeres-table")))))
9042
9043 (define-public cl-ana.makeres-table
9044   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-table))
9045
9046 (define-public sbcl-cl-ana.makeres-graphviz
9047   (package
9048     (inherit sbcl-cl-ana-boot0)
9049     (name "sbcl-cl-ana.makeres-graphviz")
9050     (inputs
9051      `(("cl-ana.makeres" ,sbcl-cl-ana.makeres)
9052        ("external-program" ,sbcl-external-program)))
9053     (arguments
9054      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9055        ((#:asd-file _ "") "makeres-graphviz/cl-ana.makeres-graphviz.asd")
9056        ((#:asd-system-name _ #f) "cl-ana.makeres-graphviz")))))
9057
9058 (define-public cl-ana.makeres-graphviz
9059   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-graphviz))
9060
9061 (define-public sbcl-cl-ana.makeres-branch
9062   (package
9063     (inherit sbcl-cl-ana-boot0)
9064     (name "sbcl-cl-ana.makeres-branch")
9065     (inputs
9066      `(("alexandria" ,sbcl-alexandria)
9067        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9068        ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
9069        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9070        ("cl-ana.map" ,sbcl-cl-ana.map)
9071        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)))
9072     (arguments
9073      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9074        ((#:asd-file _ "") "makeres-branch/cl-ana.makeres-branch.asd")
9075        ((#:asd-system-name _ #f) "cl-ana.makeres-branch")))))
9076
9077 (define-public cl-ana.makeres-branch
9078   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-branch))
9079
9080 (define-public sbcl-cl-ana.makeres-utils
9081   (package
9082     (inherit sbcl-cl-ana-boot0)
9083     (name "sbcl-cl-ana.makeres-utils")
9084     (inputs
9085      `(("alexandria" ,sbcl-alexandria)
9086        ("cl-ana.file-utils" ,sbcl-cl-ana.file-utils)
9087        ("cl-ana.fitting" ,sbcl-cl-ana.fitting)
9088        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
9089        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9090        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9091        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9092        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9093        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)
9094        ("cl-ana.map" ,sbcl-cl-ana.map)
9095        ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
9096        ("cl-ana.plotting" ,sbcl-cl-ana.plotting)
9097        ("cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
9098        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
9099        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
9100        ("cl-ana.table" ,sbcl-cl-ana.table)))
9101     (native-inputs
9102      `(("cl-fad" ,sbcl-cl-fad)))
9103     (arguments
9104      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9105        ((#:asd-file _ "") "makeres-utils/cl-ana.makeres-utils.asd")
9106        ((#:asd-system-name _ #f) "cl-ana.makeres-utils")))))
9107
9108 (define-public cl-ana.makeres-utils
9109   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-utils))
9110
9111 (define-public sbcl-cl-ana.statistical-learning
9112   (package
9113     (inherit sbcl-cl-ana-boot0)
9114     (name "sbcl-cl-ana.statistical-learning")
9115     (inputs
9116      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9117        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
9118        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9119        ("cl-ana.linear-algebra" ,sbcl-cl-ana.linear-algebra)
9120        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9121        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9122        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
9123        ("cl-ana.map" ,sbcl-cl-ana.map)
9124        ("cl-ana.statistics" ,sbcl-cl-ana.statistics)))
9125     (native-inputs
9126      `(("cl-fad" ,sbcl-cl-fad)))
9127     (arguments
9128      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9129        ((#:asd-file _ "")
9130         "statistical-learning/cl-ana.statistical-learning.asd")
9131        ((#:asd-system-name _ #f) "cl-ana.statistical-learning")))))
9132
9133 (define-public cl-ana.statistical-learning
9134   (sbcl-package->cl-source-package sbcl-cl-ana.statistical-learning))
9135
9136 (define-public sbcl-cl-ana
9137   (package
9138     (inherit sbcl-cl-ana-boot0)
9139     (name "sbcl-cl-ana")
9140     (inputs
9141      `(("cl-ana.binary-tree" ,sbcl-cl-ana.binary-tree)
9142        ("cl-ana.calculus" ,sbcl-cl-ana.calculus)
9143        ("cl-ana.clos-utils" ,sbcl-cl-ana.clos-utils)
9144        ("cl-ana.csv-table" ,sbcl-cl-ana.csv-table)
9145        ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
9146        ("cl-ana.file-utils" ,sbcl-cl-ana.file-utils)
9147        ("cl-ana.fitting" ,sbcl-cl-ana.fitting)
9148        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9149        ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
9150        ("cl-ana.hdf-table" ,sbcl-cl-ana.hdf-table)
9151        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9152        ("cl-ana.int-char" ,sbcl-cl-ana.int-char)
9153        ("cl-ana.linear-algebra" ,sbcl-cl-ana.linear-algebra)
9154        ("cl-ana.lorentz" ,sbcl-cl-ana.lorentz)
9155        ("cl-ana.map" ,sbcl-cl-ana.map)
9156        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)
9157        ("cl-ana.makeres-block" ,sbcl-cl-ana.makeres-block)
9158        ("cl-ana.makeres-branch" ,sbcl-cl-ana.makeres-branch)
9159        ("cl-ana.makeres-graphviz" ,sbcl-cl-ana.makeres-graphviz)
9160        ("cl-ana.makeres-macro" ,sbcl-cl-ana.makeres-macro)
9161        ("cl-ana.makeres-progress" ,sbcl-cl-ana.makeres-progress)
9162        ("cl-ana.makeres-table" ,sbcl-cl-ana.makeres-table)
9163        ("cl-ana.makeres-utils" ,sbcl-cl-ana.makeres-utils)
9164        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
9165        ("cl-ana.ntuple-table" ,sbcl-cl-ana.ntuple-table)
9166        ("cl-ana.package-utils" ,sbcl-cl-ana.package-utils)
9167        ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
9168        ("cl-ana.plotting" ,sbcl-cl-ana.plotting)
9169        ("cl-ana.quantity" ,sbcl-cl-ana.quantity)
9170        ("cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
9171        ("cl-ana.serialization" ,sbcl-cl-ana.serialization)
9172        ("cl-ana.statistics" ,sbcl-cl-ana.statistics)
9173        ("cl-ana.statistical-learning" ,sbcl-cl-ana.statistical-learning)
9174        ("cl-ana.table" ,sbcl-cl-ana.table)
9175        ("cl-ana.table-utils" ,sbcl-cl-ana.table-utils)
9176        ("cl-ana.table-viewing" ,sbcl-cl-ana.table-viewing)
9177        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
9178        ("libffi" ,libffi)))
9179     (native-inputs
9180      `(("cl-fad" ,sbcl-cl-fad)))
9181     (arguments
9182      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9183        ((#:asd-file _ "") "cl-ana.asd")
9184        ((#:asd-system-name _ #f) "cl-ana")))))
9185
9186 (define-public cl-ana
9187   (sbcl-package->cl-source-package sbcl-cl-ana))
9188
9189 (define-public sbcl-archive
9190   (let ((commit "631271c091ed02994bec3980cb288a2cf32c7cdc")
9191         (revision "1"))
9192     (package
9193       (name "sbcl-archive")
9194       (version (git-version "0.9" revision commit))
9195       (source (origin
9196                 (method git-fetch)
9197                 (uri (git-reference
9198                       (url "https://github.com/sharplispers/archive.git")
9199                       (commit commit)))
9200                 (file-name (git-file-name name version))
9201                 (sha256
9202                  (base32
9203                   "0pvsc9fmybx7rxd0kmzq4shi6hszdpwdc1sfy7jwyfxf8n3hnv4p"))))
9204       (build-system asdf-build-system/sbcl)
9205       (inputs
9206        `(("cl-fad" ,sbcl-cl-fad)
9207          ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
9208       (synopsis "Common Lisp library for tar and cpio archives")
9209       (description
9210        "This is a Common Lisp library to read and write disk-based file
9211 archives such as those generated by the tar and cpio programs on Unix.")
9212       (home-page "https://github.com/sharplispers/archive")
9213       (license license:bsd-3))))
9214
9215 (define-public cl-archive
9216   (sbcl-package->cl-source-package sbcl-archive))
9217
9218 (define-public ecl-archive
9219   (sbcl-package->ecl-package sbcl-archive))
9220
9221 (define-public sbcl-misc-extensions
9222   (let ((commit "101c05112bf2f1e1bbf527396822d2f50ca6327a")
9223         (revision "1"))
9224     (package
9225       (name "sbcl-misc-extensions")
9226       (version (git-version "3.3" revision commit))
9227       (source
9228        (origin
9229          (method git-fetch)
9230          (uri (git-reference
9231                (url "https://gitlab.common-lisp.net/misc-extensions/devel.git")
9232                (commit commit)))
9233          (file-name (git-file-name name version))
9234          (sha256
9235           (base32
9236            "0gz5f4p70qzilnxsnf5lih2n9m4wjcw8hlw4w8mpn9jyhyppyyv0"))))
9237       (build-system asdf-build-system/sbcl)
9238       (synopsis "Collection of small macros and extensions for Common Lisp")
9239       (description
9240        "This project is intended as a catchall for small, general-purpose
9241 extensions to Common Lisp.  It contains:
9242
9243 @itemize
9244 @item @code{new-let}, a macro that combines and generalizes @code{let},
9245 @code{let*} and @code{multiple-value-bind},
9246 @item @code{gmap}, an iteration macro that generalizes @code{map}.
9247 @end itemize\n")
9248       (home-page "https://common-lisp.net/project/misc-extensions/")
9249       (license license:public-domain))))
9250
9251 (define-public cl-misc-extensions
9252   (sbcl-package->cl-source-package sbcl-misc-extensions))
9253
9254 (define-public ecl-misc-extensions
9255   (sbcl-package->ecl-package sbcl-misc-extensions))
9256
9257 (define-public sbcl-mt19937
9258   (package
9259     (name "sbcl-mt19937")
9260     (version "1.1")
9261     (source
9262      (origin
9263        (method url-fetch)
9264        (uri (string-append "https://common-lisp.net/project/asdf-packaging/"
9265                            "mt19937-latest.tar.gz"))
9266        (sha256
9267         (base32
9268          "1iw636b0iw5ygkv02y8i41lh7xj0acglv0hg5agryn0zzi2nf1xv"))))
9269     (build-system asdf-build-system/sbcl)
9270     (synopsis "Mersenne Twister pseudo-random number generator")
9271     (description
9272      "MT19937 is a portable Mersenne Twister pseudo-random number generator
9273 for Common Lisp.")
9274     (home-page "https://www.cliki.net/mt19937")
9275     (license license:public-domain)))
9276
9277 (define-public cl-mt19937
9278   (sbcl-package->cl-source-package sbcl-mt19937))
9279
9280 (define-public ecl-mt19937
9281   (sbcl-package->ecl-package sbcl-mt19937))
9282
9283 (define-public sbcl-fset
9284   (let ((commit "6d2f9ded8934d2b42f2571a0ba5bda091037d852")
9285         (revision "1"))
9286     (package
9287       (name "sbcl-fset")
9288       (version (git-version "1.3.2" revision commit))
9289       (source
9290        (origin
9291          (method git-fetch)
9292          (uri (git-reference
9293                (url "https://github.com/slburson/fset")
9294                (commit commit)))
9295          (file-name (git-file-name name version))
9296          (sha256
9297           (base32
9298            "127acblwrbqicx47h6sgvknz1cqyfn8p4xkhkn1m7hxh8w5gk1zy"))
9299          (snippet '(begin
9300                      ;; Remove obsolete copy of system definition.
9301                      (delete-file "Code/fset.asd")
9302                      #t))))
9303       (build-system asdf-build-system/sbcl)
9304       (inputs
9305        `(("misc-extensions" ,sbcl-misc-extensions)
9306          ("mt19937" ,sbcl-mt19937)
9307          ("named-readtables" ,sbcl-named-readtables)))
9308       (synopsis "Functional set-theoretic collections library")
9309       (description
9310        "FSet is a functional set-theoretic collections library for Common Lisp.
9311 Functional means that all update operations return a new collection rather than
9312 modifying an existing one in place.  Set-theoretic means that collections may
9313 be nested arbitrarily with no additional programmer effort; for instance, sets
9314 may contain sets, maps may be keyed by sets, etc.")
9315       (home-page "https://common-lisp.net/project/fset/Site/index.html")
9316       (license license:llgpl))))
9317
9318 (define-public cl-fset
9319   (sbcl-package->cl-source-package sbcl-fset))
9320
9321 (define-public sbcl-cl-cont
9322   (let ((commit "fc1fa7e6eb64894fdca13e688e6015fad5290d2a")
9323         (revision "1"))
9324     (package
9325       (name "sbcl-cl-cont")
9326       (version (git-version "0.3.8" revision commit))
9327       (source
9328        (origin
9329          (method git-fetch)
9330          (uri (git-reference
9331                (url "https://gitlab.common-lisp.net/cl-cont/cl-cont.git")
9332                (commit commit)))
9333          (file-name (git-file-name name version))
9334          (sha256
9335           (base32
9336            "1zf8zvb0i6jm3hhfks4w74hibm6avgc6f9s1qwgjrn2bcik8lrvz"))))
9337       (build-system asdf-build-system/sbcl)
9338       (inputs
9339        `(("alexandria" ,sbcl-alexandria)
9340          ("closer-mop" ,sbcl-closer-mop)))
9341       (native-inputs
9342        `(("rt" ,sbcl-rt)))
9343       (synopsis "Delimited continuations for Common Lisp")
9344       (description
9345        "This is a library that implements delimited continuations by
9346 transforming Common Lisp code to continuation passing style.")
9347       (home-page "https://common-lisp.net/project/cl-cont/")
9348       (license license:llgpl))))
9349
9350 (define-public cl-cont
9351   (sbcl-package->cl-source-package sbcl-cl-cont))
9352
9353 (define-public ecl-cl-cont
9354   (sbcl-package->ecl-package sbcl-cl-cont))
9355
9356 (define-public sbcl-cl-coroutine
9357   (let ((commit "de098f8d5debd8b14ef6864b5bdcbbf5ddbcfd72")
9358         (revision "1"))
9359     (package
9360       (name "sbcl-cl-coroutine")
9361       (version (git-version "0.1" revision commit))
9362       (source
9363        (origin
9364          (method git-fetch)
9365          (uri (git-reference
9366                (url "https://github.com/takagi/cl-coroutine.git")
9367                (commit commit)))
9368          (file-name (git-file-name name version))
9369          (sha256
9370           (base32
9371            "1cqdhdjxffgfs116l1swjlsmcbly0xgcgrckvaajd566idj9yj4l"))))
9372       (build-system asdf-build-system/sbcl)
9373       (inputs
9374        `(("alexandria" ,sbcl-alexandria)
9375          ("cl-cont" ,sbcl-cl-cont)))
9376       (native-inputs
9377        `(("prove" ,sbcl-prove)))
9378       (arguments
9379        `(;; TODO: Fix the tests. They fail with:
9380          ;; "Component CL-COROUTINE-ASD::CL-COROUTINE-TEST not found"
9381          #:tests? #f
9382          #:phases
9383          (modify-phases %standard-phases
9384            (add-after 'unpack 'fix-tests
9385              (lambda _
9386                (substitute* "cl-coroutine-test.asd"
9387                  (("cl-test-more")
9388                   "prove"))
9389                #t)))))
9390       (synopsis "Coroutine library for Common Lisp")
9391       (description
9392        "This is a coroutine library for Common Lisp implemented using the
9393 continuations of the @code{cl-cont} library.")
9394       (home-page "https://github.com/takagi/cl-coroutine")
9395       (license license:llgpl))))
9396
9397 (define-public cl-coroutine
9398   (sbcl-package->cl-source-package sbcl-cl-coroutine))
9399
9400 (define-public ecl-cl-coroutine
9401   (sbcl-package->ecl-package sbcl-cl-coroutine))
9402
9403 (define-public sbcl-vom
9404   (let ((commit "1aeafeb5b74c53741b79497e0ef4acf85c92ff24")
9405         (revision "1"))
9406     (package
9407       (name "sbcl-vom")
9408       (version (git-version "0.1.4" revision commit))
9409       (source
9410        (origin
9411          (method git-fetch)
9412          (uri (git-reference
9413                (url "https://github.com/orthecreedence/vom.git")
9414                (commit commit)))
9415          (file-name (git-file-name name version))
9416          (sha256
9417           (base32
9418            "0536kppj76ax4lrxhv42npkfjsmx45km2g439vf9jmw3apinz9cy"))))
9419       (build-system asdf-build-system/sbcl)
9420       (synopsis "Tiny logging utility for Common Lisp")
9421       (description
9422        "Vom is a logging library for Common Lisp.  It's goal is to be useful
9423 and small.  It does not provide a lot of features as other loggers do, but
9424 has a small codebase that's easy to understand and use.")
9425       (home-page "https://github.com/orthecreedence/vom")
9426       (license license:expat))))
9427
9428 (define-public cl-vom
9429   (sbcl-package->cl-source-package sbcl-vom))
9430
9431 (define-public ecl-vom
9432   (sbcl-package->ecl-package sbcl-vom))
9433
9434 (define-public sbcl-cl-libuv
9435   (let ((commit "32100c023c518038d0670a103eaa4d50dd785d29")
9436         (revision "1"))
9437     (package
9438       (name "sbcl-cl-libuv")
9439       (version (git-version "0.1.6" revision commit))
9440       (source
9441        (origin
9442          (method git-fetch)
9443          (uri (git-reference
9444                (url "https://github.com/orthecreedence/cl-libuv.git")
9445                (commit commit)))
9446          (file-name (git-file-name name version))
9447          (sha256
9448           (base32
9449            "1kwix4si8a8hza34ab2k7whrh7z0yrmx39v2wc3qblv9m244jkh1"))))
9450       (build-system asdf-build-system/sbcl)
9451       (inputs
9452        `(("alexandria" ,sbcl-alexandria)
9453          ("cffi" ,sbcl-cffi)
9454          ("cffi-grovel" ,sbcl-cffi-grovel)
9455          ("libuv" ,libuv)))
9456       (arguments
9457        `(#:phases
9458          (modify-phases %standard-phases
9459            (add-after 'unpack 'fix-paths
9460              (lambda* (#:key inputs #:allow-other-keys)
9461                (substitute* "lib.lisp"
9462                  (("/usr/lib/libuv.so")
9463                   (string-append (assoc-ref inputs "libuv")
9464                                  "/lib/libuv.so")))
9465                #t))
9466            (add-after 'fix-paths 'fix-system-definition
9467              (lambda _
9468                (substitute* "cl-libuv.asd"
9469                  (("#:cffi #:alexandria")
9470                   "#:cffi #:cffi-grovel #:alexandria"))
9471                #t)))))
9472       (synopsis "Common Lisp bindings to libuv")
9473       (description
9474        "This library provides low-level libuv bindings for Common Lisp.")
9475       (home-page "https://github.com/orthecreedence/cl-libuv")
9476       (license license:expat))))
9477
9478 (define-public cl-libuv
9479   (sbcl-package->cl-source-package sbcl-cl-libuv))
9480
9481 (define-public ecl-cl-libuv
9482   (sbcl-package->ecl-package sbcl-cl-libuv))
9483
9484 (define-public sbcl-cl-async-base
9485   (let ((commit "f6423e44404a44434d803605e0d2e17199158e28")
9486         (revision "1"))
9487     (package
9488       (name "sbcl-cl-async-base")
9489       (version (git-version "0.6.1" revision commit))
9490       (source
9491        (origin
9492          (method git-fetch)
9493          (uri (git-reference
9494                (url "https://github.com/orthecreedence/cl-async.git")
9495                (commit commit)))
9496          (file-name (git-file-name name version))
9497          (sha256
9498           (base32
9499            "11xi9dxb8mjgwzrkj88i0xkgk26z9w9ddxzbv6xsvfc1d4x5cf4x"))))
9500       (build-system asdf-build-system/sbcl)
9501       (inputs
9502        `(("bordeaux-threads" ,sbcl-bordeaux-threads)
9503          ("cffi" ,sbcl-cffi)
9504          ("cl-libuv" ,sbcl-cl-libuv)))
9505       (arguments
9506        `(#:asd-file "cl-async.asd"))
9507       (synopsis "Base system for cl-async")
9508       (description
9509        "Cl-async is a library for general purpose, non-blocking programming in
9510 Common Lisp.  It uses the libuv library as backend.")
9511       (home-page "https://orthecreedence.github.io/cl-async/")
9512       (license license:expat))))
9513
9514 (define-public cl-async-base
9515   (sbcl-package->cl-source-package sbcl-cl-async-base))
9516
9517 (define-public ecl-cl-async-base
9518   (sbcl-package->ecl-package sbcl-cl-async-base))
9519
9520 (define-public sbcl-cl-async-util
9521   (package
9522     (inherit sbcl-cl-async-base)
9523     (name "sbcl-cl-async-util")
9524     (inputs
9525      `(("bordeaux-threads" ,sbcl-bordeaux-threads)
9526        ("cffi" ,sbcl-cffi)
9527        ("cl-async-base" ,sbcl-cl-async-base)
9528        ("cl-libuv" ,sbcl-cl-libuv)
9529        ("cl-ppcre" ,sbcl-cl-ppcre)
9530        ("fast-io" ,sbcl-fast-io)
9531        ("vom" ,sbcl-vom)))
9532     (synopsis "Internal utilities for cl-async")))
9533
9534 (define-public cl-async-util
9535   (sbcl-package->cl-source-package sbcl-cl-async-util))
9536
9537 (define-public ecl-cl-async-util
9538   (sbcl-package->ecl-package sbcl-cl-async-util))
9539
9540 (define-public sbcl-cl-async
9541   (package
9542     (inherit sbcl-cl-async-base)
9543     (name "sbcl-cl-async")
9544     (inputs
9545      `(("babel" ,sbcl-babel)
9546        ("cffi" ,sbcl-cffi)
9547        ("cl-async-base" ,sbcl-cl-async-base)
9548        ("cl-async-util" ,sbcl-cl-async-util)
9549        ("cl-libuv" ,sbcl-cl-libuv)
9550        ("cl-ppcre" ,sbcl-cl-ppcre)
9551        ("static-vectors" ,sbcl-static-vectors)
9552        ("trivial-features" ,sbcl-trivial-features)
9553        ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
9554     (synopsis "Asynchronous operations for Common Lisp")))
9555
9556 (define-public cl-async
9557   (sbcl-package->cl-source-package sbcl-cl-async))
9558
9559 (define-public ecl-cl-async
9560   (sbcl-package->ecl-package sbcl-cl-async))
9561
9562 (define-public sbcl-cl-async-repl
9563   (package
9564     (inherit sbcl-cl-async-base)
9565     (name "sbcl-cl-async-repl")
9566     (inputs
9567      `(("bordeaux-threads" ,sbcl-bordeaux-threads)
9568        ("cl-async" ,sbcl-cl-async)))
9569     (arguments
9570      (substitute-keyword-arguments (package-arguments sbcl-cl-async-base)
9571        ((#:asd-file _ "") "cl-async-repl.asd")))
9572     (synopsis "REPL integration for cl-async")))
9573
9574 (define-public cl-async-repl
9575   (sbcl-package->cl-source-package sbcl-cl-async-repl))
9576
9577 (define-public ecl-cl-async-repl
9578   (sbcl-package->ecl-package sbcl-cl-async-repl))
9579
9580 (define-public sbcl-cl-async-ssl
9581   (package
9582     (inherit sbcl-cl-async-base)
9583     (name "sbcl-cl-async-ssl")
9584     (inputs
9585      `(("cffi" ,sbcl-cffi)
9586        ("cl-async" ,sbcl-cl-async)
9587        ("openssl" ,openssl)
9588        ("vom" ,sbcl-vom)))
9589     (arguments
9590      (substitute-keyword-arguments (package-arguments sbcl-cl-async-base)
9591        ((#:asd-file _ "") "cl-async-ssl.asd")
9592        ((#:phases phases '%standard-phases)
9593         `(modify-phases ,phases
9594            (add-after 'unpack 'fix-paths
9595              (lambda* (#:key inputs #:allow-other-keys)
9596                (substitute* "src/ssl/package.lisp"
9597                  (("libcrypto\\.so")
9598                   (string-append (assoc-ref inputs "openssl")
9599                                  "/lib/libcrypto.so"))
9600                  (("libssl\\.so")
9601                   (string-append (assoc-ref inputs "openssl")
9602                                  "/lib/libssl.so")))
9603                #t))))))
9604     (synopsis "SSL wrapper around cl-async socket implementation")))
9605
9606 (define-public cl-async-ssl
9607   (sbcl-package->cl-source-package sbcl-cl-async-ssl))
9608
9609 (define-public ecl-cl-async-ssl
9610   (sbcl-package->ecl-package sbcl-cl-async-ssl))
9611
9612 (define-public sbcl-blackbird
9613   (let ((commit "d361f81c1411dec07f6c2dcb11c78f7aea9aaca8")
9614         (revision "1"))
9615     (package
9616       (name "sbcl-blackbird")
9617       (version (git-version "0.5.2" revision commit))
9618       (source
9619        (origin
9620          (method git-fetch)
9621          (uri (git-reference
9622                (url "https://github.com/orthecreedence/blackbird.git")
9623                (commit commit)))
9624          (file-name (git-file-name name version))
9625          (sha256
9626           (base32
9627            "0xfds5yaya64arzr7w1x38karyz11swzbhxx1afldpradj9dh19c"))))
9628       (build-system asdf-build-system/sbcl)
9629       (inputs
9630        `(("vom" ,sbcl-vom)))
9631       (native-inputs
9632        `(("cl-async" ,sbcl-cl-async)
9633          ("fiveam" ,sbcl-fiveam)))
9634       (synopsis "Promise implementation for Common Lisp")
9635       (description
9636        "This is a standalone promise implementation for Common Lisp.  It is
9637 the successor to the now-deprecated cl-async-future project.")
9638       (home-page "http://orthecreedence.github.io/blackbird/")
9639       (license license:expat))))
9640
9641 (define-public cl-blackbird
9642   (sbcl-package->cl-source-package sbcl-blackbird))
9643
9644 (define-public ecl-blackbird
9645   (sbcl-package->ecl-package sbcl-blackbird))
9646
9647 (define-public sbcl-cl-async-future
9648   (let ((commit "ee36c22a69a9516407458d2ed8b475f1fc473959")
9649         (revision "1"))
9650     (package
9651       (name "sbcl-cl-async-future")
9652       (version (git-version "0.4.4.1" revision commit))
9653       (source
9654        (origin
9655          (method git-fetch)
9656          (uri (git-reference
9657                (url "https://github.com/orthecreedence/cl-async-future.git")
9658                (commit commit)))
9659          (file-name (git-file-name name version))
9660          (sha256
9661           (base32
9662            "0z0sc7qlzzxk99f4l26zp6rai9kv0kj0f599sxai5s44p17zbbvh"))))
9663       (build-system asdf-build-system/sbcl)
9664       (inputs
9665        `(("blackbird" ,sbcl-blackbird)))
9666       (native-inputs
9667        `(("cl-async" ,sbcl-cl-async)
9668          ("eos" ,sbcl-eos)))
9669       (synopsis "Futures implementation for Common Lisp")
9670       (description
9671        "This is futures implementation for Common Lisp.  It plugs in nicely
9672 to cl-async.")
9673       (home-page "http://orthecreedence.github.io/cl-async/future")
9674       (license license:expat))))
9675
9676 (define-public cl-async-future
9677   (sbcl-package->cl-source-package sbcl-cl-async-future))
9678
9679 (define-public ecl-cl-async-future
9680   (sbcl-package->ecl-package sbcl-cl-async-future))
9681
9682 (define-public sbcl-green-threads
9683   (let ((commit "fff5ebecb441a37e5c511773716aafd84a3c5840")
9684         (revision "1"))
9685     (package
9686       (name "sbcl-green-threads")
9687       (version (git-version "0.3" revision commit))
9688       (source
9689        (origin
9690          (method git-fetch)
9691          (uri (git-reference
9692                (url "https://github.com/thezerobit/green-threads.git")
9693                (commit commit)))
9694          (file-name (git-file-name name version))
9695          (sha256
9696           (base32
9697            "1czw7nr0dwfps76h8hjvglk1wdh53yqbfbvv30whwbgqx33iippz"))))
9698       (build-system asdf-build-system/sbcl)
9699       (inputs
9700        `(("cl-async-future" ,sbcl-cl-async-future)
9701          ("cl-cont" ,sbcl-cl-cont)))
9702       (native-inputs
9703        `(("prove" ,sbcl-prove)))
9704       (arguments
9705        `(;; TODO: Fix the tests. They fail with:
9706          ;; "The function BLACKBIRD::PROMISE-VALUES is undefined"
9707          #:tests? #f
9708          #:phases
9709          (modify-phases %standard-phases
9710            (add-after 'unpack 'fix-tests
9711              (lambda _
9712                (substitute* "green-threads-test.asd"
9713                  (("cl-test-more")
9714                   "prove"))
9715                #t)))))
9716       (synopsis "Cooperative multitasking library for Common Lisp")
9717       (description
9718        "This library allows for cooperative multitasking with help of cl-cont
9719 for continuations.  It tries to mimic the API of bordeaux-threads as much as
9720 possible.")
9721       (home-page "https://github.com/thezerobit/green-threads")
9722       (license license:bsd-3))))
9723
9724 (define-public cl-green-threads
9725   (sbcl-package->cl-source-package sbcl-green-threads))
9726
9727 (define-public ecl-green-threads
9728   (sbcl-package->ecl-package sbcl-green-threads))
9729
9730 (define-public sbcl-cl-base32
9731   (let ((commit "8cdee06fab397f7b0a19583b57e7f0c98405be85")
9732         (revision "1"))
9733     (package
9734       (name "sbcl-cl-base32")
9735       (version (git-version "0.1" revision commit))
9736       (source
9737        (origin
9738          (method git-fetch)
9739          (uri (git-reference
9740                (url "https://github.com/hargettp/cl-base32.git")
9741                (commit commit)))
9742          (file-name (git-file-name name version))
9743          (sha256
9744           (base32 "17jrng8jb05d64ggyd11hp308c2fl5drvf9g175blgrkkl8l4mf8"))))
9745       (build-system asdf-build-system/sbcl)
9746       (native-inputs
9747        `(("lisp-unit" ,sbcl-lisp-unit)))
9748       (synopsis "Common Lisp library for base32 encoding and decoding")
9749       (description
9750        "This package provides functions for base32 encoding and decoding as
9751 defined in RFC4648.")
9752       (home-page "https://github.com/hargettp/cl-base32")
9753       (license license:expat))))
9754
9755 (define-public cl-base32
9756   (sbcl-package->cl-source-package sbcl-cl-base32))
9757
9758 (define-public ecl-cl-base32
9759   (sbcl-package->ecl-package sbcl-cl-base32))
9760
9761 (define-public sbcl-cl-z85
9762   (let ((commit "85b3951a9cfa2603acb6aee15567684f9a108098")
9763         (revision "1"))
9764     (package
9765       (name "sbcl-cl-z85")
9766       (version (git-version "1.0" revision commit))
9767       (source
9768        (origin
9769          (method git-fetch)
9770          (uri (git-reference
9771                (url "https://github.com/glv2/cl-z85.git")
9772                (commit commit)))
9773          (file-name (git-file-name name version))
9774          (sha256
9775           (base32 "0r27pidjaxbm7k1rr90nnajwl5xm2kp65g1fv0fva17lzy45z1mp"))))
9776       (build-system asdf-build-system/sbcl)
9777       (native-inputs
9778        `(("cl-octet-streams" ,sbcl-cl-octet-streams)
9779          ("fiveam" ,sbcl-fiveam)))
9780       (synopsis "Common Lisp library for Z85 encoding and decoding")
9781       (description
9782        "This package provides functions to encode or decode byte vectors or
9783 byte streams using the Z85 format, which is a base-85 encoding used by
9784 ZeroMQ.")
9785       (home-page "https://github.com/glv2/cl-z85")
9786       (license license:gpl3+))))
9787
9788 (define-public cl-z85
9789   (sbcl-package->cl-source-package sbcl-cl-z85))
9790
9791 (define-public ecl-cl-z85
9792   (sbcl-package->ecl-package sbcl-cl-z85))
9793
9794 (define-public sbcl-ltk
9795   (package
9796     (name "sbcl-ltk")
9797     (version "0.992")
9798     (source
9799      (origin
9800        (method git-fetch)
9801        (uri (git-reference
9802              (url "https://github.com/herth/ltk.git")
9803              (commit version)))
9804        (file-name (git-file-name name version))
9805        (sha256
9806         (base32 "13l2q4mskzilya9xh5wy2xvy30lwn104bd8wrq6ifds56r82iy3x"))))
9807     (build-system asdf-build-system/sbcl)
9808     (inputs
9809      `(("imagemagick" ,imagemagick)
9810        ("tk" ,tk)))
9811     (arguments
9812      `(#:asd-file "ltk/ltk.asd"
9813        #:tests? #f
9814        #:phases (modify-phases %standard-phases
9815                   (add-after 'unpack 'fix-paths
9816                     (lambda* (#:key inputs #:allow-other-keys)
9817                       (substitute* "ltk/ltk.lisp"
9818                         (("#-freebsd \"wish\"")
9819                          (string-append "#-freebsd \""
9820                                         (assoc-ref inputs "tk")
9821                                         "/bin/wish\""))
9822                         (("do-execute \"convert\"")
9823                          (string-append "do-execute \""
9824                                         (assoc-ref inputs "imagemagick")
9825                                         "/bin/convert\"")))
9826                       #t)))))
9827     (synopsis "Common Lisp bindings for the Tk GUI toolkit")
9828     (description
9829      "LTK is a Common Lisp binding for the Tk graphics toolkit.  It is written
9830 in pure Common Lisp and does not require any Tk knowledge for its usage.")
9831     (home-page "http://www.peter-herth.de/ltk/")
9832     (license license:llgpl)))
9833
9834 (define-public cl-ltk
9835   (sbcl-package->cl-source-package sbcl-ltk))
9836
9837 (define-public ecl-ltk
9838   (sbcl-package->ecl-package sbcl-ltk))
9839
9840 (define-public sbcl-ltk-mw
9841   (package
9842     (inherit sbcl-ltk)
9843     (name "sbcl-ltk-mw")
9844     (inputs
9845      `(("ltk" ,sbcl-ltk)))
9846     (arguments
9847      (substitute-keyword-arguments (package-arguments sbcl-ltk)
9848        ((#:asd-file _) "ltk/ltk-mw.asd")
9849        ((#:phases _) '%standard-phases)))
9850     (synopsis "Extra widgets for LTK")
9851     (description
9852      "This is a collection of higher-level widgets built on top of LTK.")))
9853
9854 (define-public cl-ltk-mw
9855   (sbcl-package->cl-source-package sbcl-ltk-mw))
9856
9857 (define-public ecl-ltk-mw
9858   (sbcl-package->ecl-package sbcl-ltk-mw))
9859
9860 (define-public sbcl-ltk-remote
9861   (package
9862     (inherit sbcl-ltk)
9863     (name "sbcl-ltk-remote")
9864     (inputs
9865      `(("ltk" ,sbcl-ltk)))
9866     (arguments
9867      (substitute-keyword-arguments (package-arguments sbcl-ltk)
9868        ((#:asd-file _) "ltk/ltk-remote.asd")
9869        ((#:phases _) '%standard-phases)))
9870     (synopsis "Remote GUI support for LTK")
9871     (description
9872      "This LTK extension allows the GUI to be displayed on a computer different
9873 from the one running the Lisp program by using a TCP connection.")))
9874
9875 (define-public cl-ltk-remote
9876   (sbcl-package->cl-source-package sbcl-ltk-remote))
9877
9878 (define-public sbcl-cl-lex
9879   (let ((commit "f2dbbe25ef553005fb402d9a6203180c3fa1093b")
9880         (revision "1"))
9881     (package
9882       (name "sbcl-cl-lex")
9883       (version (git-version "1.1.3" revision commit))
9884       (source
9885        (origin
9886          (method git-fetch)
9887          (uri (git-reference
9888                (url "https://github.com/djr7C4/cl-lex.git")
9889                (commit commit)))
9890          (file-name (git-file-name name version))
9891          (sha256
9892           (base32 "1kg50f76bfpfxcv4dfivq1n9a0xlsra2ajb0vd68lxwgbidgyc2y"))))
9893       (build-system asdf-build-system/sbcl)
9894       (inputs
9895        `(("cl-ppcre" ,sbcl-cl-ppcre)))
9896       (synopsis "Common Lisp macros for generating lexical analyzers")
9897       (description
9898        "This is a Common Lisp library providing a set of macros for generating
9899 lexical analyzers automatically.  The lexers generated using @code{cl-lex} can
9900 be used with @code{cl-yacc}.")
9901       (home-page "https://github.com/djr7C4/cl-lex")
9902       (license license:gpl3))))
9903
9904 (define-public cl-lex
9905   (sbcl-package->cl-source-package sbcl-cl-lex))
9906
9907 (define-public ecl-cl-lex
9908   (sbcl-package->ecl-package sbcl-cl-lex))
9909
9910 (define-public sbcl-clunit2
9911   (let ((commit "5e28343734eb9b7aee39306a614af92c1062d50b")
9912         (revision "1"))
9913     (package
9914       (name "sbcl-clunit2")
9915       (version (git-version "0.2.4" revision commit))
9916       (source
9917        (origin
9918          (method git-fetch)
9919          (uri (git-reference
9920                (url "https://notabug.org/cage/clunit2.git")
9921                (commit commit)))
9922          (file-name (git-file-name name version))
9923          (sha256
9924           (base32 "1ngiapfki6nm8a555mzhb5p7ch79i3w665za5bmb5j7q34fy80vw"))))
9925       (build-system asdf-build-system/sbcl)
9926       (synopsis "Unit testing framework for Common Lisp")
9927       (description
9928        "CLUnit is a Common Lisp unit testing framework.  It is designed to be
9929 easy to use so that you can quickly start testing.")
9930       (home-page "https://notabug.org/cage/clunit2")
9931       (license license:expat))))
9932
9933 (define-public cl-clunit2
9934   (sbcl-package->cl-source-package sbcl-clunit2))
9935
9936 (define-public ecl-clunit2
9937   (sbcl-package->ecl-package sbcl-clunit2))
9938
9939 (define-public sbcl-cl-colors2
9940   (let ((commit "795aedee593b095fecde574bd999b520dd03ed24")
9941         (revision "1"))
9942     (package
9943       (name "sbcl-cl-colors2")
9944       (version (git-version "0.2.1" revision commit))
9945       (source
9946        (origin
9947          (method git-fetch)
9948          (uri (git-reference
9949                (url "https://notabug.org/cage/cl-colors2.git")
9950                (commit commit)))
9951          (file-name (git-file-name name version))
9952          (sha256
9953           (base32 "0hlyf4h5chkjdp9armla5w4kw5acikk159sym7y8c4jbjp9x47ih"))))
9954       (build-system asdf-build-system/sbcl)
9955       (native-inputs
9956        `(("clunit2" ,sbcl-clunit2)))
9957       (inputs
9958        `(("alexandria" ,sbcl-alexandria)
9959          ("cl-ppcre" ,sbcl-cl-ppcre)))
9960       (synopsis "Color library for Common Lisp")
9961       (description
9962        "This is a very simple color library for Common Lisp, providing:
9963
9964 @itemize
9965 @item Types for representing colors in HSV and RGB spaces.
9966 @item Simple conversion functions between the above types (and also
9967 hexadecimal representation for RGB).
9968 @item Some predefined colors (currently X11 color names -- of course
9969 the library does not depend on X11).
9970 @end itemize\n")
9971       (home-page "https://notabug.org/cage/cl-colors2")
9972       (license license:boost1.0))))
9973
9974 (define-public cl-colors2
9975   (sbcl-package->cl-source-package sbcl-cl-colors2))
9976
9977 (define-public ecl-cl-colors2
9978   (sbcl-package->ecl-package sbcl-cl-colors2))
9979
9980 (define-public sbcl-cl-jpeg
9981   (let ((commit "ec557038128df6895fbfb743bfe8faf8ec2534af")
9982         (revision "1"))
9983     (package
9984       (name "sbcl-cl-jpeg")
9985       (version (git-version "2.8" revision commit))
9986       (source
9987        (origin
9988          (method git-fetch)
9989          (uri (git-reference
9990                (url "https://github.com/sharplispers/cl-jpeg.git")
9991                (commit commit)))
9992          (file-name (git-file-name name version))
9993          (sha256
9994           (base32 "1bkkiqz8fqldlj1wbmrccjsvxcwj98h6s4b6gslr3cg2wmdv5xmy"))))
9995       (build-system asdf-build-system/sbcl)
9996       (synopsis "JPEG image library for Common Lisp")
9997       (description
9998        "This is a baseline JPEG codec written in Common Lisp.  It can be used
9999 for reading and writing JPEG image files.")
10000       (home-page "https://github.com/sharplispers/cl-jpeg")
10001       (license license:bsd-3))))
10002
10003 (define-public cl-jpeg
10004   (sbcl-package->cl-source-package sbcl-cl-jpeg))
10005
10006 (define-public ecl-cl-jpeg
10007   (sbcl-package->ecl-package sbcl-cl-jpeg))
10008
10009 (define-public sbcl-nodgui
10010   (let ((commit "bc59ed9b787dfc9e68ae3bd7f7e8507c5c619212")
10011         (revision "1"))
10012     (package
10013       (name "sbcl-nodgui")
10014       (version (git-version "0.0.5" revision commit))
10015       (source
10016        (origin
10017          (method git-fetch)
10018          (uri (git-reference
10019                (url "https://notabug.org/cage/nodgui.git")
10020                (commit commit)))
10021          (file-name (git-file-name name version))
10022          (sha256
10023           (base32 "0xx0dk54d882i598ydnwmy7mnfk0b7vib3ddsgpqxhjck1rwq8l8"))))
10024       (build-system asdf-build-system/sbcl)
10025       (inputs
10026        `(("alexandria" ,sbcl-alexandria)
10027          ("bordeaux-threads" ,sbcl-bordeaux-threads)
10028          ("cl-colors2" ,sbcl-cl-colors2)
10029          ("cl-jpeg" ,sbcl-cl-jpeg)
10030          ("cl-lex" ,sbcl-cl-lex)
10031          ("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)
10032          ("cl-unicode" ,sbcl-cl-unicode)
10033          ("cl-yacc" ,sbcl-cl-yacc)
10034          ("clunit2" ,sbcl-clunit2)
10035          ("named-readtables" ,sbcl-named-readtables)
10036          ("parse-number" ,sbcl-parse-number)
10037          ("tk" ,tk)))
10038       (arguments
10039        `(#:phases (modify-phases %standard-phases
10040                     (add-after 'unpack 'fix-paths
10041                       (lambda* (#:key inputs #:allow-other-keys)
10042                         (substitute* "src/wish-communication.lisp"
10043                           (("#-freebsd \"wish\"")
10044                            (string-append "#-freebsd \""
10045                                           (assoc-ref inputs "tk")
10046                                           "/bin/wish\"")))
10047                         #t)))))
10048       (synopsis "Common Lisp bindings for the Tk GUI toolkit")
10049       (description
10050        "Nodgui (@emph{No Drama GUI}) is a Common Lisp binding for the Tk GUI
10051 toolkit.  It also provides a few additional widgets more than the standard Tk
10052 ones.")
10053       (home-page "https://www.autistici.org/interzona/nodgui.html")
10054       (license license:llgpl))))
10055
10056 (define-public cl-nodgui
10057   (sbcl-package->cl-source-package sbcl-nodgui))
10058
10059 (define-public ecl-nodgui
10060   (sbcl-package->ecl-package sbcl-nodgui))
10061
10062 (define-public sbcl-salza2
10063   (package
10064     (name "sbcl-salza2")
10065     (version "2.0.9")
10066     (source
10067      (origin
10068        (method git-fetch)
10069        (uri (git-reference
10070              (url "https://github.com/xach/salza2.git")
10071              (commit (string-append "release-" version))))
10072        (file-name (git-file-name name version))
10073        (sha256
10074         (base32 "0p38rj4gq7j5k807php7hrz7l2zyyfshv8i9yms7i8lkgg3433ki"))))
10075     (build-system asdf-build-system/sbcl)
10076     (synopsis "Common Lisp library for zlib, deflate and gzip compression")
10077     (description
10078      "Salza2 is a Common Lisp library for creating compressed data in the zlib,
10079 deflate, or gzip data formats, described in RFC 1950, RFC 1951, and RFC 1952,
10080 respectively.")
10081     (home-page "https://www.xach.com/lisp/salza2/")
10082     (license license:bsd-2)))
10083
10084 (define-public cl-salza2
10085   (sbcl-package->cl-source-package sbcl-salza2))
10086
10087 (define-public ecl-salza2
10088   (sbcl-package->ecl-package sbcl-salza2))
10089
10090 (define-public sbcl-png-read
10091   (let ((commit "ec29f38a689972b9f1373f13bbbcd6b05deada88")
10092         (revision "1"))
10093     (package
10094       (name "sbcl-png-read")
10095       (version (git-version "0.3.1" revision commit))
10096       (source
10097        (origin
10098          (method git-fetch)
10099          (uri (git-reference
10100                (url "https://github.com/Ramarren/png-read.git")
10101                (commit commit)))
10102          (file-name (git-file-name name version))
10103          (sha256
10104           (base32 "0vyczbcwskrygrf1hgrsnk0jil8skmvf1kiaalw5jps4fjrfdkw0"))))
10105       (build-system asdf-build-system/sbcl)
10106       (inputs
10107        `(("babel" ,sbcl-babel)
10108          ("chipz" ,sbcl-chipz)
10109          ("iterate" ,sbcl-iterate)))
10110       (synopsis "PNG decoder for Common Lisp")
10111       (description "This is a Common Lisp library for reading PNG images.")
10112       (home-page "https://github.com/Ramarren/png-read")
10113       (license license:bsd-3))))
10114
10115 (define-public cl-png-read
10116   (sbcl-package->cl-source-package sbcl-png-read))
10117
10118 (define-public ecl-png-read
10119   (sbcl-package->ecl-package sbcl-png-read))
10120
10121 (define-public sbcl-zpng
10122   (package
10123     (name "sbcl-zpng")
10124     (version "1.2.2")
10125     (source
10126      (origin
10127        (method git-fetch)
10128        (uri (git-reference
10129              (url "https://github.com/xach/zpng.git")
10130              (commit (string-append "release-" version))))
10131        (file-name (git-file-name name version))
10132        (sha256
10133         (base32 "0b3ag3jhl3z7kdls3ahdsdxsfhhw5qrizk769984f4wkxhb69rcm"))))
10134     (build-system asdf-build-system/sbcl)
10135     (inputs
10136      `(("salza2" ,sbcl-salza2)))
10137     (synopsis "PNG encoder for Common Lisp")
10138     (description "This is a Common Lisp library for creating PNG images.")
10139     (home-page "https://www.xach.com/lisp/zpng/")
10140     (license license:bsd-2)))
10141
10142 (define-public cl-zpng
10143   (sbcl-package->cl-source-package sbcl-zpng))
10144
10145 (define-public ecl-zpng
10146   (sbcl-package->ecl-package sbcl-zpng))
10147
10148 (define-public sbcl-cl-qrencode
10149   (package
10150     (name "sbcl-cl-qrencode")
10151     (version "0.1.2")
10152     (source
10153      (origin
10154        (method git-fetch)
10155        (uri (git-reference
10156              (url "https://github.com/jnjcc/cl-qrencode.git")
10157              (commit (string-append "v" version))))
10158        (file-name (git-file-name name version))
10159        (sha256
10160         (base32 "1l5k131dchbf6cj8a8xqa731790p01p3qa1kdy2wa9dawy3ymkxr"))))
10161     (build-system asdf-build-system/sbcl)
10162     (native-inputs
10163      `(("lisp-unit" ,sbcl-lisp-unit)))
10164     (inputs
10165      `(("zpng" ,sbcl-zpng)))
10166     (synopsis "QR code encoder for Common Lisp")
10167     (description
10168      "This Common Lisp library provides function to make QR codes and to save
10169 them as PNG files.")
10170     (home-page "https://github.com/jnjcc/cl-qrencode")
10171     (license license:gpl2+)))
10172
10173 (define-public cl-qrencode
10174   (sbcl-package->cl-source-package sbcl-cl-qrencode))
10175
10176 (define-public ecl-cl-qrencode
10177   (sbcl-package->ecl-package sbcl-cl-qrencode))
10178
10179 (define-public sbcl-hdf5-cffi
10180   (let ((commit "5b5c88f191e470e4fe96b462334e3ce0806eed5c")
10181         (revision "1"))
10182     (package
10183       (name "sbcl-hdf5-cffi")
10184       (version (git-version "1.8.18" revision commit))
10185       (source
10186        (origin
10187          (method git-fetch)
10188          (uri (git-reference
10189                (url "https://github.com/hdfgroup/hdf5-cffi.git")
10190                (commit commit)))
10191          (file-name (git-file-name name version))
10192          (sha256
10193           (base32
10194            "0vda3075423xz83qky998lpac5b04dwfv7bwgh9jq8cs5v0zrxjf"))))
10195       (build-system asdf-build-system/sbcl)
10196       (synopsis "Common Lisp bindings for the HDF5 library")
10197       (description
10198        "@code{hdf5-cffi} is a CFFI wrapper for the HDF5 library.")
10199       (home-page "https://github.com/hdfgroup/hdf5-cffi")
10200       (license (license:non-copyleft
10201                 (string-append "https://github.com/HDFGroup/hdf5-cffi/raw/"
10202                                commit
10203                                "/LICENSE")))
10204       (inputs
10205        `(("cffi" ,sbcl-cffi)
10206          ("cffi-grovel" ,sbcl-cffi-grovel)
10207          ("hdf5" ,hdf5-1.10)))
10208       (native-inputs
10209        `(("fiveam" ,sbcl-fiveam)))
10210       (arguments
10211        `(#:asd-system-name "hdf5-cffi"
10212          #:asd-file "hdf5-cffi.asd"
10213          #:test-asd-file "hdf5-cffi.test.asd"
10214          ;; Tests depend on hdf5-cffi.examples.asd in addition to hdf5-cffi.asd,
10215          ;; I don't know if there is a way to tell asdf-build-system to load
10216          ;; an additional system first, so tests are disabled.
10217          #:tests? #f
10218          #:phases
10219          (modify-phases %standard-phases
10220            (add-after 'unpack 'fix-paths
10221              (lambda* (#:key inputs #:allow-other-keys)
10222                (substitute* "src/library.lisp"
10223                  (("libhdf5.so")
10224                   (string-append
10225                    (assoc-ref inputs "hdf5")
10226                    "/lib/libhdf5.so")))))
10227            (add-after 'unpack 'fix-dependencies
10228              (lambda* (#:key inputs #:allow-other-keys)
10229                (substitute* "hdf5-cffi.asd"
10230                  ((":depends-on \\(:cffi\\)")
10231                   ":depends-on (:cffi :cffi-grovel)"))
10232                (substitute* "hdf5-cffi.test.asd"
10233                  ((":depends-on \\(:cffi :hdf5-cffi")
10234                   ":depends-on (:cffi :cffi-grovel :hdf5-cffi"))))))))))
10235
10236 (define-public cl-hdf5-cffi
10237   (sbcl-package->cl-source-package sbcl-hdf5-cffi))
10238
10239 (define-public ecl-hdf5-cffi
10240   (sbcl-package->ecl-package sbcl-hdf5-cffi))
10241
10242 (define-public sbcl-cl-randist
10243   (package
10244     (name "sbcl-cl-randist")
10245     (version "0.4.2")
10246     (source
10247      (origin
10248        (method git-fetch)
10249        (uri (git-reference
10250              (url "https://github.com/lvaruzza/cl-randist.git")
10251              (commit "f088a54b540a7adefab7c04094a6103f9edda3d0")))
10252        (file-name (git-file-name name version))
10253        (sha256
10254         (base32
10255          "0l8hyd6nbxb7f50vyxz3rbbm7kgr1fnadc40jywy4xj5vi5kpj5g"))))
10256     (build-system asdf-build-system/sbcl)
10257     (synopsis "Random distributions for Common Lisp")
10258     (description
10259      "Manual translation from C to Common Lisp of some random number
10260 generation functions from the GSL library.")
10261     (home-page "https://github.com/lvaruzza/cl-randist")
10262     (license license:bsd-2)
10263     (arguments
10264      `(#:asd-system-name "cl-randist"
10265        #:asd-file "cl-randist.asd"
10266        #:tests? #f))))
10267
10268 (define-public cl-randist
10269   (sbcl-package->cl-source-package sbcl-cl-randist))
10270
10271 (define-public ecl-cl-randist
10272   (sbcl-package->ecl-package sbcl-cl-randist))
10273
10274 (define-public sbcl-float-features
10275   (package
10276     (name "sbcl-float-features")
10277     (version "1.0.0")
10278     (source
10279      (origin
10280        (method git-fetch)
10281        (uri (git-reference
10282              (url "https://github.com/Shinmera/float-features.git")
10283              (commit "d3ef60181635b0849aa28cfc238053b7ca4644b0")))
10284        (file-name (git-file-name name version))
10285        (sha256
10286         (base32
10287          "0yj419k7n59x6rh3grwr6frgwwyria2il6f7wxpfazm8cskv4lzr"))))
10288     (build-system asdf-build-system/sbcl)
10289     (synopsis "Common Lisp IEEE float portability library")
10290     (description
10291      "Portability library for IEEE float features that are not
10292 covered by the Common Lisp standard.")
10293     (home-page "https://github.com/Shinmera/float-features")
10294     (license license:zlib)
10295     (inputs
10296      `(("documentation-utils" ,sbcl-documentation-utils)))
10297     (arguments
10298      `(#:asd-system-name "float-features"
10299        #:asd-file "float-features.asd"
10300        #:tests? #f))))
10301
10302 (define-public cl-float-features
10303   (sbcl-package->cl-source-package sbcl-float-features))
10304
10305 (define-public ecl-float-features
10306   (sbcl-package->ecl-package sbcl-float-features))
10307
10308 (define-public sbcl-function-cache
10309   (package
10310     (name "sbcl-function-cache")
10311     (version "1.0.3")
10312     (source
10313      (origin
10314        (method git-fetch)
10315        (uri (git-reference
10316              (url "https://github.com/AccelerationNet/function-cache.git")
10317              (commit "6a5ada401e57da2c8abf046f582029926e61fce8")))
10318        (file-name (git-file-name name version))
10319        (sha256
10320         (base32
10321          "000vmd3f5rx5hs9nvphfric0gkzaadns31c6mxaslpv0k7pkrmc6"))))
10322     (build-system asdf-build-system/sbcl)
10323     (synopsis "Function caching / memoization library for Common Lisp")
10324     (description
10325      "A common lisp library that provides extensible function result
10326 caching based on arguments (an expanded form of memoization).")
10327     (home-page "https://github.com/AccelerationNet/function-cache")
10328     (license
10329      (license:non-copyleft
10330       "https://github.com/AccelerationNet/function-cache/blob/master/README.md"))
10331     (inputs
10332      `(("alexandria" ,sbcl-alexandria)
10333        ("cl-interpol" ,sbcl-cl-interpol)
10334        ("iterate" ,sbcl-iterate)
10335        ("symbol-munger" ,sbcl-symbol-munger)
10336        ("closer-mop" ,sbcl-closer-mop)))
10337     (arguments
10338      `(#:asd-system-name "function-cache"
10339        #:asd-file "function-cache.asd"
10340        #:tests? #f))))
10341
10342 (define-public cl-function-cache
10343   (sbcl-package->cl-source-package sbcl-function-cache))
10344
10345 (define-public ecl-function-cache
10346   (sbcl-package->ecl-package sbcl-function-cache))
10347
10348 (define-public sbcl-type-r
10349   (let ((commit "83c89e38f2f7a7b16f1012777ecaf878cfa6a267")
10350         (revision "1"))
10351     (package
10352       (name "sbcl-type-r")
10353       (version (git-version "0.0.0" revision commit))
10354       (source
10355        (origin
10356          (method git-fetch)
10357          (uri (git-reference
10358                (url "https://github.com/guicho271828/type-r.git")
10359                (commit commit)))
10360          (file-name (git-file-name name version))
10361          (sha256
10362           (base32
10363            "1arsxc2539rg8vbrdirz4xxj1b06mc6g6rqndz7a02g127qvk2sm"))))
10364       (build-system asdf-build-system/sbcl)
10365       (synopsis "Parser interface for Common Lisp built-in compound types")
10366       (description
10367        "Collections of accessor functions and patterns to access
10368 the elements in compound type specifier, e.g. @code{dimensions} in
10369 @code{(array element-type dimensions)}")
10370       (home-page "https://github.com/guicho271828/type-r")
10371       (license license:lgpl3+)
10372       (inputs
10373        `(("trivia" ,sbcl-trivia)
10374          ("alexandria" ,sbcl-alexandria)))
10375       (native-inputs
10376        `(("fiveam" ,sbcl-fiveam)))
10377       (arguments
10378        `(#:asd-system-name "type-r"
10379          #:asd-file "type-r.asd"
10380          #:test-asd-file "type-r.test.asd")))))
10381
10382 (define-public cl-type-r
10383   (sbcl-package->cl-source-package sbcl-type-r))
10384
10385 (define-public sbcl-trivialib-type-unify
10386   (let ((commit "62492ebf04db567dcf435ae84c50b7b8202ecf99")
10387         (revision "1"))
10388     (package
10389       (name "sbcl-trivialib-type-unify")
10390       (version (git-version "0.1" revision commit))
10391       (source
10392        (origin
10393          (method git-fetch)
10394          (uri (git-reference
10395                (url "https://github.com/guicho271828/trivialib.type-unify.git")
10396                (commit commit)))
10397          (file-name (git-file-name name version))
10398          (sha256
10399           (base32
10400            "1bkyfzbwv75p50zp8n1n9rh2r29pw3vgz91gmn2gzzkyq3khj1vh"))))
10401       (build-system asdf-build-system/sbcl)
10402       (synopsis "Common Lisp type unification")
10403       (description
10404        "Unifies a parametrized type specifier against an actual type specifier.
10405 Importantly, it handles complicated array-subtypes and number-related types
10406 correctly.")
10407       (home-page "https://github.com/guicho271828/trivialib.type-unify")
10408       (license license:lgpl3+)
10409       (inputs
10410        `(("alexandria" ,sbcl-alexandria)
10411          ("trivia" ,sbcl-trivia)
10412          ("introspect-environment" ,sbcl-introspect-environment)
10413          ("type-r" ,sbcl-type-r)))
10414       (native-inputs
10415        `(("fiveam" ,sbcl-fiveam)))
10416       (arguments
10417        `(#:asd-system-name "trivialib.type-unify"
10418          #:asd-file "trivialib.type-unify.asd"
10419          #:test-asd-file "trivialib.type-unify.test.asd")))))
10420
10421 (define-public cl-trivialib-type-unify
10422   (sbcl-package->cl-source-package sbcl-trivialib-type-unify))
10423
10424 (define-public sbcl-specialized-function
10425   (let ((commit "b96b6afaf8358bf91cc0703e62a5a4ee20d2b7bc")
10426         (revision "1"))
10427     (package
10428       (name "sbcl-specialized-function")
10429       (version (git-version "0.0.0" revision commit))
10430       (source
10431        (origin
10432          (method git-fetch)
10433          (uri (git-reference
10434                (url "https://github.com/numcl/specialized-function.git")
10435                (commit commit)))
10436          (file-name (git-file-name name version))
10437          (sha256
10438           (base32
10439            "12j45ff0n26578vmfbhb9mfbdchw4wy023k0m2ppgl9s0z4bhjaj"))))
10440       (build-system asdf-build-system/sbcl)
10441       (synopsis "Julia-like dispatch for Common Lisp")
10442       (description
10443        "This library is part of NUMCL.  It provides a macro
10444 @code{SPECIALIZED} that performs a Julia-like dispatch on the arguments,
10445 lazily compiling a type-specific version of the function from the same
10446 code.  The main target of this macro is speed.")
10447       (home-page "https://github.com/numcl/specialized-function")
10448       (license license:lgpl3+)
10449       (inputs
10450        `(("trivia" ,sbcl-trivia)
10451          ("alexandria" ,sbcl-alexandria)
10452          ("iterate" ,sbcl-iterate)
10453          ("lisp-namespace" ,sbcl-lisp-namespace)
10454          ("type-r" ,sbcl-type-r)
10455          ("trivial-cltl2" ,sbcl-trivial-cltl2)))
10456       (native-inputs
10457        `(("fiveam" ,sbcl-fiveam)))
10458       (arguments
10459        `(#:asd-system-name "specialized-function"
10460          #:asd-file "specialized-function.asd"
10461          #:test-asd-file "specialized-function.test.asd")))))
10462
10463 (define-public cl-specialized-function
10464   (sbcl-package->cl-source-package sbcl-specialized-function))
10465
10466 (define-public sbcl-constantfold
10467   (let ((commit "0ff1d97a3fbcb89264f6a2af6ce62b73e7b421f4")
10468         (revision "1"))
10469     (package
10470       (name "sbcl-constantfold")
10471       (version (git-version "0.1" revision commit))
10472       (source
10473        (origin
10474          (method git-fetch)
10475          (uri (git-reference
10476                (url "https://github.com/numcl/constantfold.git")
10477                (commit commit)))
10478          (file-name (git-file-name name version))
10479          (sha256
10480           (base32
10481            "153h0569z6bff1qbad0bdssplwwny75l7ilqwcfqfdvzsxf9jh06"))))
10482       (build-system asdf-build-system/sbcl)
10483       (synopsis "Support library for numcl")
10484       (description
10485        "Support library for numcl.  Registers a function as an
10486 additional form that is considered as a candidate for a constant.")
10487       (home-page "https://github.com/numcl/constantfold")
10488       (license license:lgpl3+)
10489       (inputs
10490        `(("trivia" ,sbcl-trivia)
10491          ("alexandria" ,sbcl-alexandria)
10492          ("iterate" ,sbcl-iterate)
10493          ("lisp-namespace" ,sbcl-lisp-namespace)))
10494       (native-inputs
10495        `(("fiveam" ,sbcl-fiveam)))
10496       (arguments
10497        `(#:asd-system-name "constantfold"
10498          #:asd-file "constantfold.asd"
10499          #:test-asd-file "constantfold.test.asd")))))
10500
10501 (define-public cl-constantfold
10502   (sbcl-package->cl-source-package sbcl-constantfold))
10503
10504 (define-public sbcl-gtype
10505   (let ((commit "42275e3606242ae91e9c8dfa30c18ced50a35b66")
10506         (revision "1"))
10507     (package
10508       (name "sbcl-gtype")
10509       (version (git-version "0.1" revision commit))
10510       (source
10511        (origin
10512          (method git-fetch)
10513          (uri (git-reference
10514                (url "https://github.com/numcl/gtype.git")
10515                (commit commit)))
10516          (file-name (git-file-name name version))
10517          (sha256
10518           (base32
10519            "1f56dba998v945jcxhha391557n6md1ql25b7icfwwfivhmlaa9b"))))
10520       (build-system asdf-build-system/sbcl)
10521       (synopsis "C++/Julia-like parametric types in Common Lisp")
10522       (description
10523        "Support library for numcl that provides Julia-like runtime parametric
10524 type correctness in Common Lisp.  It is based on CLtL2 extensions.")
10525       (home-page "https://github.com/numcl/gtype")
10526       (license license:lgpl3+)
10527       (inputs
10528        `(("trivialib.type-unify" ,sbcl-trivialib-type-unify)
10529          ("trivial-cltl2" ,sbcl-trivial-cltl2)
10530          ("trivia" ,sbcl-trivia)
10531          ("alexandria" ,sbcl-alexandria)
10532          ("iterate" ,sbcl-iterate)
10533          ("type-r" ,sbcl-type-r)))
10534       (native-inputs
10535        `(("fiveam" ,sbcl-fiveam)))
10536       (arguments
10537        `(#:asd-system-name "gtype"
10538          #:asd-file "gtype.asd"
10539          #:test-asd-file "gtype.test.asd")))))
10540
10541 (define-public cl-gtype
10542   (sbcl-package->cl-source-package sbcl-gtype))
10543
10544 (define-public sbcl-numcl
10545   (let ((commit "1cf7dfa59f763a24a501092870e9c5ee745d0c17")
10546         (revision "1"))
10547     (package
10548       (name "sbcl-numcl")
10549       (version (git-version "0.1.0" revision commit))
10550       (source
10551        (origin
10552          (method git-fetch)
10553          (uri (git-reference
10554                (url "https://github.com/numcl/numcl.git")
10555                (commit commit)))
10556          (file-name (git-file-name name version))
10557          (sha256
10558           (base32
10559            "0i3jby9hf4ii7blivgyza80g0vmjfhk8537i5i7kqqk0i5sdnym2"))))
10560       (build-system asdf-build-system/sbcl)
10561       (synopsis "Numpy clone in Common Lisp")
10562       (description
10563        "This is a Numpy clone in Common Lisp.  At the moment the
10564 library is written in pure Common Lisp, focusing more on correctness
10565 and usefulness, not speed.  Track the progress at
10566 @url{https://github.com/numcl/numcl/projects/1}.")
10567       (home-page "https://github.com/numcl/numcl")
10568       (license license:lgpl3+)
10569       (inputs
10570        `(("trivia" ,sbcl-trivia)
10571          ("alexandria" ,sbcl-alexandria)
10572          ("iterate" ,sbcl-iterate)
10573          ("lisp-namespace" ,sbcl-lisp-namespace)
10574          ("type-r" ,sbcl-type-r)
10575          ("constantfold" ,sbcl-constantfold)
10576          ("cl-randist" ,sbcl-cl-randist)
10577          ("float-features" ,sbcl-float-features)
10578          ("function-cache" ,sbcl-function-cache)
10579          ("specialized-function" ,sbcl-specialized-function)
10580          ("gtype" ,sbcl-gtype)))
10581       (native-inputs
10582        `(("fiveam" ,sbcl-fiveam)))
10583       (arguments
10584        `(#:asd-system-name "numcl"
10585          #:asd-file "numcl.asd"
10586          #:test-asd-file "numcl.test.asd")))))
10587
10588 (define-public cl-numcl
10589   (sbcl-package->cl-source-package sbcl-numcl))