gnu/packages/lisp-xyz.scm

   1 ;;; GNU Guix --- Functional package management for GNU
   2 ;;; Copyright © 2014 John Darrington <jmd@gnu.org>
   3 ;;; Copyright © 2015 Taylan Ulrich Bayırlı/Kammer <taylanbayirli@gmail.com>
   4 ;;; Copyright © 2015 Mark H Weaver <mhw@netris.org>
   5 ;;; Copyright © 2016 Federico Beffa <beffa@fbengineering.ch>
   6 ;;; Copyright © 2016, 2017 ng0 <ng0@n0.is>
   7 ;;; Copyright © 2016, 2017 Andy Patterson <ajpatter@uwaterloo.ca>
   8 ;;; Copyright © 2017, 2019, 2020 Ricardo Wurmus <rekado@elephly.net>
   9 ;;; Copyright © 2017, 2018, 2019 Efraim Flashner <efraim@flashner.co.il>
  10 ;;; Copyright © 2017, 2019 Tobias Geerinckx-Rice <me@tobias.gr>
  11 ;;; Copyright © 2018 Benjamin Slade <slade@jnanam.net>
  12 ;;; Copyright © 2018 Alex Vong <alexvong1995@gmail.com>
  13 ;;; Copyright © 2018, 2020 Pierre Neidhardt <mail@ambrevar.xyz>
  14 ;;; Copyright © 2018, 2019 Pierre Langlois <pierre.langlois@gmx.com>
  15 ;;; Copyright © 2019, 2020 Katherine Cox-Buday <cox.katherine.e@gmail.com>
  16 ;;; Copyright © 2019 Jesse Gildersleve <jessejohngildersleve@protonmail.com>
  17 ;;; Copyright © 2019, 2020 Guillaume Le Vaillant <glv@posteo.net>
  18 ;;; Copyright © 2019 Brett Gilio <brettg@gnu.org>
  19 ;;; Copyright © 2020 Konrad Hinsen <konrad.hinsen@fastmail.net>
  20 ;;; Copyright © 2020 Dimakis Dimakakos <me@bendersteed.tech>
  21 ;;; Copyright © 2020 Oleg Pykhalov <go.wigust@gmail.com>
  22 ;;;
  23 ;;; This file is part of GNU Guix.
  24 ;;;
  25 ;;; GNU Guix is free software; you can redistribute it and/or modify it
  26 ;;; under the terms of the GNU General Public License as published by
  27 ;;; the Free Software Foundation; either version 3 of the License, or (at
  28 ;;; your option) any later version.
  29 ;;;
  30 ;;; GNU Guix is distributed in the hope that it will be useful, but
  31 ;;; WITHOUT ANY WARRANTY; without even the implied warranty of
  32 ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  33 ;;; GNU General Public License for more details.
  34 ;;;
  35 ;;; You should have received a copy of the GNU General Public License
  36 ;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.
  37
  38 ;;; This file only contains Common Lisp libraries.
  39 ;;; Common Lisp compilers and tooling go to lisp.scm.
  40 ;;; Common Lisp applications should go to the most appropriate file,
  41 ;;; e.g. StumpWM is in wm.scm.
  42
  43 (define-module (gnu packages lisp-xyz)
  44   #:use-module (gnu packages)
  45   #:use-module ((guix licenses) #:prefix license:)
  46   #:use-module (guix packages)
  47   #:use-module (guix download)
  48   #:use-module (guix git-download)
  49   #:use-module (guix hg-download)
  50   #:use-module (guix utils)
  51   #:use-module (guix build-system asdf)
  52   #:use-module (guix build-system trivial)
  53   #:use-module (gnu packages c)
  54   #:use-module (gnu packages compression)
  55   #:use-module (gnu packages databases)
  56   #:use-module (gnu packages enchant)
  57   #:use-module (gnu packages glib)
  58   #:use-module (gnu packages gtk)
  59   #:use-module (gnu packages imagemagick)
  60   #:use-module (gnu packages libevent)
  61   #:use-module (gnu packages libffi)
  62   #:use-module (gnu packages lisp)
  63   #:use-module (gnu packages maths)
  64   #:use-module (gnu packages networking)
  65   #:use-module (gnu packages pkg-config)
  66   #:use-module (gnu packages python)
  67   #:use-module (gnu packages python-xyz)
  68   #:use-module (gnu packages sqlite)
  69   #:use-module (gnu packages tcl)
  70   #:use-module (gnu packages tls)
  71   #:use-module (gnu packages webkit)
  72   #:use-module (gnu packages xdisorg)
  73   #:use-module (ice-9 match)
  74   #:use-module (srfi srfi-19))
  75
  76 (define-public sbcl-alexandria
  77   (let ((commit "5e5c7d83090cc0fbf32c4628362ac3ce2c50dc59"))
  78     (package
  79       (name "sbcl-alexandria")
  80       (version "1.0.1")
  81       (source
  82        (origin
  83          (method git-fetch)
  84          (uri (git-reference
  85                (url "https://gitlab.common-lisp.net/alexandria/alexandria.git")
  86                (commit commit)))
  87          (sha256
  88           (base32
  89            "010w8829dq28jf8ajfzas9nfvpxa5bal04mg299xq6y9spihc2iz"))
  90          (file-name (git-file-name name version))))
  91       (build-system asdf-build-system/sbcl)
  92       (native-inputs
  93        `(("rt" ,sbcl-rt)))
  94       (synopsis "Collection of portable utilities for Common Lisp")
  95       (description
  96        "Alexandria is a collection of portable utilities.  It does not contain
  97 conceptual extensions to Common Lisp.  It is conservative in scope, and
  98 portable between implementations.")
  99       (home-page "https://common-lisp.net/project/alexandria/")
 100       (license license:public-domain))))
 101
 102 (define-public cl-alexandria
 103   (sbcl-package->cl-source-package sbcl-alexandria))
 104
 105 (define-public ecl-alexandria
 106   (sbcl-package->ecl-package sbcl-alexandria))
 107
 108 (define-public sbcl-net.didierverna.asdf-flv
 109   (package
 110     (name "sbcl-net.didierverna.asdf-flv")
 111     (version "2.1")
 112     (source
 113      (origin
 114        (method git-fetch)
 115        (uri (git-reference
 116              (url "https://github.com/didierverna/asdf-flv")
 117              (commit (string-append "version-" version))))
 118        (file-name (git-file-name "asdf-flv" version))
 119        (sha256
 120         (base32 "1fi2y4baxan103jbg4idjddzihy03kwnj2mzbwrknw4d4x7xlgwj"))))
 121     (build-system asdf-build-system/sbcl)
 122     (synopsis "Common Lisp ASDF extension to provide support for file-local variables")
 123     (description "ASDF-FLV provides support for file-local variables through
 124 ASDF.  A file-local variable behaves like @code{*PACKAGE*} and
 125 @code{*READTABLE*} with respect to @code{LOAD} and @code{COMPILE-FILE}: a new
 126 dynamic binding is created before processing the file, so that any
 127 modification to the variable becomes essentially file-local.
 128
 129 In order to make one or several variables file-local, use the macros
 130 @code{SET-FILE-LOCAL-VARIABLE(S)}.")
 131     (home-page "https://www.lrde.epita.fr/~didier/software/lisp/misc.php#asdf-flv")
 132     (license (license:non-copyleft
 133               "https://www.gnu.org/prep/maintain/html_node/License-Notices-for-Other-Files.html"
 134               "GNU All-Permissive License"))))
 135
 136 (define-public cl-net.didierverna.asdf-flv
 137   (sbcl-package->cl-source-package sbcl-net.didierverna.asdf-flv))
 138
 139 (define-public ecl-net.didierverna.asdf-flv
 140   (sbcl-package->ecl-package sbcl-net.didierverna.asdf-flv))
 141
 142 (define-public sbcl-fiveam
 143   (package
 144     (name "sbcl-fiveam")
 145     (version "1.4.1")
 146     (source
 147      (origin
 148        (method git-fetch)
 149        (uri (git-reference
 150              (url "https://github.com/sionescu/fiveam.git")
 151              (commit (string-append "v" version))))
 152        (file-name (git-file-name "fiveam" version))
 153        (sha256
 154         (base32 "1q3d38pwafnwnw42clq0f8g5xw7pbzr287jl9jsqmb1vb0n1vrli"))))
 155     (inputs
 156      `(("alexandria" ,sbcl-alexandria)
 157        ("net.didierverna.asdf-flv" ,sbcl-net.didierverna.asdf-flv)
 158        ("trivial-backtrace" ,sbcl-trivial-backtrace)))
 159     (build-system asdf-build-system/sbcl)
 160     (synopsis "Common Lisp testing framework")
 161     (description "FiveAM is a simple (as far as writing and running tests
 162 goes) regression testing framework.  It has been designed with Common Lisp's
 163 interactive development model in mind.")
 164     (home-page "https://common-lisp.net/project/fiveam/")
 165     (license license:bsd-3)))
 166
 167 (define-public cl-fiveam
 168   (sbcl-package->cl-source-package sbcl-fiveam))
 169
 170 (define-public ecl-fiveam
 171   (sbcl-package->ecl-package sbcl-fiveam))
 172
 173 (define-public sbcl-bordeaux-threads
 174   (package
 175     (name "sbcl-bordeaux-threads")
 176     (version "0.8.7")
 177     (source (origin
 178               (method git-fetch)
 179               (uri (git-reference
 180                     (url "https://github.com/sionescu/bordeaux-threads.git")
 181                     (commit (string-append "v" version))))
 182               (sha256
 183                (base32 "1whpfmyxp2fsw6viqj45fqgsifgr534c575bfh5vaqw5m84b6alp"))
 184               (file-name
 185                (git-file-name "bordeaux-threads" version))))
 186     (inputs `(("alexandria" ,sbcl-alexandria)))
 187     (native-inputs `(("fiveam" ,sbcl-fiveam)))
 188     (build-system asdf-build-system/sbcl)
 189     (synopsis "Portable shared-state concurrency library for Common Lisp")
 190     (description "BORDEAUX-THREADS is a proposed standard for a minimal
 191 MP/Threading interface.  It is similar to the CLIM-SYS threading and lock
 192 support.")
 193     (home-page "https://common-lisp.net/project/bordeaux-threads/")
 194     (license license:x11)))
 195
 196 (define-public cl-bordeaux-threads
 197   (sbcl-package->cl-source-package sbcl-bordeaux-threads))
 198
 199 (define-public ecl-bordeaux-threads
 200   (sbcl-package->ecl-package sbcl-bordeaux-threads))
 201
 202 (define-public sbcl-trivial-gray-streams
 203   (let ((revision "1")
 204         (commit "ebd59b1afed03b9dc8544320f8f432fdf92ab010"))
 205     (package
 206       (name "sbcl-trivial-gray-streams")
 207       (version (string-append "0.0.0-" revision "." (string-take commit 7)))
 208       (source
 209        (origin
 210          (method git-fetch)
 211          (uri
 212           (git-reference
 213            (url "https://github.com/trivial-gray-streams/trivial-gray-streams.git")
 214            (commit commit)))
 215          (sha256
 216           (base32 "0b1pxlccmnagk9cbh4cy8s5k66g3x0gwib5shjwr24xvrji6lp94"))
 217          (file-name
 218           (string-append "trivial-gray-streams-" version "-checkout"))))
 219       (build-system asdf-build-system/sbcl)
 220       (synopsis "Compatibility layer for Gray streams implementations")
 221       (description "Gray streams is an interface proposed for inclusion with
 222 ANSI CL by David N. Gray.  The proposal did not make it into ANSI CL, but most
 223 popular CL implementations implement it.  This package provides an extremely
 224 thin compatibility layer for gray streams.")
 225       (home-page "https://www.cliki.net/trivial-gray-streams")
 226       (license license:x11))))
 227
 228 (define-public cl-trivial-gray-streams
 229   (sbcl-package->cl-source-package sbcl-trivial-gray-streams))
 230
 231 (define-public ecl-trivial-gray-streams
 232   (sbcl-package->ecl-package sbcl-trivial-gray-streams))
 233
 234 (define-public sbcl-fiasco
 235   (let ((commit "d62f7558b21addc89f87e306f65d7f760632655f")
 236         (revision "1"))
 237     (package
 238       (name "sbcl-fiasco")
 239       (version (git-version "0.0.1" revision commit))
 240       (source
 241        (origin
 242          (method git-fetch)
 243          (uri (git-reference
 244                (url "https://github.com/joaotavora/fiasco.git")
 245                (commit commit)))
 246          (file-name (git-file-name "fiasco" version))
 247          (sha256
 248           (base32
 249            "1zwxs3d6iswayavcmb49z2892xhym7n556d8dnmvalc32pm9bkjh"))))
 250       (build-system asdf-build-system/sbcl)
 251       (inputs
 252        `(("alexandria" ,sbcl-alexandria)
 253          ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
 254       (synopsis "Simple and powerful test framework for Common Lisp")
 255       (description "A Common Lisp test framework that treasures your failures,
 256 logical continuation of Stefil.  It focuses on interactive debugging.")
 257       (home-page "https://github.com/joaotavora/fiasco")
 258       ;; LICENCE specifies this is public-domain unless the legislation
 259       ;; doesn't allow or recognize it.  In that case it falls back to a
 260       ;; permissive licence.
 261       (license (list license:public-domain
 262                      (license:x11-style "file://LICENCE"))))))
 263
 264 (define-public cl-fiasco
 265   (sbcl-package->cl-source-package sbcl-fiasco))
 266
 267 (define-public ecl-fiasco
 268   (sbcl-package->ecl-package sbcl-fiasco))
 269
 270 (define-public sbcl-flexi-streams
 271   (package
 272     (name "sbcl-flexi-streams")
 273     (version "1.0.18")
 274     (source
 275      (origin
 276        (method git-fetch)
 277        (uri (git-reference
 278              (url "https://github.com/edicl/flexi-streams.git")
 279              (commit (string-append "v" version))))
 280        (file-name (git-file-name "flexi-streams" version))
 281        (sha256
 282         (base32 "0bjv7fd2acknidc5dyi3h85pn10krxv5jyxs1xg8jya2rlfv7f1j"))))
 283     (build-system asdf-build-system/sbcl)
 284     (arguments
 285      `(#:phases
 286        (modify-phases %standard-phases
 287          (add-after 'unpack 'make-git-checkout-writable
 288            (lambda _
 289              (for-each make-file-writable (find-files "."))
 290              #t)))))
 291     (inputs `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
 292     (synopsis "Implementation of virtual bivalent streams for Common Lisp")
 293     (description "Flexi-streams is an implementation of \"virtual\" bivalent
 294 streams that can be layered atop real binary or bivalent streams and that can
 295 be used to read and write character data in various single- or multi-octet
 296 encodings which can be changed on the fly.  It also supplies in-memory binary
 297 streams which are similar to string streams.")
 298     (home-page "http://weitz.de/flexi-streams/")
 299     (license license:bsd-3)))
 300
 301 (define-public cl-flexi-streams
 302   (sbcl-package->cl-source-package sbcl-flexi-streams))
 303
 304 (define-public ecl-flexi-streams
 305   (sbcl-package->ecl-package sbcl-flexi-streams))
 306
 307 (define-public sbcl-cl-ppcre
 308   (package
 309     (name "sbcl-cl-ppcre")
 310     (version "2.1.1")
 311     (source
 312      (origin
 313        (method git-fetch)
 314        (uri (git-reference
 315              (url "https://github.com/edicl/cl-ppcre.git")
 316              (commit (string-append "v" version))))
 317        (file-name (git-file-name "cl-ppcre" version))
 318        (sha256
 319         (base32 "0dwvr29diqzcg5n6jvbk2rnd90i05l7n828hhw99khmqd0kz7xsi"))))
 320     (build-system asdf-build-system/sbcl)
 321     (native-inputs `(("flexi-streams" ,sbcl-flexi-streams)))
 322     (synopsis "Portable regular expression library for Common Lisp")
 323     (description "CL-PPCRE is a portable regular expression library for Common
 324 Lisp, which is compatible with perl.  It is pretty fast, thread-safe, and
 325 compatible with ANSI-compliant Common Lisp implementations.")
 326     (home-page "http://weitz.de/cl-ppcre/")
 327     (license license:bsd-2)))
 328
 329 (define-public cl-ppcre
 330   (sbcl-package->cl-source-package sbcl-cl-ppcre))
 331
 332 (define-public ecl-cl-ppcre
 333   (sbcl-package->ecl-package sbcl-cl-ppcre))
 334
 335 (define sbcl-cl-unicode-base
 336   (package
 337     (name "sbcl-cl-unicode-base")
 338     (version "0.1.6")
 339     (source (origin
 340               (method git-fetch)
 341               (uri (git-reference
 342                     (url "https://github.com/edicl/cl-unicode.git")
 343                     (commit (string-append "v" version))))
 344               (file-name (git-file-name name version))
 345               (sha256
 346                (base32
 347                 "0ykx2s9lqfl74p1px0ik3l2izd1fc9jd1b4ra68s5x34rvjy0hza"))))
 348     (build-system asdf-build-system/sbcl)
 349     (arguments
 350      '(#:asd-file "cl-unicode.asd"
 351        #:asd-system-name "cl-unicode/base"))
 352     (inputs
 353      `(("cl-ppcre" ,sbcl-cl-ppcre)))
 354     (home-page "http://weitz.de/cl-unicode/")
 355     (synopsis "Portable Unicode library for Common Lisp")
 356     (description "CL-UNICODE is a portable Unicode library Common Lisp, which
 357 is compatible with perl.  It is pretty fast, thread-safe, and compatible with
 358 ANSI-compliant Common Lisp implementations.")
 359     (license license:bsd-2)))
 360
 361 (define-public sbcl-cl-unicode
 362   (package
 363     (inherit sbcl-cl-unicode-base)
 364     (name "sbcl-cl-unicode")
 365     (inputs
 366      `(("cl-unicode/base" ,sbcl-cl-unicode-base)
 367        ,@(package-inputs sbcl-cl-unicode-base)))
 368     (native-inputs
 369      `(("flexi-streams" ,sbcl-flexi-streams)))
 370     (arguments '())))
 371
 372 (define-public ecl-cl-unicode
 373   (sbcl-package->ecl-package sbcl-cl-unicode))
 374
 375 (define-public cl-unicode
 376   (sbcl-package->cl-source-package sbcl-cl-unicode))
 377
 378 (define-public sbcl-zpb-ttf
 379   (package
 380     (name "sbcl-zpb-ttf")
 381     (version "1.0.3")
 382     (source
 383      (origin
 384        (method git-fetch)
 385        (uri (git-reference
 386              (url "https://github.com/xach/zpb-ttf.git")
 387              (commit (string-append "release-" version))))
 388        (file-name (git-file-name name version))
 389        (sha256
 390         (base32
 391          "1wh66vjijzqlydnrihynpwp6796917xwrh0i9li93c17kyxa74ih"))))
 392     (build-system asdf-build-system/sbcl)
 393     (home-page "https://github.com/xach/zpb-ttf")
 394     (synopsis "TrueType font file access for Common Lisp")
 395     (description
 396      "ZPB-TTF is a TrueType font file parser that provides an interface for
 397 reading typographic metrics, glyph outlines, and other information from the
 398 file.")
 399     (license license:bsd-2)))
 400
 401 (define-public ecl-zpb-ttf
 402   (sbcl-package->ecl-package sbcl-zpb-ttf))
 403
 404 (define-public cl-zpb-ttf
 405   (sbcl-package->cl-source-package sbcl-zpb-ttf))
 406
 407 (define-public sbcl-cl-aa
 408   (package
 409     (name "sbcl-cl-aa")
 410     (version "0.1.5")
 411     (source
 412      (origin
 413        (method url-fetch)
 414        (uri (string-append "http://projects.tuxee.net/cl-vectors/"
 415                            "files/cl-vectors-" version ".tar.gz"))
 416        (sha256
 417         (base32
 418          "04lhwi0kq8pkwhgd885pk80m1cp9sfvjjn5zj70s1dnckibhdmqh"))))
 419     (build-system asdf-build-system/sbcl)
 420     (arguments '(#:asd-file "cl-aa.asd"))
 421     (home-page "http://projects.tuxee.net/cl-vectors/")
 422     (synopsis "Polygon rasterizer")
 423     (description
 424      "This is a Common Lisp library implementing the AA polygon rasterization
 425 algorithm from the @url{http://antigrain.com, Antigrain} project.")
 426     (license license:expat)))
 427
 428 (define-public ecl-cl-aa
 429   (sbcl-package->ecl-package sbcl-cl-aa))
 430
 431 (define-public cl-aa
 432   (sbcl-package->cl-source-package sbcl-cl-aa))
 433
 434 (define-public sbcl-cl-paths
 435   (package
 436     (inherit sbcl-cl-aa)
 437     (name "sbcl-cl-paths")
 438     (arguments '(#:asd-file "cl-paths.asd"))
 439     (synopsis "Facilities to create and manipulate vectorial paths")
 440     (description
 441      "This package provides facilities to create and manipulate vectorial
 442 paths.")))
 443
 444 (define-public ecl-cl-paths
 445   (sbcl-package->ecl-package sbcl-cl-paths))
 446
 447 (define-public cl-paths
 448   (sbcl-package->cl-source-package sbcl-cl-paths))
 449
 450 (define-public sbcl-cl-paths-ttf
 451   (package
 452     (inherit sbcl-cl-aa)
 453     (name "sbcl-cl-paths-ttf")
 454     (arguments '(#:asd-file "cl-paths-ttf.asd"))
 455     (inputs
 456      `(("cl-paths" ,sbcl-cl-paths)
 457        ("zpb-ttf" ,sbcl-zpb-ttf)))
 458     (synopsis "Facilities to create and manipulate vectorial paths")
 459     (description
 460      "This package provides facilities to create and manipulate vectorial
 461 paths.")))
 462
 463 (define-public ecl-cl-paths-ttf
 464   (sbcl-package->ecl-package sbcl-cl-paths-ttf))
 465
 466 (define-public cl-paths-ttf
 467   (sbcl-package->cl-source-package sbcl-cl-paths-ttf))
 468
 469 (define-public sbcl-cl-vectors
 470   (package
 471     (inherit sbcl-cl-aa)
 472     (name "sbcl-cl-vectors")
 473     (arguments '(#:asd-file "cl-vectors.asd"))
 474     (inputs
 475      `(("cl-aa" ,sbcl-cl-aa)
 476        ("cl-paths" ,sbcl-cl-paths)))
 477     (synopsis "Create, transform and render anti-aliased vectorial paths")
 478     (description
 479      "This is a pure Common Lisp library to create, transform and render
 480 anti-aliased vectorial paths.")))
 481
 482 (define-public ecl-cl-vectors
 483   (sbcl-package->ecl-package sbcl-cl-vectors))
 484
 485 (define-public cl-vectors
 486   (sbcl-package->cl-source-package sbcl-cl-vectors))
 487
 488 (define-public sbcl-spatial-trees
 489   ;; There have been no releases.
 490   (let ((commit "81fdad0a0bf109c80a53cc96eca2e093823400ba")
 491         (revision "1"))
 492     (package
 493       (name "sbcl-spatial-trees")
 494       (version (git-version "0" revision commit))
 495       (source
 496        (origin
 497          (method git-fetch)
 498          (uri (git-reference
 499                (url "https://github.com/rpav/spatial-trees.git")
 500                (commit commit)))
 501          (file-name (git-file-name name version))
 502          (sha256
 503           (base32
 504            "11rhc6h501dwcik2igkszz7b9n515cr99m5pjh4r2qfwgiri6ysa"))))
 505       (build-system asdf-build-system/sbcl)
 506       (arguments
 507        '(#:tests? #f           ; spatial-trees.test requires spatial-trees.nns
 508          #:asd-file "spatial-trees.asd"
 509          #:test-asd-file "spatial-trees.test.asd"))
 510       (native-inputs
 511        `(("fiveam" ,sbcl-fiveam)))
 512       (home-page "https://github.com/rpav/spatial-trees")
 513       (synopsis "Dynamic index data structures for spatially-extended data")
 514       (description
 515        "Spatial-trees is a set of dynamic index data structures for
 516 spatially-extended data.")
 517       (license license:bsd-3))))
 518
 519 (define-public ecl-spatial-trees
 520   (sbcl-package->ecl-package sbcl-spatial-trees))
 521
 522 (define-public cl-spatial-trees
 523   (sbcl-package->cl-source-package sbcl-spatial-trees))
 524
 525 (define-public sbcl-flexichain
 526   ;; There are no releases.
 527   (let ((commit "13d2a6c505ed0abfcd4c4ec7d7145059b06855d6")
 528         (revision "1"))
 529     (package
 530       (name "sbcl-flexichain")
 531       (version "1.5.1")
 532       (source
 533        (origin
 534          (method git-fetch)
 535          (uri (git-reference
 536                (url "https://github.com/robert-strandh/Flexichain.git")
 537                (commit commit)))
 538          (file-name (git-file-name name version))
 539          (sha256
 540           (base32
 541            "0pfyvhsfbjd2sjb30grfs52r51a428xglv7bwydvpg2lc117qimg"))))
 542       (build-system asdf-build-system/sbcl)
 543       (home-page "https://github.com/robert-strandh/Flexichain.git")
 544       (synopsis "Dynamically add elements to or remove them from sequences")
 545       (description
 546        "This package provides an implementation of the flexichain protocol,
 547 allowing client code to dynamically add elements to, and delete elements from
 548 a sequence (or chain) of such elements.")
 549       (license license:lgpl2.1+))))
 550
 551 (define-public ecl-flexichain
 552   (sbcl-package->ecl-package sbcl-flexichain))
 553
 554 (define-public cl-flexichain
 555   (sbcl-package->cl-source-package sbcl-flexichain))
 556
 557 (define-public sbcl-cl-pdf
 558   ;; There are no releases
 559   (let ((commit "752e337e6d6fc206f09d091a982e7f8e5c404e4e")
 560         (revision "1"))
 561     (package
 562       (name "sbcl-cl-pdf")
 563       (version (git-version "0" revision commit))
 564       (source
 565        (origin
 566          (method git-fetch)
 567          (uri (git-reference
 568                (url "https://github.com/mbattyani/cl-pdf.git")
 569                (commit commit)))
 570          (file-name (git-file-name name version))
 571          (sha256
 572           (base32
 573            "1cg3k3m3r11ipb8j008y8ipynj97l3xjlpi2knqc9ndmx4r3kb1r"))))
 574       (build-system asdf-build-system/sbcl)
 575       (inputs
 576        `(("iterate" ,sbcl-iterate)
 577          ("zpb-ttf" ,sbcl-zpb-ttf)))
 578       (home-page "https://github.com/mbattyani/cl-pdf")
 579       (synopsis "Common Lisp library for generating PDF files")
 580       (description
 581        "CL-PDF is a cross-platform Common Lisp library for generating PDF
 582 files.")
 583       (license license:bsd-2))))
 584
 585 (define-public ecl-cl-pdf
 586   (sbcl-package->ecl-package sbcl-cl-pdf))
 587
 588 (define-public cl-pdf
 589   (sbcl-package->cl-source-package sbcl-cl-pdf))
 590
 591 (define-public sbcl-clx
 592   (package
 593     (name "sbcl-clx")
 594     (version "0.7.5")
 595     (source
 596      (origin
 597        (method git-fetch)
 598        (uri
 599         (git-reference
 600          (url "https://github.com/sharplispers/clx.git")
 601          (commit version)))
 602        (sha256
 603         (base32
 604          "1vi67z9hpj5rr4xcmfbfwzmlcc0ah7hzhrmfid6lqdkva238v2wf"))
 605        (file-name (string-append "clx-" version))))
 606     (build-system asdf-build-system/sbcl)
 607     (native-inputs
 608      `(("fiasco" ,sbcl-fiasco)))
 609     (home-page "https://www.cliki.net/portable-clx")
 610     (synopsis "X11 client library for Common Lisp")
 611     (description "CLX is an X11 client library for Common Lisp.  The code was
 612 originally taken from a CMUCL distribution, was modified somewhat in order to
 613 make it compile and run under SBCL, then a selection of patches were added
 614 from other CLXes around the net.")
 615     (license license:x11)))
 616
 617 (define-public cl-clx
 618   (sbcl-package->cl-source-package sbcl-clx))
 619
 620 (define-public ecl-clx
 621   (sbcl-package->ecl-package sbcl-clx))
 622
 623 (define-public sbcl-clx-truetype
 624   (let ((commit "c6e10a918d46632324d5863a8ed067a83fc26de8")
 625         (revision "1"))
 626     (package
 627       (name "sbcl-clx-truetype")
 628       (version (git-version "0.0.1" revision commit))
 629       (source
 630        (origin
 631          (method git-fetch)
 632          (uri (git-reference
 633                (url "https://github.com/l04m33/clx-truetype")
 634                (commit commit)))
 635          (file-name (git-file-name name version))
 636          (sha256
 637           (base32
 638            "079hyp92cjkdfn6bhkxsrwnibiqbz4y4af6nl31lzw6nm91j5j37"))
 639          (modules '((guix build utils)))
 640          (snippet
 641           '(begin
 642              (substitute* "package.lisp"
 643                ((":export") ":export\n   :+font-cache-filename+"))
 644              #t))))
 645       (build-system asdf-build-system/sbcl)
 646       (inputs
 647        `(("clx" ,sbcl-clx)
 648          ("zpb-ttf" ,sbcl-zpb-ttf)
 649          ("cl-vectors" ,sbcl-cl-vectors)
 650          ("cl-paths-ttf" ,sbcl-cl-paths-ttf)
 651          ("cl-fad" ,sbcl-cl-fad)
 652          ("cl-store" ,sbcl-cl-store)
 653          ("trivial-features" ,sbcl-trivial-features)))
 654       (home-page "https://github.com/l04m33/clx-truetype")
 655       (synopsis "Antialiased TrueType font rendering using CLX and XRender")
 656       (description "CLX-TrueType is pure common lisp solution for
 657 antialiased TrueType font rendering using CLX and XRender extension.")
 658       (license license:expat))))
 659
 660 (define-public sbcl-cl-ppcre-unicode
 661   (package (inherit sbcl-cl-ppcre)
 662     (name "sbcl-cl-ppcre-unicode")
 663     (arguments
 664      `(#:tests? #f ; tests fail with "Component :CL-PPCRE-TEST not found"
 665        #:asd-file "cl-ppcre-unicode.asd"))
 666     (inputs
 667      `(("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
 668        ("sbcl-cl-unicode" ,sbcl-cl-unicode)))))
 669
 670 (define-public ecl-cl-ppcre-unicode
 671   (sbcl-package->ecl-package sbcl-cl-ppcre-unicode))
 672
 673 ;; The slynk that users expect to install includes all of slynk's contrib
 674 ;; modules.  Therefore, we build the base module and all contribs first; then
 675 ;; we expose the union of these as `sbcl-slynk'.  The following variable
 676 ;; describes the base module.
 677 (define sbcl-slynk-boot0
 678   (let ((revision "2")
 679         (commit "cbf84c36c4eca8b032e3fd16177a7bc02df3ec4c"))
 680     (package
 681       (name "sbcl-slynk-boot0")
 682       (version (string-append "1.0.0-beta-" revision "." (string-take commit 7)))
 683       (source
 684        (origin
 685          (method git-fetch)
 686          (uri
 687           (git-reference
 688            (url "https://github.com/joaotavora/sly.git")
 689            (commit commit)))
 690          (sha256
 691           (base32 "13dyhsravn591p7g6is01mp2ynzjnnj7pwgi57r6xqmd4611y9vh"))
 692          (file-name (string-append "slynk-" version "-checkout"))
 693          (modules '((guix build utils)
 694                     (ice-9 ftw)))
 695          (snippet
 696           '(begin
 697              ;; Move the contribs into the main source directory for easier
 698              ;; access
 699              (substitute* "slynk/slynk.asd"
 700                (("\\.\\./contrib")
 701                 "contrib")
 702                (("\\(defsystem :slynk/util")
 703                 "(defsystem :slynk/util :depends-on (:slynk)")
 704                ((":depends-on \\(:slynk :slynk/util\\)")
 705                 ":depends-on (:slynk :slynk-util)"))
 706              (substitute* "contrib/slynk-trace-dialog.lisp"
 707                (("\\(slynk::reset-inspector\\)") ; Causes problems on load
 708                 "nil"))
 709              (substitute* "contrib/slynk-profiler.lisp"
 710                (("slynk:to-line")
 711                 "slynk-pprint-to-line"))
 712              (substitute* "contrib/slynk-fancy-inspector.lisp"
 713                (("slynk/util") "slynk-util")
 714                ((":compile-toplevel :load-toplevel") ""))
 715              (rename-file "contrib" "slynk/contrib")
 716              ;; Move slynk's contents into the base directory for easier
 717              ;; access
 718              (for-each (lambda (file)
 719                          (unless (string-prefix? "." file)
 720                            (rename-file (string-append "slynk/" file)
 721                                         (string-append "./" (basename file)))))
 722                        (scandir "slynk"))
 723              #t))))
 724       (build-system asdf-build-system/sbcl)
 725       (arguments
 726        `(#:tests? #f ; No test suite
 727          #:asd-system-name "slynk"))
 728       (synopsis "Common Lisp IDE for Emacs")
 729       (description "SLY is a fork of SLIME, an IDE backend for Common Lisp.
 730 It also features a completely redesigned REPL based on Emacs's own
 731 full-featured comint.el, live code annotations, and a consistent interactive
 732 button interface.  Everything can be copied to the REPL.  One can create
 733 multiple inspectors with independent history.")
 734       (home-page "https://github.com/joaotavora/sly")
 735       (license license:public-domain)
 736       (properties `((cl-source-variant . ,(delay cl-slynk)))))))
 737
 738 (define-public cl-slynk
 739   (package
 740     (inherit (sbcl-package->cl-source-package sbcl-slynk-boot0))
 741     (name "cl-slynk")))
 742
 743 (define ecl-slynk-boot0
 744   (sbcl-package->ecl-package sbcl-slynk-boot0))
 745
 746 (define sbcl-slynk-arglists
 747   (package
 748     (inherit sbcl-slynk-boot0)
 749     (name "sbcl-slynk-arglists")
 750     (inputs `(("slynk" ,sbcl-slynk-boot0)))
 751     (arguments
 752      (substitute-keyword-arguments (package-arguments sbcl-slynk-boot0)
 753        ((#:asd-file _ "") "slynk.asd")
 754        ((#:asd-system-name _ #f) "slynk/arglists")))))
 755
 756 (define ecl-slynk-arglists
 757   (sbcl-package->ecl-package sbcl-slynk-arglists))
 758
 759 (define sbcl-slynk-util
 760   (package
 761     (inherit sbcl-slynk-boot0)
 762     (name "sbcl-slynk-util")
 763     (inputs `(("slynk" ,sbcl-slynk-boot0)))
 764     (arguments
 765      (substitute-keyword-arguments (package-arguments sbcl-slynk-boot0)
 766        ((#:asd-file _ "") "slynk.asd")
 767        ((#:asd-system-name _ #f) "slynk/util")))))
 768
 769 (define ecl-slynk-util
 770   (sbcl-package->ecl-package sbcl-slynk-util))
 771
 772 (define sbcl-slynk-fancy-inspector
 773   (package
 774     (inherit sbcl-slynk-arglists)
 775     (name "sbcl-slynk-fancy-inspector")
 776     (inputs `(("slynk-util" ,sbcl-slynk-util)
 777               ,@(package-inputs sbcl-slynk-arglists)))
 778     (arguments
 779      (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
 780        ((#:asd-system-name _ #f) "slynk/fancy-inspector")))))
 781
 782 (define ecl-slynk-fancy-inspector
 783   (sbcl-package->ecl-package sbcl-slynk-fancy-inspector))
 784
 785 (define sbcl-slynk-package-fu
 786   (package
 787     (inherit sbcl-slynk-arglists)
 788     (name "sbcl-slynk-package-fu")
 789     (arguments
 790      (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
 791        ((#:asd-system-name _ #f) "slynk/package-fu")))))
 792
 793 (define ecl-slynk-package-fu
 794   (sbcl-package->ecl-package sbcl-slynk-package-fu))
 795
 796 (define sbcl-slynk-mrepl
 797   (package
 798     (inherit sbcl-slynk-fancy-inspector)
 799     (name "sbcl-slynk-mrepl")
 800     (arguments
 801      (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
 802        ((#:asd-system-name _ #f) "slynk/mrepl")))))
 803
 804 (define ecl-slynk-mrepl
 805   (sbcl-package->ecl-package sbcl-slynk-mrepl))
 806
 807 (define sbcl-slynk-trace-dialog
 808   (package
 809     (inherit sbcl-slynk-arglists)
 810     (name "sbcl-slynk-trace-dialog")
 811     (arguments
 812      (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
 813        ((#:asd-system-name _ #f) "slynk/trace-dialog")))))
 814
 815 (define ecl-slynk-trace-dialog
 816   (sbcl-package->ecl-package sbcl-slynk-trace-dialog))
 817
 818 (define sbcl-slynk-profiler
 819   (package
 820     (inherit sbcl-slynk-arglists)
 821     (name "sbcl-slynk-profiler")
 822     (arguments
 823      (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
 824        ((#:asd-system-name _ #f) "slynk/profiler")))))
 825
 826 (define ecl-slynk-profiler
 827   (sbcl-package->ecl-package sbcl-slynk-profiler))
 828
 829 (define sbcl-slynk-stickers
 830   (package
 831     (inherit sbcl-slynk-arglists)
 832     (name "sbcl-slynk-stickers")
 833     (arguments
 834      (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
 835        ((#:asd-system-name _ #f) "slynk/stickers")))))
 836
 837 (define ecl-slynk-stickers
 838   (sbcl-package->ecl-package sbcl-slynk-stickers))
 839
 840 (define sbcl-slynk-indentation
 841   (package
 842     (inherit sbcl-slynk-arglists)
 843     (name "sbcl-slynk-indentation")
 844     (arguments
 845      (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
 846        ((#:asd-system-name _ #f) "slynk/indentation")))))
 847
 848 (define ecl-slynk-indentation
 849   (sbcl-package->ecl-package sbcl-slynk-indentation))
 850
 851 (define sbcl-slynk-retro
 852   (package
 853     (inherit sbcl-slynk-arglists)
 854     (name "sbcl-slynk-retro")
 855     (arguments
 856      (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
 857        ((#:asd-system-name _ #f) "slynk/retro")))))
 858
 859 (define ecl-slynk-retro
 860   (sbcl-package->ecl-package sbcl-slynk-retro))
 861
 862 (define slynk-systems
 863   '("slynk"
 864     "slynk-util"
 865     "slynk-arglists"
 866     "slynk-fancy-inspector"
 867     "slynk-package-fu"
 868     "slynk-mrepl"
 869     "slynk-profiler"
 870     "slynk-trace-dialog"
 871     "slynk-stickers"
 872     "slynk-indentation"
 873     "slynk-retro"))
 874
 875 (define-public sbcl-slynk
 876   (package
 877     (inherit sbcl-slynk-boot0)
 878     (name "sbcl-slynk")
 879     (inputs
 880      `(("slynk" ,sbcl-slynk-boot0)
 881        ("slynk-util" ,sbcl-slynk-util)
 882        ("slynk-arglists" ,sbcl-slynk-arglists)
 883        ("slynk-fancy-inspector" ,sbcl-slynk-fancy-inspector)
 884        ("slynk-package-fu" ,sbcl-slynk-package-fu)
 885        ("slynk-mrepl" ,sbcl-slynk-mrepl)
 886        ("slynk-profiler" ,sbcl-slynk-profiler)
 887        ("slynk-trace-dialog" ,sbcl-slynk-trace-dialog)
 888        ("slynk-stickers" ,sbcl-slynk-stickers)
 889        ("slynk-indentation" ,sbcl-slynk-indentation)
 890        ("slynk-retro" ,sbcl-slynk-retro)))
 891     (native-inputs `(("sbcl" ,sbcl)))
 892     (build-system trivial-build-system)
 893     (source #f)
 894     (outputs '("out" "image"))
 895     (arguments
 896      `(#:modules ((guix build union)
 897                   (guix build utils)
 898                   (guix build lisp-utils))
 899        #:builder
 900        (begin
 901          (use-modules (ice-9 match)
 902                       (srfi srfi-1)
 903                       (guix build union)
 904                       (guix build lisp-utils))
 905
 906          (union-build
 907           (assoc-ref %outputs "out")
 908           (filter-map
 909            (match-lambda
 910              ((name . path)
 911               (if (string-prefix? "slynk" name) path #f)))
 912            %build-inputs))
 913
 914          (prepend-to-source-registry
 915           (string-append (assoc-ref %outputs "out") "//"))
 916
 917          (parameterize ((%lisp-type "sbcl")
 918                         (%lisp (string-append (assoc-ref %build-inputs "sbcl")
 919                                               "/bin/sbcl")))
 920            (build-image (string-append
 921                          (assoc-ref %outputs "image")
 922                          "/bin/slynk")
 923                         %outputs
 924                         #:dependencies ',slynk-systems))
 925          #t)))))
 926
 927 (define-public ecl-slynk
 928   (package
 929     (inherit sbcl-slynk)
 930     (name "ecl-slynk")
 931     (inputs
 932      (map (match-lambda
 933             ((name pkg . _)
 934              (list name (sbcl-package->ecl-package pkg))))
 935           (package-inputs sbcl-slynk)))
 936     (native-inputs '())
 937     (outputs '("out"))
 938     (arguments
 939      '(#:modules ((guix build union))
 940        #:builder
 941        (begin
 942          (use-modules (ice-9 match)
 943                       (guix build union))
 944          (match %build-inputs
 945            (((names . paths) ...)
 946             (union-build (assoc-ref %outputs "out")
 947                          paths)
 948             #t)))))))
 949
 950 (define-public sbcl-parse-js
 951   (let ((commit "fbadc6029bec7039602abfc06c73bb52970998f6")
 952         (revision "1"))
 953     (package
 954       (name "sbcl-parse-js")
 955       (version (string-append "0.0.0-" revision "." (string-take commit 9)))
 956       (source
 957        (origin
 958          (method git-fetch)
 959          (uri (git-reference
 960                (url "http://marijn.haverbeke.nl/git/parse-js")
 961                (commit commit)))
 962          (file-name (string-append name "-" commit "-checkout"))
 963          (sha256
 964           (base32
 965            "1wddrnr5kiya5s3gp4cdq6crbfy9fqcz7fr44p81502sj3bvdv39"))))
 966       (build-system asdf-build-system/sbcl)
 967       (home-page "https://marijnhaverbeke.nl/parse-js/")
 968       (synopsis "Parse JavaScript")
 969       (description "Parse-js is a Common Lisp package for parsing
 970 JavaScript (ECMAScript 3).  It has basic support for ECMAScript 5.")
 971       (license license:zlib))))
 972
 973 (define-public cl-parse-js
 974   (sbcl-package->cl-source-package sbcl-parse-js))
 975
 976 (define-public sbcl-parse-number
 977   (package
 978     (name "sbcl-parse-number")
 979     (version "1.7")
 980     (source
 981      (origin
 982        (method git-fetch)
 983        (uri (git-reference
 984               (url "https://github.com/sharplispers/parse-number/")
 985               (commit (string-append "v" version))))
 986        (file-name (git-file-name name version))
 987        (sha256
 988         (base32
 989          "0sk06ib1bhqv9y39vwnnw44vmbc4b0kvqm37xxmkxd4dwchq82d7"))))
 990     (build-system asdf-build-system/sbcl)
 991     (home-page "https://www.cliki.net/PARSE-NUMBER")
 992     (synopsis "Parse numbers")
 993     (description "@code{parse-number} is a library of functions for parsing
 994 strings into one of the standard Common Lisp number types without using the
 995 reader.  @code{parse-number} accepts an arbitrary string and attempts to parse
 996 the string into one of the standard Common Lisp number types, if possible, or
 997 else @code{parse-number} signals an error of type @code{invalid-number}.")
 998     (license license:bsd-3)))
 999
1000 (define-public cl-parse-number
1001   (sbcl-package->cl-source-package sbcl-parse-number))
1002
1003 (define-public sbcl-iterate
1004   (package
1005     (name "sbcl-iterate")
1006     (version "1.5")
1007     (source
1008      (origin
1009        (method url-fetch)
1010        (uri (string-append "https://common-lisp.net/project/iterate/releases/"
1011                            "iterate-" version ".tar.gz"))
1012        (sha256
1013         (base32
1014          "1lqsbhrkfl0yif46aymvb7l3nb9wdcmj4jyw485blj32jb4famzn"))))
1015     (build-system asdf-build-system/sbcl)
1016     (native-inputs
1017      `(("rt" ,sbcl-rt)))
1018     (home-page "https://common-lisp.net/project/iterate/")
1019     (synopsis "Iteration construct for Common Lisp")
1020     (description "@code{iterate} is an iteration construct for Common Lisp.
1021 It is similar to the @code{CL:LOOP} macro, with these distinguishing marks:
1022
1023 @itemize
1024 @item it is extensible,
1025 @item it helps editors like Emacs indent iterate forms by having a more
1026   lisp-like syntax, and
1027 @item it isn't part of the ANSI standard for Common Lisp.
1028 @end itemize\n")
1029     (license license:expat)))
1030
1031 (define-public cl-iterate
1032   (sbcl-package->cl-source-package sbcl-iterate))
1033
1034 (define-public ecl-iterate
1035   (sbcl-package->ecl-package sbcl-iterate))
1036
1037 (define-public sbcl-cl-uglify-js
1038   ;; There have been many bug fixes since the 2010 release.
1039   (let ((commit "429c5e1d844e2f96b44db8fccc92d6e8e28afdd5")
1040         (revision "1"))
1041     (package
1042       (name "sbcl-cl-uglify-js")
1043       (version (string-append "0.1-" revision "." (string-take commit 9)))
1044       (source
1045        (origin
1046          (method git-fetch)
1047          (uri (git-reference
1048                (url "https://github.com/mishoo/cl-uglify-js.git")
1049                (commit commit)))
1050          (file-name (git-file-name name version))
1051          (sha256
1052           (base32
1053            "0k39y3c93jgxpr7gwz7w0d8yknn1fdnxrjhd03057lvk5w8js27a"))))
1054       (build-system asdf-build-system/sbcl)
1055       (inputs
1056        `(("sbcl-parse-js" ,sbcl-parse-js)
1057          ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
1058          ("sbcl-cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)
1059          ("sbcl-parse-number" ,sbcl-parse-number)
1060          ("sbcl-iterate" ,sbcl-iterate)))
1061       (home-page "https://github.com/mishoo/cl-uglify-js")
1062       (synopsis "JavaScript compressor library for Common Lisp")
1063       (description "This is a Common Lisp version of UglifyJS, a JavaScript
1064 compressor.  It works on data produced by @code{parse-js} to generate a
1065 @dfn{minified} version of the code.  Currently it can:
1066
1067 @itemize
1068 @item reduce variable names (usually to single letters)
1069 @item join consecutive @code{var} statements
1070 @item resolve simple binary expressions
1071 @item group most consecutive statements using the @code{sequence} operator (comma)
1072 @item remove unnecessary blocks
1073 @item convert @code{IF} expressions in various ways that result in smaller code
1074 @item remove some unreachable code
1075 @end itemize\n")
1076       (license license:zlib))))
1077
1078 (define-public cl-uglify-js
1079   (sbcl-package->cl-source-package sbcl-cl-uglify-js))
1080
1081 (define-public uglify-js
1082   (package
1083     (inherit sbcl-cl-uglify-js)
1084     (name "uglify-js")
1085     (build-system trivial-build-system)
1086     (arguments
1087      `(#:modules ((guix build utils))
1088        #:builder
1089        (let* ((bin    (string-append (assoc-ref %outputs "out") "/bin/"))
1090               (script (string-append bin "uglify-js")))
1091          (use-modules (guix build utils))
1092          (mkdir-p bin)
1093          (with-output-to-file script
1094            (lambda _
1095              (format #t "#!~a/bin/sbcl --script
1096  (require :asdf)
1097  (push (truename \"~a/lib/sbcl\") asdf:*central-registry*)"
1098                      (assoc-ref %build-inputs "sbcl")
1099                      (assoc-ref %build-inputs "sbcl-cl-uglify-js"))
1100              ;; FIXME: cannot use progn here because otherwise it fails to
1101              ;; find cl-uglify-js.
1102              (for-each
1103               write
1104               '(;; Quiet, please!
1105                 (let ((*standard-output* (make-broadcast-stream))
1106                       (*error-output* (make-broadcast-stream)))
1107                   (asdf:load-system :cl-uglify-js))
1108                 (let ((file (cadr *posix-argv*)))
1109                   (if file
1110                       (format t "~a"
1111                               (cl-uglify-js:ast-gen-code
1112                                (cl-uglify-js:ast-mangle
1113                                 (cl-uglify-js:ast-squeeze
1114                                  (with-open-file (in file)
1115                                                  (parse-js:parse-js in))))
1116                                :beautify nil))
1117                       (progn
1118                        (format *error-output*
1119                                "Please provide a JavaScript file.~%")
1120                        (sb-ext:exit :code 1))))))))
1121          (chmod script #o755)
1122          #t)))
1123     (inputs
1124      `(("sbcl" ,sbcl)
1125        ("sbcl-cl-uglify-js" ,sbcl-cl-uglify-js)))
1126     (synopsis "JavaScript compressor")))
1127
1128 (define-public sbcl-cl-strings
1129   (let ((revision "1")
1130         (commit "c5c5cbafbf3e6181d03c354d66e41a4f063f00ae"))
1131     (package
1132       (name "sbcl-cl-strings")
1133       (version (git-version "0.0.0" revision commit))
1134       (source
1135        (origin
1136          (method git-fetch)
1137          (uri (git-reference
1138                (url "https://github.com/diogoalexandrefranco/cl-strings")
1139                (commit commit)))
1140          (sha256
1141           (base32
1142            "00754mfaqallj480lwd346nkfb6ra8pa8xcxcylf4baqn604zlmv"))
1143          (file-name (string-append "cl-strings-" version "-checkout"))))
1144       (build-system asdf-build-system/sbcl)
1145       (synopsis "Portable, dependency-free set of utilities to manipulate strings in Common Lisp")
1146       (description
1147        "@command{cl-strings} is a small, portable, dependency-free set of
1148 utilities that make it even easier to manipulate text in Common Lisp.  It has
1149 100% test coverage and works at least on sbcl, ecl, ccl, abcl and clisp.")
1150       (home-page "https://github.com/diogoalexandrefranco/cl-strings")
1151       (license license:expat))))
1152
1153 (define-public cl-strings
1154   (sbcl-package->cl-source-package sbcl-cl-strings))
1155
1156 (define-public ecl-cl-strings
1157   (sbcl-package->ecl-package sbcl-cl-strings))
1158
1159 (define-public sbcl-trivial-features
1160   (package
1161     (name "sbcl-trivial-features")
1162     (version "0.8")
1163     (source
1164      (origin
1165        (method git-fetch)
1166        (uri (git-reference
1167              (url "https://github.com/trivial-features/trivial-features.git")
1168              (commit (string-append "v" version))))
1169        (file-name (git-file-name "trivial-features" version))
1170        (sha256
1171         (base32 "0ccv7dqyrk55xga78i5vzlic7mdwp28in3g1a8fqhlk6626scsq9"))))
1172     (build-system asdf-build-system/sbcl)
1173     (arguments '(#:tests? #f))
1174     (home-page "https://cliki.net/trivial-features")
1175     (synopsis "Ensures consistency of @code{*FEATURES*} in Common Lisp")
1176     (description "Trivial-features ensures that @code{*FEATURES*} is
1177 consistent across multiple Common Lisp implementations.")
1178     (license license:expat)))
1179
1180 (define-public cl-trivial-features
1181   (sbcl-package->cl-source-package sbcl-trivial-features))
1182
1183 (define-public ecl-trivial-features
1184   (sbcl-package->ecl-package sbcl-trivial-features))
1185
1186 (define-public sbcl-hu.dwim.asdf
1187   (package
1188     (name "sbcl-hu.dwim.asdf")
1189     (version "20190521")
1190     (source
1191      (origin
1192        (method url-fetch)
1193        (uri (string-append "http://beta.quicklisp.org/archive/hu.dwim.asdf/"
1194                            "2019-05-21/hu.dwim.asdf-" version "-darcs.tgz"))
1195        (sha256
1196         (base32
1197          "0rsbv71vyszy8w35yjwb5h6zcmknjq223hkzir79y72qdsc6sabn"))))
1198     (build-system asdf-build-system/sbcl)
1199     (home-page "https://hub.darcs.net/hu.dwim/hu.dwim.asdf")
1200     (synopsis "Extensions to ASDF")
1201     (description "Various ASDF extensions such as attached test and
1202 documentation system, explicit development support, etc.")
1203     (license license:public-domain)))
1204
1205 (define-public cl-hu.dwim.asdf
1206   (sbcl-package->cl-source-package sbcl-hu.dwim.asdf))
1207
1208 (define-public ecl-hu.dwim.asdf
1209   (sbcl-package->ecl-package sbcl-hu.dwim.asdf))
1210
1211 (define-public sbcl-hu.dwim.stefil
1212   (let ((commit "ab6d1aa8995878a1b66d745dfd0ba021090bbcf9"))
1213     (package
1214       (name "sbcl-hu.dwim.stefil")
1215       (version (git-version "0.0.0" "1" commit))
1216       (source
1217        (origin
1218          (method git-fetch)
1219          (uri
1220           (git-reference
1221            (url "https://gitlab.common-lisp.net/xcvb/hu.dwim.stefil.git")
1222            (commit commit)))
1223          (sha256
1224           (base32 "1d8yccw65zj3zh46cbi3x6nmn1dwdb76s9d0av035077mvyirqqp"))
1225          (file-name (git-file-name "hu.dwim.stefil" version))))
1226       (build-system asdf-build-system/sbcl)
1227       (native-inputs
1228        `(("asdf:cl-hu.dwim.asdf" ,sbcl-hu.dwim.asdf)))
1229       (inputs
1230        `(("sbcl-alexandria" ,sbcl-alexandria)))
1231       (home-page "https://hub.darcs.net/hu.dwim/hu.dwim.stefil")
1232       (synopsis "Simple test framework")
1233       (description "Stefil is a simple test framework for Common Lisp,
1234 with a focus on interactive development.")
1235       (license license:public-domain))))
1236
1237 (define-public cl-hu.dwim.stefil
1238   (sbcl-package->cl-source-package sbcl-hu.dwim.stefil))
1239
1240 (define-public ecl-hu.dwim.stefil
1241   (sbcl-package->ecl-package sbcl-hu.dwim.stefil))
1242
1243 (define-public sbcl-babel
1244   ;; No release since 2014.
1245   (let ((commit "aeed2d1b76358db48e6b70a64399c05678a6b9ea"))
1246     (package
1247       (name "sbcl-babel")
1248       (version (git-version "0.5.0" "1" commit))
1249       (source
1250        (origin
1251          (method git-fetch)
1252          (uri (git-reference
1253                (url "https://github.com/cl-babel/babel.git")
1254                (commit commit)))
1255          (file-name (git-file-name "babel" version))
1256          (sha256
1257           (base32 "0lkvv4xdpv4cv1y2bqillmabx8sdb2y4l6pbinq6mjh33w2brpvb"))))
1258       (build-system asdf-build-system/sbcl)
1259       (native-inputs
1260        `(("tests:cl-hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
1261       (inputs
1262        `(("sbcl-alexandria" ,sbcl-alexandria)
1263          ("sbcl-trivial-features" ,sbcl-trivial-features)))
1264       (home-page "https://common-lisp.net/project/babel/")
1265       (synopsis "Charset encoding and decoding library")
1266       (description "Babel is a charset encoding and decoding library, not unlike
1267 GNU libiconv, but completely written in Common Lisp.")
1268       (license license:expat))))
1269
1270 (define-public cl-babel
1271   (sbcl-package->cl-source-package sbcl-babel))
1272
1273 (define-public ecl-babel
1274   (sbcl-package->ecl-package sbcl-babel))
1275
1276 (define-public sbcl-cl-yacc
1277   (package
1278     (name "sbcl-cl-yacc")
1279     (version "0.3")
1280     (source
1281      (origin
1282        (method git-fetch)
1283        (uri (git-reference
1284              (url "https://github.com/jech/cl-yacc")
1285              (commit (string-append "cl-yacc-" version))))
1286        (sha256
1287         (base32
1288          "16946pzf8vvadnyfayvj8rbh4zjzw90h0azz2qk1mxrvhh5wklib"))
1289        (file-name (string-append "cl-yacc-" version "-checkout"))))
1290     (build-system asdf-build-system/sbcl)
1291     (arguments
1292      `(#:asd-file "yacc.asd"
1293        #:asd-system-name "yacc"))
1294     (synopsis "LALR(1) parser generator for Common Lisp, similar in spirit to Yacc")
1295     (description
1296      "CL-Yacc is a LALR(1) parser generator for Common Lisp, similar in spirit
1297 to AT&T Yacc, Berkeley Yacc, GNU Bison, Zebu, lalr.cl or lalr.scm.
1298
1299 CL-Yacc uses the algorithm due to Aho and Ullman, which is the one also used
1300 by AT&T Yacc, Berkeley Yacc and Zebu.  It does not use the faster algorithm due
1301 to DeRemer and Pennello, which is used by Bison and lalr.scm (not lalr.cl).")
1302     (home-page "https://www.irif.fr/~jch//software/cl-yacc/")
1303     (license license:expat)))
1304
1305 (define-public cl-yacc
1306   (sbcl-package->cl-source-package sbcl-cl-yacc))
1307
1308 (define-public ecl-cl-yacc
1309   (sbcl-package->ecl-package sbcl-cl-yacc))
1310
1311 (define-public sbcl-jpl-util
1312   (let ((commit "0311ed374e19a49d43318064d729fe3abd9a3b62"))
1313     (package
1314       (name "sbcl-jpl-util")
1315       (version "20151005")
1316       (source
1317        (origin
1318          (method git-fetch)
1319          (uri (git-reference
1320                ;; Quicklisp uses this fork.
1321                (url "https://github.com/hawkir/cl-jpl-util")
1322                (commit commit)))
1323          (file-name
1324           (git-file-name "jpl-util" version))
1325          (sha256
1326           (base32
1327            "0nc0rk9n8grkg3045xsw34whmcmddn2sfrxki4268g7kpgz0d2yz"))))
1328       (build-system asdf-build-system/sbcl)
1329       (synopsis "Collection of Common Lisp utility functions and macros")
1330       (description
1331        "@command{cl-jpl-util} is a collection of Common Lisp utility functions
1332 and macros, primarily for software projects written in CL by the author.")
1333       (home-page "https://www.thoughtcrime.us/software/cl-jpl-util/")
1334       (license license:isc))))
1335
1336 (define-public cl-jpl-util
1337   (sbcl-package->cl-source-package sbcl-jpl-util))
1338
1339 (define-public ecl-jpl-util
1340   (sbcl-package->ecl-package sbcl-jpl-util))
1341
1342 (define-public sbcl-jpl-queues
1343   (package
1344     (name "sbcl-jpl-queues")
1345     (version "0.1")
1346     (source
1347      (origin
1348        (method url-fetch)
1349        (uri (string-append
1350              "http://www.thoughtcrime.us/software/jpl-queues/jpl-queues-"
1351              version
1352              ".tar.gz"))
1353        (sha256
1354         (base32
1355          "1wvvv7j117h9a42qaj1g4fh4mji28xqs7s60rn6d11gk9jl76h96"))))
1356     (build-system asdf-build-system/sbcl)
1357     (inputs
1358      `(("jpl-util" ,sbcl-jpl-util)
1359        ("bordeaux-threads" ,sbcl-bordeaux-threads)))
1360     (arguments
1361      ;; Tests seem to be broken.
1362      `(#:tests? #f))
1363     (synopsis "Common Lisp library implementing a few different kinds of queues")
1364     (description
1365      "A Common Lisp library implementing a few different kinds of queues:
1366
1367 @itemize
1368 @item Bounded and unbounded FIFO queues.
1369 @item Lossy bounded FIFO queues that drop elements when full.
1370 @item Unbounded random-order queues that use less memory than unbounded FIFO queues.
1371 @end itemize
1372
1373 Additionally, a synchronization wrapper is provided to make any queue
1374 conforming to the @command{jpl-queues} API thread-safe for lightweight
1375 multithreading applications.  (See Calispel for a more sophisticated CL
1376 multithreaded message-passing library with timeouts and alternation among
1377 several blockable channels.)")
1378     (home-page "https://www.thoughtcrime.us/software/jpl-queues/")
1379     (license license:isc)))
1380
1381 (define-public cl-jpl-queues
1382   (sbcl-package->cl-source-package sbcl-jpl-queues))
1383
1384 (define-public ecl-jpl-queues
1385   (sbcl-package->ecl-package sbcl-jpl-queues))
1386
1387 (define-public sbcl-eos
1388   (let ((commit "b0faca83781ead9a588661e37bd47f90362ccd94"))
1389     (package
1390       (name "sbcl-eos")
1391       (version (git-version "0.0.0" "1" commit))
1392       (source
1393        (origin
1394          (method git-fetch)
1395          (uri (git-reference
1396                (url "https://github.com/adlai/Eos")
1397                (commit commit)))
1398          (sha256
1399           (base32
1400            "1bq8cfg087iyxmxi1mwgx5cfgy3b8ydrf81xljcis8qbgb2vszph"))
1401          (file-name (git-file-name "eos" version))))
1402       (build-system asdf-build-system/sbcl)
1403       (synopsis "Unit Testing for Common Lisp")
1404       (description
1405        "Eos was a unit testing library for Common Lisp.
1406 It began as a fork of FiveAM; however, FiveAM development has continued, while
1407 that of Eos has not.  Thus, Eos is now deprecated in favor of FiveAM.")
1408       (home-page "https://github.com/adlai/Eos")
1409       (license license:expat))))
1410
1411 (define-public cl-eos
1412   (sbcl-package->cl-source-package sbcl-eos))
1413
1414 (define-public ecl-eos
1415   (sbcl-package->ecl-package sbcl-eos))
1416
1417 (define-public sbcl-esrap
1418   (let ((commit "133be8b05c2aae48696fe5b739eea2fa573fa48d"))
1419     (package
1420       (name "sbcl-esrap")
1421       (version (git-version "0.0.0" "1" commit))
1422       (source
1423        (origin
1424          (method git-fetch)
1425          (uri (git-reference
1426                (url "https://github.com/nikodemus/esrap")
1427                (commit commit)))
1428          (sha256
1429           (base32
1430            "02d5clihsdryhf7pix8c5di2571fdsffh75d40fkzhws90r5mksl"))
1431          (file-name (git-file-name "esrap" version))))
1432       (build-system asdf-build-system/sbcl)
1433       (native-inputs
1434        `(("eos" ,sbcl-eos)))            ;For testing only.
1435       (inputs
1436        `(("alexandria" ,sbcl-alexandria)))
1437       (synopsis "Common Lisp packrat parser")
1438       (description
1439        "A packrat parser for Common Lisp.
1440 In addition to regular Packrat / Parsing Grammar / TDPL features ESRAP supports:
1441
1442 @itemize
1443 @item dynamic redefinition of nonterminals
1444 @item inline grammars
1445 @item semantic predicates
1446 @item introspective facilities (describing grammars, tracing, setting breaks)
1447 @end itemize\n")
1448       (home-page "https://nikodemus.github.io/esrap/")
1449       (license license:expat))))
1450
1451 (define-public cl-esrap
1452   (sbcl-package->cl-source-package sbcl-esrap))
1453
1454 (define-public ecl-esrap
1455   (sbcl-package->ecl-package sbcl-esrap))
1456
1457 (define-public sbcl-split-sequence
1458   (package
1459     (name "sbcl-split-sequence")
1460     (version "2.0.0")
1461     (source
1462      (origin
1463        (method git-fetch)
1464        (uri (git-reference
1465              (url "https://github.com/sharplispers/split-sequence")
1466              (commit (string-append "v" version))))
1467        (sha256
1468         (base32
1469          "0jcpnx21hkfwqj5fvp7kc6pn1qcz9hk7g2s5x8h0349x1j2irln0"))
1470        (file-name (git-file-name "split-sequence" version))))
1471     (build-system asdf-build-system/sbcl)
1472     (native-inputs
1473      `(("fiveam" ,sbcl-fiveam)))
1474     (synopsis "Member of the Common Lisp Utilities family of programs")
1475     (description
1476      "Splits sequence into a list of subsequences delimited by objects
1477 satisfying the test.")
1478     (home-page "https://cliki.net/split-sequence")
1479     (license license:expat)))
1480
1481 (define-public cl-split-sequence
1482   (sbcl-package->cl-source-package sbcl-split-sequence))
1483
1484 (define-public ecl-split-sequence
1485   (sbcl-package->ecl-package sbcl-split-sequence))
1486
1487 (define-public sbcl-html-encode
1488   (package
1489     (name "sbcl-html-encode")
1490     (version "1.2")
1491     (source
1492      (origin
1493        (method url-fetch)
1494        (uri (string-append
1495              "http://beta.quicklisp.org/archive/html-encode/2010-10-06/html-encode-"
1496              version ".tgz"))
1497        (sha256
1498         (base32
1499          "06mf8wn95yf5swhmzk4vp0xr4ylfl33dgfknkabbkd8n6jns8gcf"))
1500        (file-name (string-append "colorize" version "-checkout"))))
1501     (build-system asdf-build-system/sbcl)
1502     (synopsis "Common Lisp library for encoding text in various web-savvy encodings")
1503     (description
1504      "A library for encoding text in various web-savvy encodings.")
1505     (home-page "http://quickdocs.org/html-encode/")
1506     (license license:expat)))
1507
1508 (define-public cl-html-encode
1509   (sbcl-package->cl-source-package sbcl-html-encode))
1510
1511 (define-public ecl-html-encode
1512   (sbcl-package->ecl-package sbcl-html-encode))
1513
1514 (define-public sbcl-colorize
1515   (let ((commit "ea676b584e0899cec82f21a9e6871172fe3c0eb5"))
1516     (package
1517       (name "sbcl-colorize")
1518       (version (git-version "0.0.0" "1" commit))
1519       (source
1520        (origin
1521          (method git-fetch)
1522          (uri (git-reference
1523                (url "https://github.com/kingcons/colorize")
1524                (commit commit)))
1525          (sha256
1526           (base32
1527            "1pdg4kiaczmr3ivffhirp7m3lbr1q27rn7dhaay0vwghmi31zcw9"))
1528          (file-name (git-file-name "colorize" version))))
1529       (build-system asdf-build-system/sbcl)
1530       (inputs
1531        `(("alexandria" ,sbcl-alexandria)
1532          ("split-sequence" ,sbcl-split-sequence)
1533          ("html-encode" ,sbcl-html-encode)))
1534       (synopsis "Common Lisp for syntax highlighting")
1535       (description
1536        "@command{colorize} is a Lisp library for syntax highlighting
1537 supporting the following languages: Common Lisp, Emacs Lisp, Scheme, Clojure,
1538 C, C++, Java, Python, Erlang, Haskell, Objective-C, Diff, Webkit.")
1539       (home-page "https://github.com/kingcons/colorize")
1540       ;; TODO: Missing license?
1541       (license license:expat))))
1542
1543 (define-public cl-colorize
1544   (sbcl-package->cl-source-package sbcl-colorize))
1545
1546 (define-public ecl-colorize
1547   (sbcl-package->ecl-package sbcl-colorize))
1548
1549 (define-public sbcl-3bmd
1550   (let ((commit "192ea13435b605a96ef607df51317056914cabbd"))
1551     (package
1552       (name "sbcl-3bmd")
1553       (version (git-version "0.0.0" "1" commit))
1554       (source
1555        (origin
1556          (method git-fetch)
1557          (uri (git-reference
1558                (url "https://github.com/3b/3bmd")
1559                (commit commit)))
1560          (sha256
1561           (base32
1562            "1rgv3gi7wf963ikmmpk132wgn0icddf226gq3bmcnk1fr3v9gf2f"))
1563          (file-name (git-file-name "3bmd" version))))
1564       (build-system asdf-build-system/sbcl)
1565       (arguments
1566        ;; FIXME: We need to specify the name because the build-system thinks
1567        ;; "3" is a version marker.
1568        `(#:asd-system-name "3bmd"))
1569       (inputs
1570        `(("esrap" ,sbcl-esrap)
1571          ("split-sequence" ,sbcl-split-sequence)))
1572       (synopsis "Markdown processor in Command Lisp using esrap parser")
1573       (description
1574        "Common Lisp Markdown -> HTML converter, using @command{esrap} for
1575 parsing, and grammar based on @command{peg-markdown}.")
1576       (home-page "https://github.com/3b/3bmd")
1577       (license license:expat))))
1578
1579 (define-public cl-3bmd
1580   (sbcl-package->cl-source-package sbcl-3bmd))
1581
1582 (define-public ecl-3bmd
1583   (sbcl-package->ecl-package sbcl-3bmd))
1584
1585 (define-public sbcl-3bmd-ext-code-blocks
1586   (let ((commit "192ea13435b605a96ef607df51317056914cabbd"))
1587     (package
1588       (inherit sbcl-3bmd)
1589       (name "sbcl-3bmd-ext-code-blocks")
1590       (arguments
1591        `(#:asd-system-name "3bmd-ext-code-blocks"
1592          #:asd-file "3bmd-ext-code-blocks.asd"))
1593       (inputs
1594        `(("3bmd" ,sbcl-3bmd)
1595          ("colorize" ,sbcl-colorize)))
1596       (synopsis "3bmd extension which adds support for GitHub-style fenced
1597 code blocks")
1598       (description
1599        "3bmd extension which adds support for GitHub-style fenced code blocks,
1600 with @command{colorize} support."))))
1601
1602 (define-public cl-3bmd-ext-code-blocks
1603   (sbcl-package->cl-source-package sbcl-3bmd-ext-code-blocks))
1604
1605 (define-public ecl-3bmd-ext-code-blocks
1606   (sbcl-package->ecl-package sbcl-3bmd-ext-code-blocks))
1607
1608 (define-public sbcl-cl-fad
1609   (package
1610     (name "sbcl-cl-fad")
1611     (version "0.7.6")
1612     (source
1613      (origin
1614        (method git-fetch)
1615        (uri (git-reference
1616              (url "https://github.com/edicl/cl-fad/")
1617              (commit (string-append "v" version))))
1618        (sha256
1619         (base32
1620          "1gc8i82v6gks7g0lnm54r4prk2mklidv2flm5fvbr0a7rsys0vpa"))
1621        (file-name (string-append "cl-fad" version "-checkout"))))
1622     (build-system asdf-build-system/sbcl)
1623     (inputs
1624      `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
1625     (synopsis "Portable pathname library for Common Lisp")
1626     (description
1627      "CL-FAD (for \"Files and Directories\") is a thin layer atop Common
1628 Lisp's standard pathname functions.  It is intended to provide some
1629 unification between current CL implementations on Windows, OS X, Linux, and
1630 Unix.  Most of the code was written by Peter Seibel for his book Practical
1631 Common Lisp.")
1632     (home-page "https://edicl.github.io/cl-fad/")
1633     (license license:bsd-2)))
1634
1635 (define-public cl-fad
1636   (sbcl-package->cl-source-package sbcl-cl-fad))
1637
1638 (define-public ecl-cl-fad
1639   (sbcl-package->ecl-package sbcl-cl-fad))
1640
1641 (define-public sbcl-rt
1642   (let ((commit "a6a7503a0b47953bc7579c90f02a6dba1f6e4c5a")
1643         (revision "1"))
1644     (package
1645       (name "sbcl-rt")
1646       (version (git-version "1990.12.19" revision commit))
1647       (source
1648        (origin
1649          (method git-fetch)
1650          (uri (git-reference
1651                (url "http://git.kpe.io/rt.git")
1652                (commit commit)))
1653          (file-name (git-file-name name version))
1654          (sha256
1655           (base32 "13si2rrxaagbr0bkvg6sqicxxpyshabx6ad6byc9n2ik5ysna69b"))))
1656       (build-system asdf-build-system/sbcl)
1657       (synopsis "MIT Regression Tester")
1658       (description
1659        "RT provides a framework for writing regression test suites.")
1660       (home-page "https://www.cliki.net/rt")
1661       (license license:expat))))
1662
1663 (define-public cl-rt
1664   (sbcl-package->cl-source-package sbcl-rt))
1665
1666 (define-public ecl-rt
1667   (sbcl-package->ecl-package sbcl-rt))
1668
1669 (define-public sbcl-nibbles
1670   (package
1671     (name "sbcl-nibbles")
1672     (version "0.14")
1673     (source
1674      (origin
1675        (method git-fetch)
1676        (uri (git-reference
1677              (url "https://github.com/sharplispers/nibbles/")
1678              (commit (string-append "v" version))))
1679        (sha256
1680         (base32
1681          "1v7qfgpvdr6nz7v63dj69d26dis0kff3rd8xamr1llfdvza2pm8f"))
1682        (file-name (git-file-name "nibbles" version))))
1683     (build-system asdf-build-system/sbcl)
1684     (native-inputs
1685      ;; Tests only.
1686      `(("rt" ,sbcl-rt)))
1687     (synopsis "Common Lisp library for accessing octet-addressed blocks of data")
1688     (description
1689      "When dealing with network protocols and file formats, it's common to
1690 have to read or write 16-, 32-, or 64-bit datatypes in signed or unsigned
1691 flavors.  Common Lisp sort of supports this by specifying :element-type for
1692 streams, but that facility is underspecified and there's nothing similar for
1693 read/write from octet vectors.  What most people wind up doing is rolling their
1694 own small facility for their particular needs and calling it a day.
1695
1696 This library attempts to be comprehensive and centralize such
1697 facilities.  Functions to read 16-, 32-, and 64-bit quantities from octet
1698 vectors in signed or unsigned flavors are provided; these functions are also
1699 SETFable.  Since it's sometimes desirable to read/write directly from streams,
1700 functions for doing so are also provided.  On some implementations,
1701 reading/writing IEEE singles/doubles (i.e. single-float and double-float) will
1702 also be supported.")
1703     (home-page "https://github.com/sharplispers/nibbles")
1704     (license license:bsd-3)))
1705
1706 (define-public cl-nibbles
1707   (sbcl-package->cl-source-package sbcl-nibbles))
1708
1709 (define-public ecl-nibbles
1710   (sbcl-package->ecl-package sbcl-nibbles))
1711
1712 (define-public sbcl-ironclad
1713   (package
1714     (name "sbcl-ironclad")
1715     (version "0.49")
1716     (source
1717      (origin
1718        (method git-fetch)
1719        (uri (git-reference
1720              (url "https://github.com/sharplispers/ironclad/")
1721              (commit (string-append "v" version))))
1722        (sha256
1723         (base32 "0kbzqg2aasrhjwy3nrzy2ddy809n1j045w4qkyc3r2syqd203d4q"))
1724        (file-name (git-file-name name version))))
1725     (build-system asdf-build-system/sbcl)
1726     (native-inputs
1727      ;; Tests only.
1728      `(("rt" ,sbcl-rt)))
1729     (inputs
1730      `(("bordeaux-threads" ,sbcl-bordeaux-threads)
1731        ("flexi-streams" ,sbcl-flexi-streams)
1732        ("trivial-garbage" ,sbcl-trivial-garbage)))
1733     (synopsis "Cryptographic toolkit written in Common Lisp")
1734     (description
1735      "Ironclad is a cryptography library written entirely in Common Lisp.
1736 It includes support for several popular ciphers, digests, MACs and public key
1737 cryptography algorithms.  For several implementations that support Gray
1738 streams, support is included for convenient stream wrappers.")
1739     (home-page "https://github.com/sharplispers/ironclad")
1740     (license license:bsd-3)))
1741
1742 (define-public cl-ironclad
1743   (sbcl-package->cl-source-package sbcl-ironclad))
1744
1745 (define-public ecl-ironclad
1746   (sbcl-package->ecl-package sbcl-ironclad))
1747
1748 (define-public sbcl-named-readtables
1749   (let ((commit "64bd53f37a1694cfde48fc38b8f03901f6f0c05b")
1750         (revision "2"))
1751     (package
1752       (name "sbcl-named-readtables")
1753       (version (git-version "0.9" revision commit))
1754       (source
1755        (origin
1756          (method git-fetch)
1757          (uri (git-reference
1758                (url "https://github.com/melisgl/named-readtables.git")
1759                (commit commit)))
1760          (sha256
1761           (base32 "01l4831m7k84qvhzyx0qgdl50isr4zmp40qf6dfq2iqcaj8y4h3n"))
1762          (file-name (git-file-name "named-readtables" version))))
1763       (build-system asdf-build-system/sbcl)
1764       (arguments
1765        ;; Tests seem to be broken.
1766        `(#:tests? #f))
1767       (home-page "https://github.com/melisgl/named-readtables/")
1768       (synopsis "Library that creates a namespace for named readtables")
1769       (description "Named readtables is a library that creates a namespace for
1770 named readtables, which is akin to package namespacing in Common Lisp.")
1771       (license license:bsd-3))))
1772
1773 (define-public cl-named-readtables
1774   (sbcl-package->cl-source-package sbcl-named-readtables))
1775
1776 (define-public ecl-named-readtables
1777   (sbcl-package->ecl-package sbcl-named-readtables))
1778
1779 (define-public sbcl-pythonic-string-reader
1780   (let ((commit "47a70ba1e32362e03dad6ef8e6f36180b560f86a"))
1781     (package
1782       (name "sbcl-pythonic-string-reader")
1783       (version (git-version "0.0.0" "1" commit))
1784       (source
1785        (origin
1786          (method git-fetch)
1787          (uri (git-reference
1788                (url "https://github.com/smithzvk/pythonic-string-reader/")
1789                (commit commit)))
1790          (sha256
1791           (base32 "1b5iryqw8xsh36swckmz8rrngmc39k92si33fgy5pml3n9l5rq3j"))
1792          (file-name (git-file-name "pythonic-string-reader" version))))
1793       (build-system asdf-build-system/sbcl)
1794       (inputs
1795        `(("named-readtables" ,sbcl-named-readtables)))
1796       (home-page "https://github.com/smithzvk/pythonic-string-reader")
1797       (synopsis "Read table modification inspired by Python's three quote strings")
1798       (description "This piece of code sets up some reader macros that make it
1799 simpler to input string literals which contain backslashes and double quotes
1800 This is very useful for writing complicated docstrings and, as it turns out,
1801 writing code that contains string literals that contain code themselves.")
1802       (license license:bsd-3))))
1803
1804 (define-public cl-pythonic-string-reader
1805   (sbcl-package->cl-source-package sbcl-pythonic-string-reader))
1806
1807 (define-public ecl-pythonic-string-reader
1808   (sbcl-package->ecl-package sbcl-pythonic-string-reader))
1809
1810 ;; SLIME does not have a ASDF system definition to build all of Swank.  As a
1811 ;; result, the asdf-build-system/sbcl will produce an almost empty package.
1812 ;; Some work was done to fix this at
1813 ;; https://github.com/sionescu/slime/tree/swank-asdf but it was never merged
1814 ;; and is now lagging behind.  Building SBCL fasls might not be worth the
1815 ;; hassle, so let's just ship the source then.
1816 (define-public cl-slime-swank
1817   (package
1818     (name "cl-slime-swank")
1819     (version "2.24")
1820     (source
1821      (origin
1822        (file-name (string-append name "-" version ".tar.gz"))
1823        (method git-fetch)
1824        (uri (git-reference
1825              (url "https://github.com/slime/slime/")
1826              (commit (string-append "v" version))))
1827        (sha256
1828         (base32
1829          "0js24x42m7b5iymb4rxz501dff19vav5pywnzv50b673rbkaaqvh"))))
1830     (build-system asdf-build-system/source)
1831     (home-page "https://github.com/slime/slime")
1832     (synopsis "Common Lisp Swank server")
1833     (description
1834      "This is only useful if you want to start a Swank server in a Lisp
1835 processes that doesn't run under Emacs.  Lisp processes created by
1836 @command{M-x slime} automatically start the server.")
1837     (license (list license:gpl2+ license:public-domain))))
1838
1839 (define-public sbcl-slime-swank
1840   (deprecated-package "sbcl-slime-swank" cl-slime-swank))
1841
1842 (define-public sbcl-mgl-pax
1843   (let ((commit "818448418d6b9de74620f606f5b23033c6082769"))
1844     (package
1845       (name "sbcl-mgl-pax")
1846       (version (git-version "0.0.0" "1" commit))
1847       (source
1848        (origin
1849          (method git-fetch)
1850          (uri (git-reference
1851                (url "https://github.com/melisgl/mgl-pax")
1852                (commit commit)))
1853          (sha256
1854           (base32
1855            "1p97zfkh130bdxqqxwaw2j9psv58751wakx7czbfpq410lg7dd7i"))
1856          (file-name (git-file-name "mgl-pax" version))))
1857       (build-system asdf-build-system/sbcl)
1858       (inputs
1859        `(("3bmd" ,sbcl-3bmd)
1860          ("3bmd-ext-code-blocks" ,sbcl-3bmd-ext-code-blocks)
1861          ("babel" ,sbcl-babel)
1862          ("cl-fad" ,sbcl-cl-fad)
1863          ("ironclad" ,sbcl-ironclad)
1864          ("named-readtables" ,sbcl-named-readtables)
1865          ("pythonic-string-reader" ,sbcl-pythonic-string-reader)))
1866       (propagated-inputs
1867        ;; Packages having mgl-pax as input complain that it can't find
1868        ;; swank if we put it in inputs, so let's put it in propageted-inputs.
1869        `(("swank" ,cl-slime-swank)))
1870       (synopsis "Exploratory programming environment and documentation generator")
1871       (description
1872        "PAX provides an extremely poor man's Explorable Programming
1873 environment.  Narrative primarily lives in so called sections that mix markdown
1874 docstrings with references to functions, variables, etc, all of which should
1875 probably have their own docstrings.
1876
1877 The primary focus is on making code easily explorable by using SLIME's
1878 @command{M-.} (@command{slime-edit-definition}).  See how to enable some
1879 fanciness in Emacs Integration.  Generating documentation from sections and all
1880 the referenced items in Markdown or HTML format is also implemented.
1881
1882 With the simplistic tools provided, one may accomplish similar effects as with
1883 Literate Programming, but documentation is generated from code, not vice versa
1884 and there is no support for chunking yet.  Code is first, code must look
1885 pretty, documentation is code.")
1886       (home-page "http://quotenil.com/")
1887       (license license:expat))))
1888
1889 (define-public cl-mgl-pax
1890   (sbcl-package->cl-source-package sbcl-mgl-pax))
1891
1892 (define-public ecl-mgl-pax
1893   (sbcl-package->ecl-package sbcl-mgl-pax))
1894
1895 (define-public sbcl-lisp-unit
1896   (let ((commit "89653a232626b67400bf9a941f9b367da38d3815"))
1897     (package
1898       (name "sbcl-lisp-unit")
1899       (version (git-version "0.0.0" "1" commit))
1900       (source
1901        (origin
1902          (method git-fetch)
1903          (uri (git-reference
1904                (url "https://github.com/OdonataResearchLLC/lisp-unit")
1905                (commit commit)))
1906          (sha256
1907           (base32
1908            "0p6gdmgr7p383nvd66c9y9fp2bjk4jx1lpa5p09g43hr9y9pp9ry"))
1909          (file-name (git-file-name "lisp-unit" version))))
1910       (build-system asdf-build-system/sbcl)
1911       (synopsis "Common Lisp Test framework inspired by JUnit to be simple of use")
1912       (description
1913        "@command{lisp-unit} is a Common Lisp library that supports unit
1914 testing.  It is an extension of the library written by Chris Riesbeck.")
1915       (home-page "https://github.com/OdonataResearchLLC/lisp-unit")
1916       (license license:expat))))
1917
1918 (define-public cl-lisp-unit
1919   (sbcl-package->cl-source-package sbcl-lisp-unit))
1920
1921 (define-public ecl-lisp-unit
1922   (sbcl-package->ecl-package sbcl-lisp-unit))
1923
1924 (define-public sbcl-anaphora
1925   (package
1926     (name "sbcl-anaphora")
1927     (version "0.9.6")
1928     (source
1929      (origin
1930        (method git-fetch)
1931        (uri (git-reference
1932              (url "https://github.com/tokenrove/anaphora")
1933              (commit version)))
1934        (sha256
1935         (base32
1936          "19wfrk3asimznkli0x2rfy637hwpdgqyvwj3vhq9x7vjvyf5vv6x"))
1937        (file-name (git-file-name "anaphora" version))))
1938     (build-system asdf-build-system/sbcl)
1939     (native-inputs
1940      `(("rt" ,sbcl-rt)))
1941     (synopsis "The anaphoric macro collection from Hell")
1942     (description
1943      "Anaphora is the anaphoric macro collection from Hell: it includes many
1944 new fiends in addition to old friends like @command{aif} and
1945 @command{awhen}.")
1946     (home-page "https://github.com/tokenrove/anaphora")
1947     (license license:public-domain)))
1948
1949 (define-public cl-anaphora
1950   (sbcl-package->cl-source-package sbcl-anaphora))
1951
1952 (define-public ecl-anaphora
1953   (sbcl-package->ecl-package sbcl-anaphora))
1954
1955 (define-public sbcl-lift
1956   (let ((commit "7d49a66c62759535624037826891152223d4206c"))
1957     (package
1958       (name "sbcl-lift")
1959       (version (git-version "1.7.1" "1" commit))
1960       (source
1961        (origin
1962          (method git-fetch)
1963          (uri (git-reference
1964                (url "https://github.com/gwkkwg/lift")
1965                (commit commit)))
1966          (sha256
1967           (base32
1968            "127v5avpz1i4m0lkaxqrq8hrl69rdazqaxf6s8awf0nd7wj2g4dp"))
1969          (file-name (git-file-name "lift" version))
1970          (modules '((guix build utils)))
1971          (snippet
1972           ;; Don't keep the bundled website
1973           `(begin
1974              (delete-file-recursively "website")
1975              #t))))
1976       (build-system asdf-build-system/sbcl)
1977       (arguments
1978        ;; The tests require a debugger, but we run with the debugger disabled.
1979        '(#:tests? #f))
1980       (synopsis "LIsp Framework for Testing")
1981       (description
1982        "The LIsp Framework for Testing (LIFT) is a unit and system test tool for LISP.
1983 Though inspired by SUnit and JUnit, it's built with Lisp in mind.  In LIFT,
1984 testcases are organized into hierarchical testsuites each of which can have
1985 its own fixture.  When run, a testcase can succeed, fail, or error.  LIFT
1986 supports randomized testing, benchmarking, profiling, and reporting.")
1987       (home-page "https://github.com/gwkkwg/lift")
1988       (license license:expat))))
1989
1990 (define-public cl-lift
1991   (sbcl-package->cl-source-package sbcl-lift))
1992
1993 (define-public ecl-lift
1994   (sbcl-package->ecl-package sbcl-lift))
1995
1996 (define-public sbcl-let-plus
1997   (let ((commit "5f14af61d501ecead02ec6b5a5c810efc0c9fdbb"))
1998     (package
1999       (name "sbcl-let-plus")
2000       (version (git-version "0.0.0" "1" commit))
2001       (source
2002        (origin
2003          (method git-fetch)
2004          (uri (git-reference
2005                (url "https://github.com/sharplispers/let-plus")
2006                (commit commit)))
2007          (sha256
2008           (base32
2009            "0i050ca2iys9f5mb7dgqgqdxfnc3b0rnjdwv95sqd490vkiwrsaj"))
2010          (file-name (git-file-name "let-plus" version))))
2011       (build-system asdf-build-system/sbcl)
2012       (inputs
2013        `(("alexandria" ,sbcl-alexandria)
2014          ("anaphora" ,sbcl-anaphora)))
2015       (native-inputs
2016        `(("lift" ,sbcl-lift)))
2017       (synopsis "Destructuring extension of let*")
2018       (description
2019        "This library implements the let+ macro, which is a dectructuring
2020 extension of let*.  It features:
2021
2022 @itemize
2023 @item Clean, consistent syntax and small implementation (less than 300 LOC,
2024 not counting tests)
2025 @item Placeholder macros allow editor hints and syntax highlighting
2026 @item @command{&ign} for ignored values (in forms where that makes sense)
2027 @item Very easy to extend
2028 @end itemize\n")
2029       (home-page "https://github.com/sharplispers/let-plus")
2030       (license license:boost1.0))))
2031
2032 (define-public cl-let-plus
2033   (sbcl-package->cl-source-package sbcl-let-plus))
2034
2035 (define-public ecl-let-plus
2036   (sbcl-package->ecl-package sbcl-let-plus))
2037
2038 (define-public sbcl-cl-colors
2039   (let ((commit "827410584553f5c717eec6182343b7605f707f75"))
2040     (package
2041       (name "sbcl-cl-colors")
2042       (version (git-version "0.0.0" "1" commit))
2043       (source
2044        (origin
2045          (method git-fetch)
2046          (uri (git-reference
2047                (url "https://github.com/tpapp/cl-colors")
2048                (commit commit)))
2049          (sha256
2050           (base32
2051            "0l446lday4hybsm9bq3jli97fvv8jb1d33abg79vbylpwjmf3y9a"))
2052          (file-name (git-file-name "cl-colors" version))))
2053       (build-system asdf-build-system/sbcl)
2054       (inputs
2055        `(("alexandria" ,sbcl-alexandria)
2056          ("let-plus" ,sbcl-let-plus)))
2057       (synopsis "Simple color library for Common Lisp")
2058       (description
2059        "This is a very simple color library for Common Lisp, providing
2060
2061 @itemize
2062 @item Types for representing colors in HSV and RGB spaces.
2063 @item Simple conversion functions between the above types (and also
2064 hexadecimal representation for RGB).
2065 @item Some predefined colors (currently X11 color names – of course the
2066 library does not depend on X11).Because color in your terminal is nice.
2067 @end itemize
2068
2069 This library is no longer supported by its author.")
2070       (home-page "https://github.com/tpapp/cl-colors")
2071       (license license:boost1.0))))
2072
2073 (define-public cl-colors
2074   (sbcl-package->cl-source-package sbcl-cl-colors))
2075
2076 (define-public ecl-cl-colors
2077   (sbcl-package->ecl-package sbcl-cl-colors))
2078
2079 (define-public sbcl-cl-ansi-text
2080   (let ((commit "53badf7878f27f22f2d4a2a43e6df458e43acbe9"))
2081     (package
2082       (name "sbcl-cl-ansi-text")
2083       (version (git-version "1.0.0" "1" commit))
2084       (source
2085        (origin
2086          (method git-fetch)
2087          (uri (git-reference
2088                (url "https://github.com/pnathan/cl-ansi-text")
2089                (commit commit)))
2090          (sha256
2091           (base32
2092            "11i27n0dbz5lmygiw65zzr8lx0rac6b6yysqranphn31wls6ja3v"))
2093          (file-name (git-file-name "cl-ansi-text" version))))
2094       (build-system asdf-build-system/sbcl)
2095       (inputs
2096        `(("alexandria" ,sbcl-alexandria)
2097          ("cl-colors" ,sbcl-cl-colors)))
2098       (native-inputs
2099        `(("fiveam" ,sbcl-fiveam)))
2100       (synopsis "ANSI terminal color implementation for Common Lisp")
2101       (description
2102        "@command{cl-ansi-text} provides utilities which enable printing to an
2103 ANSI terminal with colored text.  It provides the macro @command{with-color}
2104 which causes everything printed in the body to be displayed with the provided
2105 color.  It further provides functions which will print the argument with the
2106 named color.")
2107       (home-page "https://github.com/pnathan/cl-ansi-text")
2108       (license license:llgpl))))
2109
2110 (define-public cl-ansi-text
2111   (sbcl-package->cl-source-package sbcl-cl-ansi-text))
2112
2113 (define-public ecl-cl-ansi-text
2114   (sbcl-package->ecl-package sbcl-cl-ansi-text))
2115
2116 (define-public sbcl-prove-asdf
2117   (let ((commit "4f9122bd393e63c5c70c1fba23070622317cfaa0"))
2118     (package
2119       (name "sbcl-prove-asdf")
2120       (version (git-version "1.0.0" "1" commit))
2121       (source
2122        (origin
2123          (method git-fetch)
2124          (uri (git-reference
2125                (url "https://github.com/fukamachi/prove")
2126                (commit commit)))
2127          (sha256
2128           (base32
2129            "07sbfw459z8bbjvx1qlmfa8qk2mvbjnnzi2mi0x72blaj8bkl4vc"))
2130          (file-name (git-file-name "prove" version))))
2131       (build-system asdf-build-system/sbcl)
2132       (arguments
2133        `(#:asd-file "prove-asdf.asd"))
2134       (synopsis "Test requirement for the Common Lisp 'prove' library")
2135       (description
2136        "Test requirement for the Common Lisp @command{prove} library.")
2137       (home-page "https://github.com/fukamachi/prove")
2138       (license license:expat))))
2139
2140 (define-public cl-prove-asdf
2141   (sbcl-package->cl-source-package sbcl-prove-asdf))
2142
2143 (define-public ecl-prove-asdf
2144   (sbcl-package->ecl-package sbcl-prove-asdf))
2145
2146 (define-public sbcl-prove
2147   (package
2148     (inherit sbcl-prove-asdf)
2149     (name "sbcl-prove")
2150     (inputs
2151      `(("alexandria" ,sbcl-alexandria)
2152        ("cl-ppcre" ,sbcl-cl-ppcre)
2153        ("cl-ansi-text" ,sbcl-cl-ansi-text)))
2154     (native-inputs
2155      `(("prove-asdf" ,sbcl-prove-asdf)))
2156     (arguments
2157      `(#:asd-file "prove.asd"))
2158     (synopsis "Yet another unit testing framework for Common Lisp")
2159     (description
2160      "This project was originally called @command{cl-test-more}.
2161 @command{prove} is yet another unit testing framework for Common Lisp.  The
2162 advantages of @command{prove} are:
2163
2164 @itemize
2165 @item Various simple functions for testing and informative error messages
2166 @item ASDF integration
2167 @item Extensible test reporters
2168 @item Colorizes the report if it's available (note for SLIME)
2169 @item Reports test durations
2170 @end itemize\n")))
2171
2172 (define-public cl-prove
2173   (sbcl-package->cl-source-package sbcl-prove))
2174
2175 (define-public ecl-prove
2176   (sbcl-package->ecl-package sbcl-prove))
2177
2178 (define-public sbcl-proc-parse
2179   (let ((commit "ac3636834d561bdc2686c956dbd82494537285fd"))
2180     (package
2181       (name "sbcl-proc-parse")
2182       (version (git-version "0.0.0" "1" commit))
2183       (source
2184        (origin
2185          (method git-fetch)
2186          (uri (git-reference
2187                (url "https://github.com/fukamachi/proc-parse")
2188                (commit commit)))
2189          (sha256
2190           (base32
2191            "06rnl0h4cx6xv2wj3jczmmcxqn2703inmmvg1s4npbghmijsybfh"))
2192          (file-name (git-file-name "proc-parse" version))))
2193       (build-system asdf-build-system/sbcl)
2194       (inputs
2195        `(("alexandria" ,sbcl-alexandria)
2196          ("babel" ,sbcl-babel)))
2197       (native-inputs
2198        `(("prove" ,sbcl-prove)
2199          ("prove-asdf" ,sbcl-prove-asdf)))
2200       (arguments
2201        ;; TODO: Tests don't find "proc-parse-test", why?
2202        `(#:tests? #f))
2203       (synopsis "Procedural vector parser")
2204       (description
2205        "This is a string/octets parser library for Common Lisp with speed and
2206 readability in mind.  Unlike other libraries, the code is not a
2207 pattern-matching-like, but a char-by-char procedural parser.")
2208       (home-page "https://github.com/fukamachi/proc-parse")
2209       (license license:bsd-2))))
2210
2211 (define-public cl-proc-parse
2212   (sbcl-package->cl-source-package sbcl-proc-parse))
2213
2214 (define-public ecl-proc-parse
2215   (sbcl-package->ecl-package sbcl-proc-parse))
2216
2217 (define-public sbcl-parse-float
2218   (let ((commit "2aae569f2a4b2eb3bfb5401a959425dcf151b09c"))
2219     (package
2220       (name "sbcl-parse-float")
2221       (version (git-version "0.0.0" "1" commit))
2222       (source
2223        (origin
2224          (method git-fetch)
2225          (uri (git-reference
2226                (url "https://github.com/soemraws/parse-float")
2227                (commit commit)))
2228          (sha256
2229           (base32
2230            "08xw8cchhmqcc0byng69m3f5a2izc9y2290jzz2k0qrbibp1fdk7"))
2231          (file-name (git-file-name "proc-parse" version))))
2232       (build-system asdf-build-system/sbcl)
2233       (inputs
2234        `(("alexandria" ,sbcl-alexandria)
2235          ("babel" ,sbcl-babel)))
2236       (native-inputs
2237        `(("prove" ,sbcl-prove)
2238          ("prove-asdf" ,sbcl-prove-asdf)))
2239       (arguments
2240        ;; TODO: Tests don't find "proc-parse-test", why?
2241        `(#:tests? #f))
2242       (synopsis "Parse a floating point value from a string in Common Lisp")
2243       (description
2244        "This package exports the following function to parse floating-point
2245 values from a string in Common Lisp.")
2246       (home-page "https://github.com/soemraws/parse-float")
2247       (license license:public-domain))))
2248
2249 (define-public cl-parse-float
2250   (sbcl-package->cl-source-package sbcl-parse-float))
2251
2252 (define-public ecl-parse-float
2253   (sbcl-package->ecl-package sbcl-parse-float))
2254
2255 (define-public sbcl-ascii-strings
2256   (let ((revision "1")
2257         (changeset "5048480a61243e6f1b02884012c8f25cdbee6d97"))
2258     (package
2259       (name "sbcl-ascii-strings")
2260       (version (string-append "0-" revision "." (string-take changeset 7)))
2261       (source
2262        (origin
2263          (method hg-fetch)
2264          (uri (hg-reference
2265                (url "https://bitbucket.org/vityok/cl-string-match/")
2266                (changeset changeset)))
2267          (sha256
2268           (base32
2269            "01wn5qx562w43ssy92xlfgv79w7p0nv0wbl76mpmba131n9ziq2y"))
2270          (file-name (git-file-name "cl-string-match" version))))
2271       (build-system asdf-build-system/sbcl)
2272       (inputs
2273        `(("alexandria" ,sbcl-alexandria)
2274          ("babel" ,sbcl-babel)))
2275       (arguments
2276        `(#:asd-file "ascii-strings.asd"))
2277       (synopsis "Operations on ASCII strings")
2278       (description
2279        "Operations on ASCII strings.  Essentially this can be any kind of
2280 single-byte encoded strings.")
2281       (home-page "https://bitbucket.org/vityok/cl-string-match/")
2282       (license license:bsd-3))))
2283
2284 (define-public cl-ascii-strings
2285   (sbcl-package->cl-source-package sbcl-ascii-strings))
2286
2287 (define-public ecl-ascii-strings
2288   (sbcl-package->ecl-package sbcl-ascii-strings))
2289
2290 (define-public sbcl-simple-scanf
2291   (package
2292     (inherit sbcl-ascii-strings)
2293     (name "sbcl-simple-scanf")
2294     (inputs
2295      `(("alexandria" ,sbcl-alexandria)
2296        ("iterate" ,sbcl-iterate)
2297        ("proc-parse" ,sbcl-proc-parse)
2298        ("parse-float" ,sbcl-parse-float)))
2299     (arguments
2300      `(#:asd-file "simple-scanf.asd"))
2301     (synopsis "Simple scanf-like functionality implementation")
2302     (description
2303      "A simple scanf-like functionality implementation.")))
2304
2305 (define-public cl-simple-scanf
2306   (sbcl-package->cl-source-package sbcl-simple-scanf))
2307
2308 (define-public ecl-simple-scanf
2309   (sbcl-package->ecl-package sbcl-simple-scanf))
2310
2311 (define-public sbcl-cl-string-match
2312   (package
2313     (inherit sbcl-ascii-strings)
2314     (name "sbcl-cl-string-match")
2315     (inputs
2316      `(("alexandria" ,sbcl-alexandria)
2317        ("ascii-strings" ,sbcl-ascii-strings)
2318        ("yacc" ,sbcl-cl-yacc)
2319        ("jpl-util" ,sbcl-jpl-util)
2320        ("jpl-queues" ,sbcl-jpl-queues)
2321        ("mgl-pax" ,sbcl-mgl-pax)
2322        ("iterate" ,sbcl-iterate)))
2323     ;; TODO: Tests are not evaluated properly.
2324     (native-inputs
2325      ;; For testing:
2326      `(("lisp-unit" ,sbcl-lisp-unit)
2327        ("simple-scanf" ,sbcl-simple-scanf)))
2328     (arguments
2329      `(#:tests? #f
2330        #:asd-file "cl-string-match.asd"))
2331     (synopsis "Portable, dependency-free set of utilities to manipulate strings in Common Lisp")
2332     (description
2333      "@command{cl-strings} is a small, portable, dependency-free set of
2334 utilities that make it even easier to manipulate text in Common Lisp.  It has
2335 100% test coverage and works at least on sbcl, ecl, ccl, abcl and clisp.")))
2336
2337 (define-public cl-string-match
2338   (sbcl-package->cl-source-package sbcl-cl-string-match))
2339
2340 (define-public ecl-cl-string-match
2341   (sbcl-package->ecl-package sbcl-cl-string-match))
2342
2343 (define-public sbcl-ptester
2344   (let ((commit "fe69fde54f4bce00ce577feb918796c293fc7253")
2345         (revision "1"))
2346     (package
2347       (name "sbcl-ptester")
2348       (version (git-version "2.1.3" revision commit))
2349       (source
2350        (origin
2351          (method git-fetch)
2352          (uri (git-reference
2353                (url "http://git.kpe.io/ptester.git")
2354                (commit commit)))
2355          (file-name (git-file-name name version))
2356          (sha256
2357           (base32 "1l0lfl7cdnr2qf4zh38hi4llxg22c49zkm639bdkmvlkzwj3ndwf"))))
2358       (build-system asdf-build-system/sbcl)
2359       (home-page "http://quickdocs.org/ptester/")
2360       (synopsis "Portable test harness package")
2361       (description
2362        "@command{ptester} is a portable testing framework based on Franz's
2363 tester module.")
2364       (license license:llgpl))))
2365
2366 (define-public cl-ptester
2367   (sbcl-package->cl-source-package sbcl-ptester))
2368
2369 (define-public ecl-ptester
2370   (sbcl-package->ecl-package sbcl-ptester))
2371
2372 (define-public sbcl-puri
2373   (let ((commit "ef5afb9e5286c8e952d4344f019c1a636a717b97")
2374         (revision "1"))
2375     (package
2376       (name "sbcl-puri")
2377       (version (git-version "1.5.7" revision commit))
2378       (source
2379        (origin
2380          (method git-fetch)
2381          (uri (git-reference
2382                (url "http://git.kpe.io/puri.git")
2383                (commit commit)))
2384          (file-name (git-file-name name version))
2385          (sha256
2386           (base32 "1vm25pdl92laj72p5vyd538kf3cjy2655z6bdc99h20ana2p231s"))))
2387       (build-system asdf-build-system/sbcl)
2388       (native-inputs
2389        `(("ptester" ,sbcl-ptester)))
2390       (home-page "http://quickdocs.org/puri/")
2391       (synopsis "Portable URI Library")
2392       (description
2393        "This is a portable Universal Resource Identifier library for Common
2394 Lisp programs.  It parses URI according to the RFC 2396 specification.")
2395       (license license:llgpl))))
2396
2397 (define-public cl-puri
2398   (sbcl-package->cl-source-package sbcl-puri))
2399
2400 (define-public ecl-puri
2401   (sbcl-package->ecl-package sbcl-puri))
2402
2403 (define-public sbcl-queues
2404   (let ((commit "47d4da65e9ea20953b74aeeab7e89a831b66bc94"))
2405     (package
2406       (name "sbcl-queues")
2407       (version (git-version "0.0.0" "1" commit))
2408       (source
2409        (origin
2410          (method git-fetch)
2411          (uri (git-reference
2412                (url "https://github.com/oconnore/queues")
2413                (commit commit)))
2414          (file-name (git-file-name "queues" version))
2415          (sha256
2416           (base32
2417            "0wdhfnzi4v6d97pggzj2aw55si94w4327br94jrmyvwf351wqjvv"))))
2418       (build-system asdf-build-system/sbcl)
2419       (home-page "https://github.com/oconnore/queues")
2420       (synopsis "Common Lisp queue library")
2421       (description
2422        "This is a simple queue library for Common Lisp with features such as
2423 non-consing thread safe queues and fibonacci priority queues.")
2424       (license license:expat))))
2425
2426 (define-public cl-queues
2427   (sbcl-package->cl-source-package sbcl-queues))
2428
2429 (define-public ecl-queues
2430   (sbcl-package->ecl-package sbcl-queues))
2431
2432 (define-public sbcl-queues.simple-queue
2433   (package
2434     (inherit sbcl-queues)
2435     (name "sbcl-queues.simple-queue")
2436     (inputs
2437      `(("sbcl-queues" ,sbcl-queues)))
2438     (arguments
2439      `(#:asd-file "queues.simple-queue.asd"))
2440     (synopsis "Simple queue implementation")
2441     (description
2442      "This is a simple queue library for Common Lisp with features such as
2443 non-consing thread safe queues and fibonacci priority queues.")
2444     (license license:expat)))
2445
2446 (define-public cl-queues.simple-queue
2447   (sbcl-package->cl-source-package sbcl-queues.simple-queue))
2448
2449 (define-public ecl-queues.simple-queue
2450   (sbcl-package->ecl-package sbcl-queues.simple-queue))
2451
2452 (define-public sbcl-queues.simple-cqueue
2453   (package
2454     (inherit sbcl-queues)
2455     (name "sbcl-queues.simple-cqueue")
2456     (inputs
2457      `(("sbcl-queues" ,sbcl-queues)
2458        ("sbcl-queues.simple-queue" ,sbcl-queues.simple-queue)
2459        ("bordeaux-threads" ,sbcl-bordeaux-threads)))
2460     (arguments
2461      `(#:asd-file "queues.simple-cqueue.asd"))
2462     (synopsis "Thread safe queue implementation")
2463     (description
2464      "This is a simple queue library for Common Lisp with features such as
2465 non-consing thread safe queues and fibonacci priority queues.")
2466     (license license:expat)))
2467
2468 (define-public cl-queues.simple-cqueue
2469   (sbcl-package->cl-source-package sbcl-queues.simple-cqueue))
2470
2471 (define-public ecl-queues.simple-cqueue
2472   (sbcl-package->ecl-package sbcl-queues.simple-cqueue))
2473
2474 (define-public sbcl-queues.priority-queue
2475   (package
2476     (inherit sbcl-queues)
2477     (name "sbcl-queues.priority-queue")
2478     (inputs
2479      `(("sbcl-queues" ,sbcl-queues)))
2480     (arguments
2481      `(#:asd-file "queues.priority-queue.asd"))
2482     (synopsis "Priority queue (Fibonacci) implementation")
2483     (description
2484      "This is a simple queue library for Common Lisp with features such as
2485 non-consing thread safe queues and fibonacci priority queues.")
2486     (license license:expat)))
2487
2488 (define-public cl-queues.priority-queue
2489   (sbcl-package->cl-source-package sbcl-queues.priority-queue))
2490
2491 (define-public ecl-queues.priority-queue
2492   (sbcl-package->ecl-package sbcl-queues.priority-queue))
2493
2494 (define-public sbcl-queues.priority-cqueue
2495   (package
2496     (inherit sbcl-queues)
2497     (name "sbcl-queues.priority-cqueue")
2498     (inputs
2499      `(("sbcl-queues" ,sbcl-queues)
2500        ("sbcl-queues.priority-queue" ,sbcl-queues.priority-queue)
2501        ("bordeaux-threads" ,sbcl-bordeaux-threads)))
2502     (arguments
2503      `(#:asd-file "queues.priority-cqueue.asd"))
2504     (synopsis "Thread safe fibonacci priority queue implementation")
2505     (description
2506      "This is a simple queue library for Common Lisp with features such as
2507 non-consing thread safe queues and fibonacci priority queues.")
2508     (license license:expat)))
2509
2510 (define-public cl-queues.priority-cqueue
2511   (sbcl-package->cl-source-package sbcl-queues.priority-cqueue))
2512
2513 (define-public ecl-queues.priority-cqueue
2514   (sbcl-package->ecl-package sbcl-queues.priority-cqueue))
2515
2516 (define sbcl-cffi-bootstrap
2517   (package
2518     (name "sbcl-cffi-bootstrap")
2519     (version "0.21.0")
2520     (source
2521      (origin
2522        (method git-fetch)
2523        (uri (git-reference
2524              (url "https://github.com/cffi/cffi.git")
2525              (commit (string-append "v" version))))
2526        (file-name (git-file-name "cffi-bootstrap" version))
2527        (sha256
2528         (base32 "1qalargz9bhp850qv60ffwpdqi4xirzar4l3g6qcg8yc6xqf2cjk"))))
2529     (build-system asdf-build-system/sbcl)
2530     (inputs
2531      `(("libffi" ,libffi)
2532        ("alexandria" ,sbcl-alexandria)
2533        ("babel" ,sbcl-babel)
2534        ("trivial-features" ,sbcl-trivial-features)))
2535     (native-inputs
2536      `(("pkg-config" ,pkg-config)))
2537     (arguments
2538      '(#:phases
2539        (modify-phases %standard-phases
2540          (add-after 'unpack 'fix-paths
2541            (lambda* (#:key inputs #:allow-other-keys)
2542              (substitute* "libffi/libffi.lisp"
2543                (("libffi.so.6" all) (string-append
2544                                      (assoc-ref inputs "libffi")
2545                                      "/lib/" all)))
2546              (substitute* "toolchain/c-toolchain.lisp"
2547                (("\"cc\"") (format #f "~S" (which "gcc")))))))
2548        #:asd-system-name "cffi"
2549        #:tests? #f))
2550     (home-page "https://common-lisp.net/project/cffi/")
2551     (synopsis "Common Foreign Function Interface for Common Lisp")
2552     (description "The Common Foreign Function Interface (CFFI)
2553 purports to be a portable foreign function interface for Common Lisp.
2554 The CFFI library is composed of a Lisp-implementation-specific backend
2555 in the CFFI-SYS package, and a portable frontend in the CFFI
2556 package.")
2557     (license license:expat)))
2558
2559 (define-public sbcl-cffi-toolchain
2560   (package
2561     (inherit sbcl-cffi-bootstrap)
2562     (name "sbcl-cffi-toolchain")
2563     (inputs
2564      `(("libffi" ,libffi)
2565        ("sbcl-cffi" ,sbcl-cffi-bootstrap)))
2566     (arguments
2567      (substitute-keyword-arguments (package-arguments sbcl-cffi-bootstrap)
2568        ((#:asd-system-name _) #f)
2569        ((#:tests? _) #t)))))
2570
2571 (define-public sbcl-cffi-libffi
2572   (package
2573     (inherit sbcl-cffi-toolchain)
2574     (name "sbcl-cffi-libffi")
2575     (inputs
2576      `(("cffi" ,sbcl-cffi-bootstrap)
2577        ("cffi-grovel" ,sbcl-cffi-grovel)
2578        ("trivial-features" ,sbcl-trivial-features)
2579        ("libffi" ,libffi)))))
2580
2581 (define-public sbcl-cffi-grovel
2582   (package
2583     (inherit sbcl-cffi-toolchain)
2584     (name "sbcl-cffi-grovel")
2585     (inputs
2586      `(("libffi" ,libffi)
2587        ("cffi" ,sbcl-cffi-bootstrap)
2588        ("cffi-toolchain" ,sbcl-cffi-toolchain)
2589        ("alexandria" ,sbcl-alexandria)))
2590     (arguments
2591      (substitute-keyword-arguments (package-arguments sbcl-cffi-toolchain)
2592        ((#:phases phases)
2593         `(modify-phases ,phases
2594            (add-after 'build 'install-headers
2595              (lambda* (#:key outputs #:allow-other-keys)
2596                (install-file "grovel/common.h"
2597                              (string-append
2598                               (assoc-ref outputs "out")
2599                               "/include/grovel"))))))))))
2600
2601 (define-public sbcl-cffi
2602   (package
2603     (inherit sbcl-cffi-toolchain)
2604     (name "sbcl-cffi")
2605     (inputs (package-inputs sbcl-cffi-bootstrap))
2606     (native-inputs
2607      `(("cffi-grovel" ,sbcl-cffi-grovel)
2608        ("cffi-libffi" ,sbcl-cffi-libffi)
2609        ("rt" ,sbcl-rt)
2610        ("bordeaux-threads" ,sbcl-bordeaux-threads)
2611        ,@(package-native-inputs sbcl-cffi-bootstrap)))))
2612
2613 (define-public cl-cffi
2614   (sbcl-package->cl-source-package sbcl-cffi))
2615
2616 (define-public sbcl-cffi-uffi-compat
2617   (package
2618     (inherit sbcl-cffi-toolchain)
2619     (name "sbcl-cffi-uffi-compat")
2620     (native-inputs
2621      `(,@(package-inputs sbcl-cffi-bootstrap))) ; For fix-paths phase
2622     (inputs
2623      `(("cffi" ,sbcl-cffi)))
2624     (synopsis "UFFI Compatibility Layer for CFFI")))
2625
2626 (define-public cl-cffi-uffi-compat
2627   (sbcl-package->cl-source-package sbcl-cffi-uffi-compat))
2628
2629 (define-public sbcl-cl-sqlite
2630   (let ((commit "c738e66d4266ef63a1debc4ef4a1b871a068c112"))
2631     (package
2632       (name "sbcl-cl-sqlite")
2633       (version (git-version "0.2" "1" commit))
2634       (source
2635        (origin
2636          (method git-fetch)
2637          (uri (git-reference
2638                (url "https://github.com/dmitryvk/cl-sqlite")
2639                (commit commit)))
2640          (file-name (git-file-name "cl-sqlite" version))
2641          (sha256
2642           (base32
2643            "1ng45k1hdb84sqjryrfx93g66bsbybmpy301wd0fdybnc5jzr36q"))))
2644       (build-system asdf-build-system/sbcl)
2645       (inputs
2646        `(("iterate" ,sbcl-iterate)
2647          ("cffi" ,sbcl-cffi)
2648          ("sqlite" ,sqlite)))
2649       (native-inputs
2650        `(("fiveam" ,sbcl-fiveam)
2651          ("bordeaux-threads" ,sbcl-bordeaux-threads)))
2652       (arguments
2653        `(#:tests? #f                    ; Upstream seems to have issues with tests: https://github.com/dmitryvk/cl-sqlite/issues/7
2654          #:asd-file "sqlite.asd"
2655          #:asd-system-name "sqlite"
2656          #:phases
2657          (modify-phases %standard-phases
2658            (add-after 'unpack 'fix-paths
2659              (lambda* (#:key inputs #:allow-other-keys)
2660                (substitute* "sqlite-ffi.lisp"
2661                  (("libsqlite3" all) (string-append
2662                                       (assoc-ref inputs "sqlite")"/lib/" all))))))))
2663       (home-page "https://common-lisp.net/project/cl-sqlite/")
2664       (synopsis "Common Lisp binding for SQLite")
2665       (description
2666        "The @command{cl-sqlite} package is an interface to the SQLite embedded
2667 relational database engine.")
2668       (license license:public-domain))))
2669
2670 (define-public cl-sqlite
2671   (sbcl-package->cl-source-package sbcl-cl-sqlite))
2672
2673 (define-public sbcl-parenscript
2674   ;; Source archives are overwritten on every release, we use the Git repo instead.
2675   (let ((commit "7a1ac46353cecd144fc91915ba9f122aafcf4766"))
2676     (package
2677       (name "sbcl-parenscript")
2678       (version (git-version "2.7.1" "1" commit))
2679       (source
2680        (origin
2681          (method git-fetch)
2682          (uri (git-reference
2683                (url "https://gitlab.common-lisp.net/parenscript/parenscript")
2684                (commit commit)))
2685          (file-name (git-file-name "parenscript" version))
2686          (sha256
2687           (base32
2688            "0c22lqarrpbq82dg1sb3y6mp6w2faczp34ymzhnmff88yfq1xzsf"))))
2689       (build-system asdf-build-system/sbcl)
2690       (inputs
2691        `(("cl-ppcre" ,sbcl-cl-ppcre)
2692          ("anaphora" ,sbcl-anaphora)
2693          ("named-readtables" ,sbcl-named-readtables)))
2694       (home-page "https://common-lisp.net/project/parenscript/")
2695       (synopsis "Translator from a subset of Common Lisp to JavaScript")
2696       (description
2697        "Parenscript is a translator from an extended subset of Common Lisp to
2698 JavaScript.  Parenscript code can run almost identically on both the
2699 browser (as JavaScript) and server (as Common Lisp).
2700
2701 Parenscript code is treated the same way as Common Lisp code, making the full
2702 power of Lisp macros available for JavaScript.  This provides a web
2703 development environment that is unmatched in its ability to reduce code
2704 duplication and provide advanced meta-programming facilities to web
2705 developers.
2706
2707 At the same time, Parenscript is different from almost all other \"language
2708 X\" to JavaScript translators in that it imposes almost no overhead:
2709
2710 @itemize
2711 @item No run-time dependencies: Any piece of Parenscript code is runnable
2712 as-is.  There are no JavaScript files to include.
2713 @item Native types: Parenscript works entirely with native JavaScript data
2714 types.  There are no new types introduced, and object prototypes are not
2715 touched.
2716 @item Native calling convention: Any JavaScript code can be called without the
2717 need for bindings.  Likewise, Parenscript can be used to make efficient,
2718 self-contained JavaScript libraries.
2719 @item Readable code: Parenscript generates concise, formatted, idiomatic
2720 JavaScript code.  Identifier names are preserved.  This enables seamless
2721 debugging in tools like Firebug.
2722 @item Efficiency: Parenscript introduces minimal overhead for advanced Common
2723 Lisp features.  The generated code is almost as fast as hand-written
2724 JavaScript.
2725 @end itemize\n")
2726       (license license:bsd-3))))
2727
2728 (define-public cl-parenscript
2729   (sbcl-package->cl-source-package sbcl-parenscript))
2730
2731 (define-public ecl-parenscript
2732   (sbcl-package->ecl-package sbcl-parenscript))
2733
2734 (define-public sbcl-cl-json
2735   (let ((commit "6dfebb9540bfc3cc33582d0c03c9ec27cb913e79"))
2736     (package
2737       (name "sbcl-cl-json")
2738       (version (git-version "0.5" "1" commit))
2739       (source
2740        (origin
2741          (method git-fetch)
2742          (uri (git-reference
2743                (url "https://github.com/hankhero/cl-json")
2744                (commit commit)))
2745          (file-name (git-file-name "cl-json" version))
2746          (sha256
2747           (base32
2748            "0fx3m3x3s5ji950yzpazz4s0img3l6b3d6l3jrfjv0lr702496lh"))))
2749       (build-system asdf-build-system/sbcl)
2750       (native-inputs
2751        `(("fiveam" ,sbcl-fiveam)))
2752       (home-page "https://github.com/hankhero/cl-json")
2753       (synopsis "JSON encoder and decoder for Common-Lisp")
2754       (description
2755        "@command{cl-json} provides an encoder of Lisp objects to JSON format
2756 and a corresponding decoder of JSON data to Lisp objects.  Both the encoder
2757 and the decoder are highly customizable; at the same time, the default
2758 settings ensure a very simple mode of operation, similar to that provided by
2759 @command{yason} or @command{st-json}.")
2760       (license license:expat))))
2761
2762 (define-public cl-json
2763   (sbcl-package->cl-source-package sbcl-cl-json))
2764
2765 (define-public ecl-cl-json
2766   (sbcl-package->ecl-package sbcl-cl-json))
2767
2768 (define-public sbcl-unix-opts
2769   (package
2770     (name "sbcl-unix-opts")
2771     (version "0.1.7")
2772     (source
2773      (origin
2774        (method git-fetch)
2775        (uri (git-reference
2776              (url "https://github.com/libre-man/unix-opts")
2777              (commit version)))
2778        (file-name (git-file-name "unix-opts" version))
2779        (sha256
2780         (base32
2781          "08djdi1ard09fijb7w9bdmhmwd98b1hzmcnjw9fqjiqa0g3b44rr"))))
2782     (build-system asdf-build-system/sbcl)
2783     (home-page "https://github.com/hankhero/cl-json")
2784     (synopsis "Unix-style command line options parser")
2785     (description
2786      "This is a minimalistic parser of command line options.  The main
2787 advantage of the library is the ability to concisely define command line
2788 options once and then use this definition for parsing and extraction of
2789 command line arguments, as well as printing description of command line
2790 options (you get --help for free).  This way you don't need to repeat
2791 yourself.  Also, @command{unix-opts} doesn't depend on anything and
2792 precisely controls the behavior of the parser via Common Lisp restarts.")
2793     (license license:expat)))
2794
2795 (define-public cl-unix-opts
2796   (sbcl-package->cl-source-package sbcl-unix-opts))
2797
2798 (define-public ecl-unix-opts
2799   (sbcl-package->ecl-package sbcl-unix-opts))
2800
2801 (define-public sbcl-trivial-garbage
2802   (package
2803     (name "sbcl-trivial-garbage")
2804     (version "0.21")
2805     (source
2806      (origin
2807        (method git-fetch)
2808        (uri (git-reference
2809              (url "https://github.com/trivial-garbage/trivial-garbage.git")
2810              (commit (string-append "v" version))))
2811        (file-name (git-file-name "trivial-garbage" version))
2812        (sha256
2813         (base32 "0122jicfg7pca1wxw8zak1n92h5friqy60988ns0ysksj3fphw9n"))))
2814     (build-system asdf-build-system/sbcl)
2815     (native-inputs
2816      `(("rt" ,sbcl-rt)))
2817     (home-page "https://common-lisp.net/project/trivial-garbage/")
2818     (synopsis "Portable GC-related APIs for Common Lisp")
2819     (description "@command{trivial-garbage} provides a portable API to
2820 finalizers, weak hash-tables and weak pointers on all major implementations of
2821 the Common Lisp programming language.")
2822     (license license:public-domain)))
2823
2824 (define-public cl-trivial-garbage
2825   (sbcl-package->cl-source-package sbcl-trivial-garbage))
2826
2827 (define-public ecl-trivial-garbage
2828   (sbcl-package->ecl-package sbcl-trivial-garbage))
2829
2830 (define-public sbcl-closer-mop
2831   (let ((commit "19c9d33f576e10715fd79cc1d4f688dab0f241d6"))
2832     (package
2833       (name "sbcl-closer-mop")
2834       (version (git-version  "1.0.0" "2" commit))
2835       (source
2836        (origin
2837          (method git-fetch)
2838          (uri (git-reference
2839                (url "https://github.com/pcostanza/closer-mop")
2840                (commit commit)))
2841          (sha256
2842           (base32 "1w3x087wvlwkd6swfdgbvjfs6kazf0la8ax4pjfzikwjch4snn2c"))
2843          (file-name (git-file-name "closer-mop" version ))))
2844       (build-system asdf-build-system/sbcl)
2845       (home-page "https://github.com/pcostanza/closer-mop")
2846       (synopsis "Rectifies absent or incorrect CLOS MOP features")
2847       (description "Closer to MOP is a compatibility layer that rectifies many
2848 of the absent or incorrect CLOS MOP features across a broad range of Common
2849 Lisp implementations.")
2850       (license license:expat))))
2851
2852 (define-public cl-closer-mop
2853   (sbcl-package->cl-source-package sbcl-closer-mop))
2854
2855 (define-public ecl-closer-mop
2856   (sbcl-package->ecl-package sbcl-closer-mop))
2857
2858 (define sbcl-cl-cffi-gtk-boot0
2859   (let ((commit "412d17214e092220c65a5660f5cbbd9cb69b8fe4"))
2860     (package
2861       (name "sbcl-cl-cffi-gtk-boot0")
2862       (version (git-version "0.11.2" "1" commit))
2863       (source
2864        (origin
2865          (method git-fetch)
2866          (uri (git-reference
2867                (url "https://github.com/Ferada/cl-cffi-gtk/")
2868                (commit commit)))
2869          (file-name (git-file-name "cl-cffi-gtk" version))
2870          (sha256
2871           (base32
2872            "0n997yhcnzk048nalx8ys62ja2ac8iv4mbn3mb55iapl0321hghn"))))
2873       (build-system asdf-build-system/sbcl)
2874       (inputs
2875        `(("iterate" ,sbcl-iterate)
2876          ("cffi" ,sbcl-cffi)
2877          ("trivial-features" ,sbcl-trivial-features)))
2878       (home-page "https://github.com/Ferada/cl-cffi-gtk/")
2879       (synopsis "Common Lisp binding for GTK+3")
2880       (description
2881        "@command{cl-cffi-gtk} is a Lisp binding to GTK+ 3 (GIMP Toolkit) which
2882 is a library for creating graphical user interfaces.")
2883       (license license:lgpl3))))
2884
2885 (define-public sbcl-cl-cffi-gtk-glib
2886   (package
2887     (inherit sbcl-cl-cffi-gtk-boot0)
2888     (name "sbcl-cl-cffi-gtk-glib")
2889     (inputs
2890      `(("glib" ,glib)
2891        ("bordeaux-threads" ,sbcl-bordeaux-threads)
2892        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2893     (arguments
2894      `(#:asd-file "glib/cl-cffi-gtk-glib.asd"
2895        #:phases
2896        (modify-phases %standard-phases
2897          (add-after 'unpack 'fix-paths
2898            (lambda* (#:key inputs #:allow-other-keys)
2899              (substitute* "glib/glib.init.lisp"
2900                (("libglib|libgthread" all)
2901                 (string-append (assoc-ref inputs "glib") "/lib/" all))))))))))
2902
2903 (define-public sbcl-cl-cffi-gtk-gobject
2904   (package
2905     (inherit sbcl-cl-cffi-gtk-boot0)
2906     (name "sbcl-cl-cffi-gtk-gobject")
2907     (inputs
2908      `(("glib" ,glib)
2909        ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
2910        ("trivial-garbage" ,sbcl-trivial-garbage)
2911        ("bordeaux-threads" ,sbcl-bordeaux-threads)
2912        ("closer-mop" ,sbcl-closer-mop)
2913        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2914     (arguments
2915      `(#:asd-file "gobject/cl-cffi-gtk-gobject.asd"
2916        #:phases
2917        (modify-phases %standard-phases
2918          (add-after 'unpack 'fix-paths
2919            (lambda* (#:key inputs #:allow-other-keys)
2920              (substitute* "gobject/gobject.init.lisp"
2921                (("libgobject" all) (string-append
2922                                     (assoc-ref inputs "glib") "/lib/" all)))))
2923          (add-after 'install 'link-source
2924            ;; Since source is particularly heavy (16MiB+), let's reuse it
2925            ;; across the different components of cl-ffi-gtk.
2926            (lambda* (#:key inputs outputs #:allow-other-keys)
2927              (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
2928                                                "/share/common-lisp/sbcl-source/"
2929                                                "cl-cffi-gtk-glib"))
2930                    (out-source (string-append (assoc-ref outputs "out")
2931                                               "/share/common-lisp/sbcl-source/"
2932                                               "cl-cffi-gtk-gobject")))
2933                (delete-file-recursively out-source)
2934                (symlink glib-source out-source)
2935                #t))))))))
2936
2937 (define-public sbcl-cl-cffi-gtk-gio
2938   (package
2939     (inherit sbcl-cl-cffi-gtk-boot0)
2940     (name "sbcl-cl-cffi-gtk-gio")
2941     (inputs
2942      `(("glib" ,glib)
2943        ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
2944        ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
2945        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2946     (arguments
2947      `(#:asd-file "gio/cl-cffi-gtk-gio.asd"
2948        #:phases
2949        (modify-phases %standard-phases
2950          (add-after 'unpack 'fix-paths
2951            (lambda* (#:key inputs #:allow-other-keys)
2952              (substitute* "gio/gio.init.lisp"
2953                (("libgio" all)
2954                 (string-append
2955                  (assoc-ref inputs "glib") "/lib/" all)))))
2956          (add-after 'install 'link-source
2957            ;; Since source is particularly heavy (16MiB+), let's reuse it
2958            ;; across the different components of cl-ffi-gtk.
2959            (lambda* (#:key inputs outputs #:allow-other-keys)
2960              (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
2961                                                "/share/common-lisp/sbcl-source/"
2962                                                "cl-cffi-gtk-glib"))
2963                    (out-source (string-append (assoc-ref outputs "out")
2964                                               "/share/common-lisp/sbcl-source/"
2965                                               "cl-cffi-gtk-gio")))
2966                (delete-file-recursively out-source)
2967                (symlink glib-source out-source)
2968                #t))))))))
2969
2970 (define-public sbcl-cl-cffi-gtk-cairo
2971   (package
2972     (inherit sbcl-cl-cffi-gtk-boot0)
2973     (name "sbcl-cl-cffi-gtk-cairo")
2974     (inputs
2975      `(("cairo" ,cairo)
2976        ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
2977        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2978     (arguments
2979      `(#:asd-file "cairo/cl-cffi-gtk-cairo.asd"
2980        #:phases
2981        (modify-phases %standard-phases
2982          (add-after 'unpack 'fix-paths
2983            (lambda* (#:key inputs #:allow-other-keys)
2984              (substitute* "cairo/cairo.init.lisp"
2985                (("libcairo" all)
2986                 (string-append
2987                  (assoc-ref inputs "cairo") "/lib/" all)))))
2988          (add-after 'install 'link-source
2989            ;; Since source is particularly heavy (16MiB+), let's reuse it
2990            ;; across the different components of cl-ffi-gtk.
2991            (lambda* (#:key inputs outputs #:allow-other-keys)
2992              (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
2993                                                "/share/common-lisp/sbcl-source/"
2994                                                "cl-cffi-gtk-glib"))
2995                    (out-source (string-append (assoc-ref outputs "out")
2996                                               "/share/common-lisp/sbcl-source/"
2997                                               "cl-cffi-gtk-cairo")))
2998                (delete-file-recursively out-source)
2999                (symlink glib-source out-source)
3000                #t))))))))
3001
3002 (define-public sbcl-cl-cffi-gtk-pango
3003   (package
3004     (inherit sbcl-cl-cffi-gtk-boot0)
3005     (name "sbcl-cl-cffi-gtk-pango")
3006     (inputs
3007      `(("pango" ,pango)
3008        ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
3009        ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
3010        ("cl-cffi-gtk-cairo" ,sbcl-cl-cffi-gtk-cairo)
3011        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
3012     (arguments
3013      `(#:asd-file "pango/cl-cffi-gtk-pango.asd"
3014        #:phases
3015        (modify-phases %standard-phases
3016          (add-after 'unpack 'fix-paths
3017            (lambda* (#:key inputs #:allow-other-keys)
3018              (substitute* "pango/pango.init.lisp"
3019                (("libpango" all)
3020                 (string-append
3021                  (assoc-ref inputs "pango") "/lib/" all)))))
3022          (add-after 'install 'link-source
3023            ;; Since source is particularly heavy (16MiB+), let's reuse it
3024            ;; across the different components of cl-ffi-gtk.
3025            (lambda* (#:key inputs outputs #:allow-other-keys)
3026              (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
3027                                                "/share/common-lisp/sbcl-source/"
3028                                                "cl-cffi-gtk-glib"))
3029                    (out-source (string-append (assoc-ref outputs "out")
3030                                               "/share/common-lisp/sbcl-source/"
3031                                               "cl-cffi-gtk-pango")))
3032                (delete-file-recursively out-source)
3033                (symlink glib-source out-source)
3034                #t))))))))
3035
3036 (define-public sbcl-cl-cffi-gtk-gdk-pixbuf
3037   (package
3038     (inherit sbcl-cl-cffi-gtk-boot0)
3039     (name "sbcl-cl-cffi-gtk-gdk-pixbuf")
3040     (inputs
3041      `(("gdk-pixbuf" ,gdk-pixbuf)
3042        ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
3043        ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
3044        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
3045     (arguments
3046      `(#:asd-file "gdk-pixbuf/cl-cffi-gtk-gdk-pixbuf.asd"
3047        #:phases
3048        (modify-phases %standard-phases
3049          (add-after 'unpack 'fix-paths
3050            (lambda* (#:key inputs #:allow-other-keys)
3051              (substitute* "gdk-pixbuf/gdk-pixbuf.init.lisp"
3052                (("libgdk_pixbuf" all)
3053                 (string-append
3054                  (assoc-ref inputs "gdk-pixbuf") "/lib/" all)))))
3055          (add-after 'install 'link-source
3056            ;; Since source is particularly heavy (16MiB+), let's reuse it
3057            ;; across the different components of cl-ffi-gtk.
3058            (lambda* (#:key inputs outputs #:allow-other-keys)
3059              (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
3060                                                "/share/common-lisp/sbcl-source/"
3061                                                "cl-cffi-gtk-glib"))
3062                    (out-source (string-append (assoc-ref outputs "out")
3063                                               "/share/common-lisp/sbcl-source/"
3064                                               "cl-cffi-gtk-gdk-pixbuf")))
3065                (delete-file-recursively out-source)
3066                (symlink glib-source out-source)
3067                #t))))))))
3068
3069 (define-public sbcl-cl-cffi-gtk-gdk
3070   (package
3071     (inherit sbcl-cl-cffi-gtk-boot0)
3072     (name "sbcl-cl-cffi-gtk-gdk")
3073     (inputs
3074      `(("gtk" ,gtk+)
3075        ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
3076        ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
3077        ("cl-cffi-gtk-gio" ,sbcl-cl-cffi-gtk-gio)
3078        ("cl-cffi-gtk-gdk-pixbuf" ,sbcl-cl-cffi-gtk-gdk-pixbuf)
3079        ("cl-cffi-gtk-cairo" ,sbcl-cl-cffi-gtk-cairo)
3080        ("cl-cffi-gtk-pango" ,sbcl-cl-cffi-gtk-pango)
3081        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
3082     (arguments
3083      `(#:asd-file "gdk/cl-cffi-gtk-gdk.asd"
3084        #:phases
3085        (modify-phases %standard-phases
3086          (add-after 'unpack 'fix-paths
3087            (lambda* (#:key inputs #:allow-other-keys)
3088              (substitute* "gdk/gdk.init.lisp"
3089                (("libgdk" all)
3090                 (string-append
3091                  (assoc-ref inputs "gtk") "/lib/" all)))
3092              (substitute* "gdk/gdk.package.lisp"
3093                (("libgtk" all)
3094                 (string-append
3095                  (assoc-ref inputs "gtk") "/lib/" all)))))
3096          (add-after 'install 'link-source
3097            ;; Since source is particularly heavy (16MiB+), let's reuse it
3098            ;; across the different components of cl-ffi-gtk.
3099            (lambda* (#:key inputs outputs #:allow-other-keys)
3100              (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
3101                                                "/share/common-lisp/sbcl-source/"
3102                                                "cl-cffi-gtk-glib"))
3103                    (out-source (string-append (assoc-ref outputs "out")
3104                                               "/share/common-lisp/sbcl-source/"
3105                                               "cl-cffi-gtk-gdk")))
3106                (delete-file-recursively out-source)
3107                (symlink glib-source out-source)
3108                #t))))))))
3109
3110 (define-public sbcl-cl-cffi-gtk
3111   (package
3112     (inherit sbcl-cl-cffi-gtk-boot0)
3113     (name "sbcl-cl-cffi-gtk")
3114     (inputs
3115      `(("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
3116        ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
3117        ("cl-cffi-gtk-gio" ,sbcl-cl-cffi-gtk-gio)
3118        ("cl-cffi-gtk-gdk" ,sbcl-cl-cffi-gtk-gdk)
3119        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
3120     (native-inputs
3121      `(("fiveam" ,sbcl-fiveam)))
3122     (arguments
3123      `(#:asd-file "gtk/cl-cffi-gtk.asd"
3124        #:test-asd-file "test/cl-cffi-gtk-test.asd"
3125        ;; TODO: Tests fail with memory fault.
3126        ;; See https://github.com/Ferada/cl-cffi-gtk/issues/24.
3127        #:tests? #f
3128        #:phases
3129        (modify-phases %standard-phases
3130          (add-after 'install 'link-source
3131            ;; Since source is particularly heavy (16MiB+), let's reuse it
3132            ;; across the different components of cl-ffi-gtk.
3133            (lambda* (#:key inputs outputs #:allow-other-keys)
3134              (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
3135                                                "/share/common-lisp/sbcl-source/"
3136                                                "cl-cffi-gtk-glib"))
3137                    (out-source (string-append (assoc-ref outputs "out")
3138                                               "/share/common-lisp/sbcl-source/"
3139                                               "cl-cffi-gtk")))
3140                (delete-file-recursively out-source)
3141                (symlink glib-source out-source)
3142                #t))))))))
3143
3144 (define-public cl-cffi-gtk
3145   (sbcl-package->cl-source-package sbcl-cl-cffi-gtk))
3146
3147 (define-public sbcl-cl-webkit
3148   (let ((commit "f93cb9697e8813068795fe4dc39ac950d814102d"))
3149     (package
3150       (name "sbcl-cl-webkit")
3151       (version (git-version "2.4" "3" commit))
3152       (source
3153        (origin
3154          (method git-fetch)
3155          (uri (git-reference
3156                (url "https://github.com/joachifm/cl-webkit")
3157                (commit commit)))
3158          (file-name (git-file-name "cl-webkit" version))
3159          (sha256
3160           (base32
3161            "1sjcw08kjpd5h83sms7zcq2nymddjygk9hm2rpgzrl524an9ziwc"))))
3162       (build-system asdf-build-system/sbcl)
3163       (inputs
3164        `(("cffi" ,sbcl-cffi)
3165          ("cl-cffi-gtk" ,sbcl-cl-cffi-gtk)
3166          ("webkitgtk" ,webkitgtk)))
3167       (arguments
3168        `(#:asd-file "webkit2/cl-webkit2.asd"
3169          #:asd-system-name "cl-webkit2"
3170          #:phases
3171          (modify-phases %standard-phases
3172            (add-after 'unpack 'fix-paths
3173              (lambda* (#:key inputs #:allow-other-keys)
3174                (substitute* "webkit2/webkit2.init.lisp"
3175                  (("libwebkit2gtk" all)
3176                   (string-append
3177                    (assoc-ref inputs "webkitgtk") "/lib/" all))))))))
3178       (home-page "https://github.com/joachifm/cl-webkit")
3179       (synopsis "Binding to WebKitGTK+ for Common Lisp")
3180       (description
3181        "@command{cl-webkit} is a binding to WebKitGTK+ for Common Lisp,
3182 currently targeting WebKit version 2.  The WebKitGTK+ library adds web
3183 browsing capabilities to an application, leveraging the full power of the
3184 WebKit browsing engine.")
3185       (license license:expat))))
3186
3187 (define-public cl-webkit
3188   (sbcl-package->cl-source-package sbcl-cl-webkit))
3189
3190 (define-public sbcl-lparallel
3191   (package
3192     (name "sbcl-lparallel")
3193     (version "2.8.4")
3194     (source
3195      (origin
3196        (method git-fetch)
3197        (uri (git-reference
3198              (url "https://github.com/lmj/lparallel/")
3199              (commit (string-append "lparallel-" version))))
3200        (file-name (git-file-name "lparallel" version))
3201        (sha256
3202         (base32
3203          "0g0aylrbbrqsz0ahmwhvnk4cmc2931fllbpcfgzsprwnqqd7vwq9"))))
3204     (build-system asdf-build-system/sbcl)
3205     (inputs
3206      `(("alexandria" ,sbcl-alexandria)
3207        ("bordeaux-threads" ,sbcl-bordeaux-threads)
3208        ("trivial-garbage" ,sbcl-trivial-garbage)))
3209     (home-page "https://lparallel.org/")
3210     (synopsis "Parallelism for Common Lisp")
3211     (description
3212      "@command{lparallel} is a library for parallel programming in Common
3213 Lisp, featuring:
3214
3215 @itemize
3216 @item a simple model of task submission with receiving queue,
3217 @item constructs for expressing fine-grained parallelism,
3218 @item asynchronous condition handling across thread boundaries,
3219 @item parallel versions of map, reduce, sort, remove, and many others,
3220 @item promises, futures, and delayed evaluation constructs,
3221 @item computation trees for parallelizing interconnected tasks,
3222 @item bounded and unbounded FIFO queues,
3223 @item high and low priority tasks,
3224 @item task killing by category,
3225 @item integrated timeouts.
3226 @end itemize\n")
3227     (license license:expat)))
3228
3229 (define-public cl-lparallel
3230   (sbcl-package->cl-source-package sbcl-lparallel))
3231
3232 (define-public ecl-lparallel
3233   (sbcl-package->ecl-package sbcl-lparallel))
3234
3235 (define-public sbcl-cl-markup
3236   (let ((commit "e0eb7debf4bdff98d1f49d0f811321a6a637b390"))
3237     (package
3238       (name "sbcl-cl-markup")
3239       (version (git-version "0.1" "1" commit))
3240       (source
3241        (origin
3242          (method git-fetch)
3243          (uri (git-reference
3244                (url "https://github.com/arielnetworks/cl-markup/")
3245                (commit commit)))
3246          (file-name (git-file-name "cl-markup" version))
3247          (sha256
3248           (base32
3249            "10l6k45971dl13fkdmva7zc6i453lmq9j4xax2ci6pjzlc6xjhp7"))))
3250       (build-system asdf-build-system/sbcl)
3251       (home-page "https://github.com/arielnetworks/cl-markup/")
3252       (synopsis "Markup generation library for Common Lisp")
3253       (description
3254        "A modern markup generation library for Common Lisp that features:
3255
3256 @itemize
3257 @item Fast (even faster through compiling the code)
3258 @item Safety
3259 @item Support for multiple document types (markup, xml, html, html5, xhtml)
3260 @item Output with doctype
3261 @item Direct output to stream
3262 @end itemize\n")
3263       (license license:lgpl3+))))
3264
3265 (define-public cl-markup
3266   (sbcl-package->cl-source-package sbcl-cl-markup))
3267
3268 (define-public ecl-cl-markup
3269   (sbcl-package->ecl-package sbcl-cl-markup))
3270
3271 (define-public sbcl-cl-css
3272   (let ((commit "8fe654c8f0cf95b300718101cce4feb517f78e2f"))
3273     (package
3274       (name "sbcl-cl-css")
3275       (version (git-version "0.1" "1" commit))
3276       (source
3277        (origin
3278          (method git-fetch)
3279          (uri (git-reference
3280                (url "https://github.com/inaimathi/cl-css/")
3281                (commit commit)))
3282          (file-name (git-file-name "cl-css" version))
3283          (sha256
3284           (base32
3285            "1lc42zi2sw11fl2589sc19nr5sd2p0wy7wgvgwaggxa5f3ajhsmd"))))
3286       (build-system asdf-build-system/sbcl)
3287       (home-page "https://github.com/inaimathi/cl-css/")
3288       (synopsis "Non-validating, inline CSS generator for Common Lisp")
3289       (description
3290        "This is a dead-simple, non validating, inline CSS generator for Common
3291 Lisp.  Its goals are axiomatic syntax, simple implementation to support
3292 portability, and boilerplate reduction in CSS.")
3293       (license license:expat))))
3294
3295 (define-public cl-css
3296   (sbcl-package->cl-source-package sbcl-cl-css))
3297
3298 (define-public ecl-cl-css
3299   (sbcl-package->ecl-package sbcl-cl-css))
3300
3301 (define-public sbcl-portable-threads
3302   (let ((commit "c0e61a1faeb0583c80fd3f20b16cc4c555226920"))
3303     (package
3304       (name "sbcl-portable-threads")
3305       (version (git-version "2.3" "1" commit))
3306       (source
3307        (origin
3308          (method git-fetch)
3309          (uri (git-reference
3310                (url "https://github.com/binghe/portable-threads/")
3311                (commit commit)))
3312          (file-name (git-file-name "portable-threads" version))
3313          (sha256
3314           (base32
3315            "03fmxyarc0xf4kavwkfa0a2spkyfrz6hbgbi9y4q7ny5aykdyfaq"))))
3316       (build-system asdf-build-system/sbcl)
3317       (arguments
3318        `(;; Tests seem broken.
3319          #:tests? #f))
3320       (home-page "https://github.com/binghe/portable-threads")
3321       (synopsis "Portable threads (and scheduled and periodic functions) API for Common Lisp")
3322       (description
3323        "Portable Threads (and Scheduled and Periodic Functions) API for Common
3324 Lisp (from GBBopen project).")
3325       (license license:asl2.0))))
3326
3327 (define-public cl-portable-threads
3328   (sbcl-package->cl-source-package sbcl-portable-threads))
3329
3330 (define-public ecl-portable-threada
3331   (sbcl-package->ecl-package sbcl-portable-threads))
3332
3333 (define sbcl-usocket-boot0
3334   ;; usocket's test rely on usocket-server which depends on usocket itself.
3335   ;; We break this cyclic dependency with -boot0 that packages usocket.
3336   (package
3337     (name "sbcl-usocket-boot0")
3338     (version "0.8.3")
3339     (source
3340      (origin
3341        (method git-fetch)
3342        (uri (git-reference
3343              (url "https://github.com/usocket/usocket/")
3344              (commit (string-append "v" version))))
3345        (file-name (git-file-name "usocket" version))
3346        (sha256
3347         (base32
3348          "0x746wr2324l6bn7skqzgkzcbj5kd0zp2ck0c8rldrw0rzabg826"))))
3349     (build-system asdf-build-system/sbcl)
3350     (inputs
3351      `(("split-sequence" ,sbcl-split-sequence)))
3352     (arguments
3353      `(#:tests? #f
3354        #:asd-system-name "usocket"))
3355     (home-page "https://common-lisp.net/project/usocket/")
3356     (synopsis "Universal socket library for Common Lisp (server side)")
3357     (description
3358      "This library strives to provide a portable TCP/IP and UDP/IP socket
3359 interface for as many Common Lisp implementations as possible, while keeping
3360 the abstraction and portability layer as thin as possible.")
3361     (license license:expat)))
3362
3363 (define-public sbcl-usocket-server
3364   (package
3365     (inherit sbcl-usocket-boot0)
3366     (name "sbcl-usocket-server")
3367     (inputs
3368      `(("bordeaux-threads" ,sbcl-bordeaux-threads)
3369        ("usocket" ,sbcl-usocket-boot0)))
3370     (arguments
3371      '(#:asd-system-name "usocket-server"))
3372     (synopsis "Universal socket library for Common Lisp (server side)")))
3373
3374 (define-public cl-usocket-server
3375   (sbcl-package->cl-source-package sbcl-usocket-server))
3376
3377 (define-public ecl-socket-server
3378   (sbcl-package->ecl-package sbcl-usocket-server))
3379
3380 (define-public sbcl-usocket
3381   (package
3382     (inherit sbcl-usocket-boot0)
3383     (name "sbcl-usocket")
3384     (arguments
3385      ;; FIXME: Tests need network access?
3386      `(#:tests? #f))
3387     (native-inputs
3388      ;; Testing only.
3389      `(("usocket-server" ,sbcl-usocket-server)
3390        ("rt" ,sbcl-rt)))))
3391
3392 (define-public cl-usocket
3393   (sbcl-package->cl-source-package sbcl-usocket))
3394
3395 (define-public ecl-usocket
3396   (sbcl-package->ecl-package sbcl-usocket))
3397
3398 (define-public sbcl-s-xml
3399   (package
3400     (name "sbcl-s-xml")
3401     (version "3")
3402     (source
3403      (origin
3404        (method url-fetch)
3405        (uri "https://common-lisp.net/project/s-xml/s-xml.tgz")
3406        (sha256
3407         (base32
3408          "061qcr0dzshsa38s5ma4ay924cwak2nq9gy59dw6v9p0qb58nzjf"))))
3409     (build-system asdf-build-system/sbcl)
3410     (home-page "https://common-lisp.net/project/s-xml/")
3411     (synopsis "Simple XML parser implemented in Common Lisp")
3412     (description
3413      "S-XML is a simple XML parser implemented in Common Lisp.  This XML
3414 parser implementation has the following features:
3415
3416 @itemize
3417 @item It works (handling many common XML usages).
3418 @item It is very small (the core is about 700 lines of code, including
3419 comments and whitespace).
3420 @item It has a core API that is simple, efficient and pure functional, much
3421 like that from SSAX (see also http://ssax.sourceforge.net).
3422 @item It supports different DOM models: an XSML-based one, an LXML-based one
3423 and a classic xml-element struct based one.
3424 @item It is reasonably time and space efficient (internally avoiding garbage
3425 generatation as much as possible).
3426 @item It does support CDATA.
3427 @item It should support the same character sets as your Common Lisp
3428 implementation.
3429 @item It does support XML name spaces.
3430 @end itemize
3431
3432 This XML parser implementation has the following limitations:
3433
3434 @itemize
3435 @item It does not support any special tags (like processing instructions).
3436 @item It is not validating, even skips DTD's all together.
3437 @end itemize\n")
3438     (license license:lgpl3+)))
3439
3440 (define-public cl-s-xml
3441   (sbcl-package->cl-source-package sbcl-s-xml))
3442
3443 (define-public ecl-s-xml
3444   (sbcl-package->ecl-package sbcl-s-xml))
3445
3446 (define-public sbcl-s-xml-rpc
3447   (package
3448     (name "sbcl-s-xml-rpc")
3449     (version "7")
3450     (source
3451      (origin
3452        (method url-fetch)
3453        (uri "https://common-lisp.net/project/s-xml-rpc/s-xml-rpc.tgz")
3454        (sha256
3455         (base32
3456          "02z7k163d51v0pzk8mn1xb6h5s6x64gjqkslhwm3a5x26k2gfs11"))))
3457     (build-system asdf-build-system/sbcl)
3458     (inputs
3459      `(("s-xml" ,sbcl-s-xml)))
3460     (home-page "https://common-lisp.net/project/s-xml-rpc/")
3461     (synopsis "Implementation of XML-RPC in Common Lisp for both client and server")
3462     (description
3463      "S-XML-RPC is an implementation of XML-RPC in Common Lisp for both
3464 client and server.")
3465     (license license:lgpl3+)))
3466
3467 (define-public cl-s-xml-rpc
3468   (sbcl-package->cl-source-package sbcl-s-xml-rpc))
3469
3470 (define-public ecl-s-xml-rpc
3471   (sbcl-package->ecl-package sbcl-s-xml-rpc))
3472
3473 (define-public sbcl-trivial-clipboard
3474   (let ((commit "5af3415d1484e6d69a1b5c178f24680d9fd01796"))
3475     (package
3476       (name "sbcl-trivial-clipboard")
3477       (version (git-version "0.0.0.0" "2" commit))
3478       (source
3479        (origin
3480          (method git-fetch)
3481          (uri (git-reference
3482                (url "https://github.com/snmsts/trivial-clipboard")
3483                (commit commit)))
3484          (file-name (git-file-name "trivial-clipboard" version))
3485          (sha256
3486           (base32
3487            "1gb515z5yq6h5548pb1fwhmb0hhq1ssyb78pvxh4alq799xipxs9"))))
3488       (build-system asdf-build-system/sbcl)
3489       (inputs
3490        `(("xclip" ,xclip)))
3491       (native-inputs
3492        `(("fiveam" ,sbcl-fiveam)))
3493       (arguments
3494        `(#:phases
3495          (modify-phases %standard-phases
3496            (add-after 'unpack 'fix-paths
3497              (lambda* (#:key inputs #:allow-other-keys)
3498                (substitute* "src/text.lisp"
3499                  (("\\(executable-find \"xclip\"\\)")
3500                   (string-append "(executable-find \""
3501                                  (assoc-ref inputs "xclip")
3502                                  "/bin/xclip\")"))))))))
3503       (home-page "https://github.com/snmsts/trivial-clipboard")
3504       (synopsis "Access system clipboard in Common Lisp")
3505       (description
3506        "@command{trivial-clipboard} gives access to the system clipboard.")
3507       (license license:expat))))
3508
3509 (define-public cl-trivial-clipboard
3510   (sbcl-package->cl-source-package sbcl-trivial-clipboard))
3511
3512 (define-public ecl-trivial-clipboard
3513   (sbcl-package->ecl-package sbcl-trivial-clipboard))
3514
3515 (define-public sbcl-trivial-backtrace
3516   (let ((commit "ca81c011b86424a381a7563cea3b924f24e6fbeb")
3517         (revision "1"))
3518     (package
3519      (name "sbcl-trivial-backtrace")
3520      (version (git-version "0.0.0" revision commit))
3521      (source
3522       (origin
3523        (method git-fetch)
3524        (uri (git-reference
3525              (url "https://github.com/gwkkwg/trivial-backtrace.git")
3526              (commit commit)))
3527        (file-name (git-file-name "trivial-backtrace" version))
3528        (sha256
3529         (base32 "10p41p43skj6cimdg8skjy7372s8v2xpkg8djjy0l8rm45i654k1"))))
3530      (build-system asdf-build-system/sbcl)
3531      (inputs
3532       `(("sbcl-lift" ,sbcl-lift)))
3533      (arguments
3534       `(#:phases
3535         (modify-phases %standard-phases
3536           (add-after 'check 'delete-test-results
3537             (lambda* (#:key outputs #:allow-other-keys)
3538               (let ((test-results (string-append (assoc-ref outputs "out")
3539                                                  "/share/common-lisp/"
3540                                                  (%lisp-type) "-source"
3541                                                  "/trivial-backtrace"
3542                                                  "/test-results")))
3543                 (when (file-exists? test-results)
3544                   (delete-file-recursively test-results)))
3545               #t)))))
3546      (home-page "https://common-lisp.net/project/trivial-backtrace/")
3547      (synopsis "Portable simple API to work with backtraces in Common Lisp")
3548      (description
3549       "On of the many things that didn't quite get into the Common Lisp
3550 standard was how to get a Lisp to output its call stack when something has
3551 gone wrong.  As such, each Lisp has developed its own notion of what to
3552 display, how to display it, and what sort of arguments can be used to
3553 customize it.  @code{trivial-backtrace} is a simple solution to generating a
3554 backtrace portably.")
3555      (license license:expat))))
3556
3557 (define-public cl-trivial-backtrace
3558   (sbcl-package->cl-source-package sbcl-trivial-backtrace))
3559
3560 (define-public sbcl-rfc2388
3561   (let ((commit "591bcf7e77f2c222c43953a80f8c297751dc0c4e")
3562         (revision "1"))
3563     (package
3564      (name "sbcl-rfc2388")
3565      (version (git-version "0.0.0" revision commit))
3566      (source
3567       (origin
3568        (method git-fetch)
3569        (uri (git-reference
3570              (url "https://github.com/jdz/rfc2388.git")
3571              (commit commit)))
3572        (file-name (git-file-name "rfc2388" version))
3573        (sha256
3574         (base32 "0phh5n3clhl9ji8jaxrajidn22d3f0aq87mlbfkkxlnx2pnw694k"))))
3575      (build-system asdf-build-system/sbcl)
3576      (home-page "https://github.com/jdz/rfc2388/")
3577      (synopsis "An implementation of RFC 2388 in Common Lisp")
3578      (description
3579       "This package contains an implementation of RFC 2388, which is used to
3580 process form data posted with HTTP POST method using enctype
3581 \"multipart/form-data\".")
3582      (license license:bsd-2))))
3583
3584 (define-public cl-rfc2388
3585   (sbcl-package->cl-source-package sbcl-rfc2388))
3586
3587 (define-public sbcl-md5
3588   (package
3589     (name "sbcl-md5")
3590     (version "2.0.4")
3591     (source
3592      (origin
3593        (method url-fetch)
3594        (uri (string-append
3595              "https://github.com/pmai/md5/archive/release-" version ".tar.gz"))
3596        (sha256
3597         (base32 "19yl9n0pjdz5gw4qi711lka97xcd9f81ylg434hk7jwn9f2s6w11"))))
3598     (build-system asdf-build-system/sbcl)
3599     (home-page "https://github.com/pmai/md5")
3600     (synopsis
3601      "Common Lisp implementation of the MD5 Message-Digest Algorithm (RFC 1321)")
3602     (description
3603      "This package implements The MD5 Message-Digest Algorithm, as defined in
3604 RFC 1321 by R. Rivest, published April 1992.")
3605     (license license:public-domain)))
3606
3607 (define-public cl-md5
3608   (sbcl-package->cl-source-package sbcl-md5))
3609
3610 (define-public sbcl-cl+ssl
3611   (let ((commit "701e645081e6533a3f0f0b3ac86389d6f506c4b5")
3612         (revision "1"))
3613     (package
3614       (name "sbcl-cl+ssl")
3615       (version (git-version "0.0.0" revision commit))
3616       (source
3617        (origin
3618          (method git-fetch)
3619          (uri (git-reference
3620                (url "https://github.com/cl-plus-ssl/cl-plus-ssl.git")
3621                (commit commit)))
3622          (file-name (git-file-name "cl+ssl" version))
3623          (sha256
3624           (base32 "0nfl275nwhff3m25872y388cydz14kqb6zbwywa6nj85r9k8bgs0"))))
3625       (build-system asdf-build-system/sbcl)
3626       (arguments
3627        '(#:phases
3628          (modify-phases %standard-phases
3629            (add-after 'unpack 'fix-paths
3630              (lambda* (#:key inputs #:allow-other-keys)
3631                (substitute* "src/reload.lisp"
3632                  (("libssl.so" all)
3633                   (string-append
3634                    (assoc-ref inputs "openssl") "/lib/" all))))))))
3635       (inputs
3636        `(("openssl" ,openssl)
3637          ("sbcl-cffi" ,sbcl-cffi)
3638          ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)
3639          ("sbcl-flexi-streams" ,sbcl-flexi-streams)
3640          ("sbcl-bordeaux-threads" ,sbcl-bordeaux-threads)
3641          ("sbcl-trivial-garbage" ,sbcl-trivial-garbage)
3642          ("sbcl-alexandria" ,sbcl-alexandria)
3643          ("sbcl-trivial-features" ,sbcl-trivial-features)))
3644       (home-page "https://common-lisp.net/project/cl-plus-ssl/")
3645       (synopsis "Common Lisp bindings to OpenSSL")
3646       (description
3647        "This library is a fork of SSL-CMUCL.  The original SSL-CMUCL source
3648 code was written by Eric Marsden and includes contributions by Jochen Schmidt.
3649 Development into CL+SSL was done by David Lichteblau.")
3650       (license license:expat))))
3651
3652 (define-public cl-cl+ssl
3653   (sbcl-package->cl-source-package sbcl-cl+ssl))
3654
3655 (define-public sbcl-kmrcl
3656   (let ((version "1.109.0")
3657         (commit "5260068b2eb735af6796740c2db4955afac21636")
3658         (revision "1"))
3659     (package
3660       (name "sbcl-kmrcl")
3661       (version (git-version version revision commit))
3662       (source
3663        (origin
3664          (method git-fetch)
3665          (uri (git-reference
3666                (url "http://git.kpe.io/kmrcl.git/")
3667                (commit commit)))
3668          (file-name (git-file-name name version))
3669          (sha256
3670           (base32 "1va7xjgzfv674bpsli674i7zj3f7wg5kxic41kz18r6hh4n52dfv"))))
3671       (build-system asdf-build-system/sbcl)
3672       (arguments
3673        ;; Tests fail with: :FORCE and :FORCE-NOT arguments not allowed in a
3674        ;; nested call to ASDF/OPERATE:OPERATE unless identically to toplevel
3675        '(#:tests? #f))
3676       (inputs
3677        `(("sbcl-rt" ,sbcl-rt)))
3678       (home-page "http://files.kpe.io/kmrcl/")
3679       (synopsis "General utilities for Common Lisp programs")
3680       (description
3681        "KMRCL is a collection of utilities used by a number of Kevin
3682 Rosenberg's CL packages.")
3683       (license license:llgpl))))
3684
3685 (define-public cl-kmrcl
3686   (sbcl-package->cl-source-package sbcl-kmrcl))
3687
3688 (define-public sbcl-cl-base64
3689   (package
3690     (name "sbcl-cl-base64")
3691     (version "3.3.4")
3692     (source
3693      (origin
3694        (method url-fetch)
3695        (uri (string-append "http://files.kpe.io/cl-base64/cl-base64-"
3696                            version ".tar.gz"))
3697        (sha256
3698         (base32 "0pl4zwn5bf18dm8fh1kn1yshaa6kpmfrjyb33z9mq4raqmj3xpv2"))))
3699     (build-system asdf-build-system/sbcl)
3700     (arguments
3701      ;; Tests fail with: :FORCE and :FORCE-NOT arguments not allowed
3702      ;; in a nested call to ASDF/OPERATE:OPERATE unless identically
3703      ;; to toplevel
3704      '(#:tests? #f))
3705     (inputs
3706      `(("sbcl-ptester" ,sbcl-ptester)
3707        ("sbcl-kmrcl" ,sbcl-kmrcl)))
3708     (home-page "http://files.kpe.io/cl-base64/")
3709     (synopsis
3710      "Common Lisp package to encode and decode base64 with URI support")
3711     (description
3712      "This package provides highly optimized base64 encoding and decoding.
3713 Besides conversion to and from strings, integer conversions are supported.
3714 Encoding with Uniform Resource Identifiers is supported by using a modified
3715 encoding table that uses only URI-compatible characters.")
3716     (license license:bsd-3)))
3717
3718 (define-public cl-base64
3719   (sbcl-package->cl-source-package sbcl-cl-base64))
3720
3721 (define-public sbcl-chunga
3722   (package
3723     (name "sbcl-chunga")
3724     (version "1.1.7")
3725     (source
3726      (origin
3727        (method git-fetch)
3728        (uri (git-reference
3729               (url "https://github.com/edicl/chunga.git")
3730               (commit (string-append "v" version))))
3731        (file-name (git-file-name name version))
3732        (sha256
3733         (base32 "0jzn3nyb3f22gm983rfk99smqs3mhb9ivjmasvhq9qla5cl9pyhd"))))
3734     (build-system asdf-build-system/sbcl)
3735     (inputs
3736      `(("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)))
3737     (home-page "https://edicl.github.io/chunga/")
3738     (synopsis "Portable chunked streams for Common Lisp")
3739     (description
3740      "Chunga implements streams capable of chunked encoding on demand as
3741 defined in RFC 2616.")
3742     (license license:bsd-2)))
3743
3744 (define-public cl-chunga
3745   (sbcl-package->cl-source-package sbcl-chunga))
3746
3747 (define-public sbcl-cl-who
3748   (let ((version "1.1.4")
3749         (commit "2c08caa4bafba720409af9171feeba3f32e86d32")
3750         (revision "1"))
3751     (package
3752       (name "sbcl-cl-who")
3753       (version (git-version version revision commit))
3754       (source
3755        (origin
3756          (method git-fetch)
3757          (uri (git-reference
3758                (url "https://github.com/edicl/cl-who.git")
3759                (commit commit)))
3760          (file-name (git-file-name name version))
3761          (sha256
3762           (base32
3763            "0yjb6sr3yazm288m318kqvj9xk8rm9n1lpimgf65ymqv0i5agxsb"))))
3764       (build-system asdf-build-system/sbcl)
3765       (native-inputs
3766        `(("sbcl-flexi-streams" ,sbcl-flexi-streams)))
3767       (home-page "https://edicl.github.io/cl-who/")
3768       (synopsis "Yet another Lisp markup language")
3769       (description
3770        "There are plenty of Lisp Markup Languages out there - every Lisp
3771 programmer seems to write at least one during his career - and CL-WHO (where
3772 WHO means \"with-html-output\" for want of a better acronym) is probably just
3773 as good or bad as the next one.")
3774       (license license:bsd-2))))
3775
3776 (define-public cl-cl-who
3777   (sbcl-package->cl-source-package sbcl-cl-who))
3778
3779 (define-public sbcl-chipz
3780   (let ((version "0.8")
3781         (commit "75dfbc660a5a28161c57f115adf74c8a926bfc4d")
3782         (revision "1"))
3783     (package
3784       (name "sbcl-chipz")
3785       (version (git-version version revision commit))
3786       (source
3787        (origin
3788          (method git-fetch)
3789          (uri (git-reference
3790                (url "https://github.com/froydnj/chipz.git")
3791                (commit commit)))
3792          (file-name (git-file-name name version))
3793          (sha256
3794           (base32
3795            "0plx4rs39zbs4gjk77h4a2q11zpy75fh9v8hnxrvsf8fnakajhwg"))))
3796       (build-system asdf-build-system/sbcl)
3797       (native-inputs
3798        `(("sbcl-flexi-streams" ,sbcl-flexi-streams)))
3799       (home-page "http://method-combination.net/lisp/chipz/")
3800       (synopsis
3801        "Common Lisp library for decompressing deflate, zlib, gzip, and bzip2
3802 data")
3803       (description
3804        "DEFLATE data, defined in RFC1951, forms the core of popular
3805 compression formats such as zlib (RFC 1950) and gzip (RFC 1952).  As such,
3806 Chipz also provides for decompressing data in those formats as well.  BZIP2 is
3807 the format used by the popular compression tool bzip2.")
3808       ;; The author describes it as "MIT-like"
3809       (license license:expat))))
3810
3811 (define-public cl-chipz
3812   (sbcl-package->cl-source-package sbcl-chipz))
3813
3814 (define-public sbcl-drakma
3815   (package
3816     (name "sbcl-drakma")
3817     (version "2.0.7")
3818     (source
3819      (origin
3820        (method git-fetch)
3821        (uri (git-reference
3822              (url "https://github.com/edicl/drakma.git")
3823              (commit (string-append "v" version))))
3824        (file-name (git-file-name name version))
3825        (sha256
3826         (base32
3827          "1441idnyif9xzx3ln1p3fg36k2v9h4wasjqrzc8y52j61420qpci"))))
3828     (build-system asdf-build-system/sbcl)
3829     (inputs
3830      `(("sbcl-puri" ,sbcl-puri)
3831        ("sbcl-cl-base64" ,sbcl-cl-base64)
3832        ("sbcl-chunga" ,sbcl-chunga)
3833        ("sbcl-flexi-streams" ,sbcl-flexi-streams)
3834        ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
3835        ("sbcl-chipz" ,sbcl-chipz)
3836        ("sbcl-usocket" ,sbcl-usocket)
3837        ("sbcl-cl+ssl" ,sbcl-cl+ssl)))
3838     (native-inputs
3839      `(("sbcl-fiveam" ,sbcl-fiveam)))
3840     (home-page "https://edicl.github.io/drakma/")
3841     (synopsis "HTTP client written in Common Lisp")
3842     (description
3843      "Drakma is a full-featured HTTP client implemented in Common Lisp.  It
3844 knows how to handle HTTP/1.1 chunking, persistent connections, re-usable
3845 sockets, SSL, continuable uploads, file uploads, cookies, and more.")
3846     (license license:bsd-2)))
3847
3848 (define-public cl-drakma
3849   (sbcl-package->cl-source-package sbcl-drakma))
3850
3851 (define-public ecl-drakma
3852   (sbcl-package->ecl-package sbcl-drakma))
3853
3854 (define-public sbcl-hunchentoot
3855   (package
3856     (name "sbcl-hunchentoot")
3857     (version "1.2.38")
3858     (source
3859      (origin
3860        (method git-fetch)
3861        (uri (git-reference
3862              (url "https://github.com/edicl/hunchentoot.git")
3863              (commit (string-append "v" version))))
3864        (file-name (git-file-name "hunchentoot" version))
3865        (sha256
3866         (base32 "1anpcad7w045m4rsjs1f3xdhjwx5cppq1h0vlb3q7dz81fi3i6yq"))))
3867     (build-system asdf-build-system/sbcl)
3868     (native-inputs
3869      `(("sbcl-cl-who" ,sbcl-cl-who)
3870        ("sbcl-drakma" ,sbcl-drakma)))
3871     (inputs
3872      `(("sbcl-chunga" ,sbcl-chunga)
3873        ("sbcl-cl-base64" ,sbcl-cl-base64)
3874        ("sbcl-cl-fad" ,sbcl-cl-fad)
3875        ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
3876        ("sbcl-flexi-streams" ,sbcl-flexi-streams)
3877        ("sbcl-cl+ssl" ,sbcl-cl+ssl)
3878        ("sbcl-md5" ,sbcl-md5)
3879        ("sbcl-rfc2388" ,sbcl-rfc2388)
3880        ("sbcl-trivial-backtrace" ,sbcl-trivial-backtrace)
3881        ("sbcl-usocket" ,sbcl-usocket)))
3882     (home-page "https://edicl.github.io/hunchentoot/")
3883     (synopsis "Web server written in Common Lisp")
3884     (description
3885      "Hunchentoot is a web server written in Common Lisp and at the same
3886 time a toolkit for building dynamic websites.  As a stand-alone web server,
3887 Hunchentoot is capable of HTTP/1.1 chunking (both directions), persistent
3888 connections (keep-alive), and SSL.")
3889     (license license:bsd-2)))
3890
3891 (define-public cl-hunchentoot
3892   (sbcl-package->cl-source-package sbcl-hunchentoot))
3893
3894 (define-public sbcl-trivial-types
3895   (package
3896     (name "sbcl-trivial-types")
3897     (version "0.0.1")
3898     (source
3899      (origin
3900        (method git-fetch)
3901        (uri (git-reference
3902              (url "https://github.com/m2ym/trivial-types.git")
3903              (commit "ee869f2b7504d8aa9a74403641a5b42b16f47d88")))
3904        (file-name (git-file-name name version))
3905        (sha256
3906         (base32 "1s4cp9bdlbn8447q7w7f1wkgwrbvfzp20mgs307l5pxvdslin341"))))
3907     (build-system asdf-build-system/sbcl)
3908     (home-page "https://github.com/m2ym/trivial-types")
3909     (synopsis "Trivial type definitions for Common Lisp")
3910     (description
3911      "TRIVIAL-TYPES provides missing but important type definitions such as
3912 PROPER-LIST, ASSOCIATION-LIST, PROPERTY-LIST and TUPLE.")
3913     (license license:llgpl)))
3914
3915 (define-public cl-trivial-types
3916   (sbcl-package->cl-source-package sbcl-trivial-types))
3917
3918 (define-public sbcl-cl-syntax
3919   (package
3920     (name "sbcl-cl-syntax")
3921     (version "0.0.3")
3922     (source
3923      (origin
3924        (method git-fetch)
3925        (uri (git-reference
3926              (url "https://github.com/m2ym/cl-syntax.git")
3927              (commit "03f0c329bbd55b8622c37161e6278366525e2ccc")))
3928        (file-name (git-file-name "cl-syntax" version))
3929        (sha256
3930         (base32 "17ran8xp77asagl31xv8w819wafh6whwfc9p6dgx22ca537gyl4y"))))
3931     (build-system asdf-build-system/sbcl)
3932     (arguments
3933      '(#:asd-file "cl-syntax.asd"
3934        #:asd-system-name "cl-syntax"))
3935     (inputs `(("sbcl-trivial-types" ,sbcl-trivial-types)
3936               ("sbcl-named-readtables" ,sbcl-named-readtables)))
3937     (home-page "https://github.com/m2ym/cl-syntax")
3938     (synopsis "Reader Syntax Coventions for Common Lisp and SLIME")
3939     (description
3940      "CL-SYNTAX provides Reader Syntax Coventions for Common Lisp and SLIME.")
3941     (license license:llgpl)))
3942
3943 (define-public cl-syntax
3944   (sbcl-package->cl-source-package sbcl-cl-syntax))
3945
3946 (define-public sbcl-cl-annot
3947   (let ((commit "c99e69c15d935eabc671b483349a406e0da9518d")
3948         (revision "1"))
3949     (package
3950       (name "sbcl-cl-annot")
3951       (version (git-version "0.0.0" revision commit))
3952       (source
3953        (origin
3954          (method git-fetch)
3955          (uri (git-reference
3956                (url "https://github.com/m2ym/cl-annot.git")
3957                (commit commit)))
3958          (file-name (git-file-name name version))
3959          (sha256
3960           (base32 "1wq1gs9jjd5m6iwrv06c2d7i5dvqsfjcljgbspfbc93cg5xahk4n"))))
3961       (build-system asdf-build-system/sbcl)
3962     (arguments
3963      '(#:asd-file "cl-annot.asd"
3964        #:asd-system-name "cl-annot"))
3965       (inputs
3966        `(("sbcl-alexandria" ,sbcl-alexandria)))
3967       (home-page "https://github.com/m2ym/cl-annot")
3968       (synopsis "Python-like Annotation Syntax for Common Lisp.")
3969       (description
3970        "@code{cl-annot} is an general annotation library for Common Lisp.")
3971       (license license:llgpl))))
3972
3973 (define-public cl-annot
3974   (sbcl-package->cl-source-package sbcl-cl-annot))
3975
3976 (define-public sbcl-cl-syntax-annot
3977   (package
3978     (inherit sbcl-cl-syntax)
3979     (name "sbcl-cl-syntax-annot")
3980     (arguments
3981      '(#:asd-file "cl-syntax-annot.asd"
3982        #:asd-system-name "cl-syntax-annot"))
3983     (inputs
3984      `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
3985        ("sbcl-cl-annot" ,sbcl-cl-annot)))
3986     (synopsis "Common Lisp reader Syntax for cl-annot")
3987     (description
3988      "CL-SYNTAX provides reader syntax coventions for Common Lisp and
3989 @code{cl-annot}.")))
3990
3991 (define-public cl-syntax-annot
3992   (sbcl-package->cl-source-package sbcl-cl-syntax-annot))
3993
3994 (define-public sbcl-cl-syntax-interpol
3995   (package
3996     (inherit sbcl-cl-syntax)
3997     (name "sbcl-cl-syntax-interpol")
3998     (arguments
3999      '(#:asd-file "cl-syntax-interpol.asd"
4000        #:asd-system-name "cl-syntax-interpol"))
4001     (inputs
4002      `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
4003        ("sbcl-cl-interpol" ,sbcl-cl-interpol)))
4004     (synopsis "Common Lisp reader Syntax for cl-interpol")
4005     (description
4006      "CL-SYNTAX provides reader syntax coventions for Common Lisp and
4007 @code{cl-interpol}.")))
4008
4009 (define-public cl-syntax-interpol
4010   (sbcl-package->cl-source-package sbcl-cl-syntax-interpol))
4011
4012 (define-public sbcl-cl-utilities
4013   (let ((commit "dce2d2f6387091ea90357a130fa6d13a6776884b")
4014         (revision "1"))
4015     (package
4016       (name "sbcl-cl-utilities")
4017       (version (git-version "0.0.0" revision commit))
4018       (source
4019        (origin
4020          (method url-fetch)
4021          (uri
4022           (string-append
4023            "https://gitlab.common-lisp.net/cl-utilities/cl-utilities/-/"
4024            "archive/" commit "/cl-utilities-" commit ".tar.gz"))
4025          (sha256
4026           (base32 "1r46v730yf96nk2vb24qmagv9x96xvd08abqwhf02ghgydv1a7z2"))))
4027       (build-system asdf-build-system/sbcl)
4028       (arguments
4029        '(#:asd-file "cl-utilities.asd"
4030          #:asd-system-name "cl-utilities"
4031          #:phases
4032          (modify-phases %standard-phases
4033            (add-after 'unpack 'fix-paths
4034              (lambda* (#:key inputs #:allow-other-keys)
4035                (substitute* "rotate-byte.lisp"
4036                  (("in-package :cl-utilities)" all)
4037                   "in-package :cl-utilities)\n\n#+sbcl\n(require :sb-rotate-byte)")))))))
4038       (home-page "http://common-lisp.net/project/cl-utilities")
4039       (synopsis "A collection of semi-standard utilities")
4040       (description
4041        "On Cliki.net <http://www.cliki.net/Common%20Lisp%20Utilities>, there
4042 is a collection of Common Lisp Utilities, things that everybody writes since
4043 they're not part of the official standard.  There are some very useful things
4044 there; the only problems are that they aren't implemented as well as you'd
4045 like (some aren't implemented at all) and they aren't conveniently packaged
4046 and maintained.  It takes quite a bit of work to carefully implement utilities
4047 for common use, commented and documented, with error checking placed
4048 everywhere some dumb user might make a mistake.")
4049       (license license:public-domain))))
4050
4051 (define-public cl-utilities
4052   (sbcl-package->cl-source-package sbcl-cl-utilities))
4053
4054 (define-public sbcl-map-set
4055   (let ((commit "7b4b545b68b8")
4056         (revision "1"))
4057     (package
4058       (name "sbcl-map-set")
4059       (version (git-version "0.0.0" revision commit))
4060       (source
4061        (origin
4062          (method url-fetch)
4063          (uri (string-append
4064                "https://bitbucket.org/tarballs_are_good/map-set/get/"
4065                commit ".tar.gz"))
4066          (sha256
4067           (base32 "1sx5j5qdsy5fklspfammwb16kjrhkggdavm922a9q86jm5l0b239"))))
4068       (build-system asdf-build-system/sbcl)
4069       (home-page "https://bitbucket.org/tarballs_are_good/map-set")
4070       (synopsis "Set-like data structure")
4071       (description
4072        "Implementation of a set-like data structure with constant time
4073 addition, removal, and random selection.")
4074       (license license:bsd-3))))
4075
4076 (define-public cl-map-set
4077   (sbcl-package->cl-source-package sbcl-map-set))
4078
4079 (define-public sbcl-quri
4080   (let ((commit "76b75103f21ead092c9f715512fa82441ef61185")
4081         (revision "1"))
4082     (package
4083       (name "sbcl-quri")
4084       (version (git-version "0.1.0" revision commit))
4085       (source
4086        (origin
4087          (method git-fetch)
4088          (uri (git-reference
4089                (url "https://github.com/fukamachi/quri.git")
4090                (commit commit)))
4091          (file-name (git-file-name name version))
4092          (sha256
4093           (base32 "1ccbxsgzdibmzq33mmbmmz9vwl6l03xh6nbpsh1hkdvdcl7q0a60"))))
4094       (build-system asdf-build-system/sbcl)
4095       (arguments
4096        ;; Tests fail with: Component QURI-ASD::QURI-TEST not found,
4097        ;; required by #<SYSTEM "quri">. Why?
4098        '(#:tests? #f))
4099       (native-inputs `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4100                        ("sbcl-prove" ,sbcl-prove)))
4101       (inputs `(("sbcl-babel" ,sbcl-babel)
4102                 ("sbcl-split-sequence" ,sbcl-split-sequence)
4103                 ("sbcl-cl-utilities" ,sbcl-cl-utilities)
4104                 ("sbcl-alexandria" ,sbcl-alexandria)))
4105       (home-page "https://github.com/fukamachi/quri")
4106       (synopsis "Yet another URI library for Common Lisp")
4107       (description
4108        "QURI (pronounced \"Q-ree\") is yet another URI library for Common
4109 Lisp. It is intended to be a replacement of PURI.")
4110       (license license:bsd-3))))
4111
4112 (define-public cl-quri
4113   (sbcl-package->cl-source-package sbcl-quri))
4114
4115 (define-public sbcl-myway
4116   (let ((commit "286230082a11f879c18b93f17ca571c5f676bfb7")
4117         (revision "1"))
4118     (package
4119      (name "sbcl-myway")
4120      (version (git-version "0.1.0" revision commit))
4121      (source
4122       (origin
4123        (method git-fetch)
4124        (uri (git-reference
4125              (url "https://github.com/fukamachi/myway.git")
4126              (commit commit)))
4127        (file-name (git-file-name "myway" version))
4128        (sha256
4129         (base32 "0briia9bk3lbr0frnx39d1qg6i38dm4j6z9w3yga3d40k6df4a90"))))
4130      (build-system asdf-build-system/sbcl)
4131      (arguments
4132       ;; Tests fail with: Component MYWAY-ASD::MYWAY-TEST not found, required
4133       ;; by #<SYSTEM "myway">. Why?
4134       '(#:tests? #f))
4135      (native-inputs
4136       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4137         ("sbcl-prove" ,sbcl-prove)))
4138      (inputs
4139       `(("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
4140         ("sbcl-quri" ,sbcl-quri)
4141         ("sbcl-map-set" ,sbcl-map-set)))
4142      (home-page "https://github.com/fukamachi/myway")
4143      (synopsis "Sinatra-compatible URL routing library for Common Lisp")
4144      (description "My Way is a Sinatra-compatible URL routing library.")
4145      (license license:llgpl))))
4146
4147 (define-public cl-myway
4148   (sbcl-package->cl-source-package sbcl-myway))
4149
4150 (define-public sbcl-xsubseq
4151   (let ((commit "5ce430b3da5cda3a73b9cf5cee4df2843034422b")
4152         (revision "1"))
4153     (package
4154      (name "sbcl-xsubseq")
4155      (version (git-version "0.0.1" revision commit))
4156      (source
4157       (origin
4158        (method git-fetch)
4159        (uri (git-reference
4160              (url "https://github.com/fukamachi/xsubseq")
4161              (commit commit)))
4162        (file-name (git-file-name name version))
4163        (sha256
4164         (base32 "1xz79q0p2mclf3sqjiwf6izdpb6xrsr350bv4mlmdlm6rg5r99px"))))
4165      (build-system asdf-build-system/sbcl)
4166      (arguments
4167       ;; Tests fail with: Component XSUBSEQ-ASD::XSUBSEQ-TEST not found,
4168       ;; required by #<SYSTEM "xsubseq">. Why?
4169       '(#:tests? #f))
4170      (native-inputs
4171       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4172         ("sbcl-prove" ,sbcl-prove)))
4173      (home-page "https://github.com/fukamachi/xsubseq")
4174      (synopsis "Efficient way to use \"subseq\"s in Common Lisp")
4175      (description
4176       "XSubseq provides functions to be able to handle \"subseq\"s more
4177 effieiently.")
4178      (license license:bsd-2))))
4179
4180 (define-public cl-xsubseq
4181   (sbcl-package->cl-source-package sbcl-xsubseq))
4182
4183 (define-public sbcl-smart-buffer
4184   (let ((commit "09b9a9a0b3abaa37abe9a730f5aac2643dca4e62")
4185         (revision "1"))
4186     (package
4187       (name "sbcl-smart-buffer")
4188       (version (git-version "0.0.1" revision commit))
4189       (source
4190        (origin
4191          (method git-fetch)
4192          (uri (git-reference
4193                (url "https://github.com/fukamachi/smart-buffer")
4194                (commit commit)))
4195          (file-name (git-file-name name version))
4196          (sha256
4197           (base32 "0qz1zzxx0wm5ff7gpgsq550a59p0qj594zfmm2rglj97dahj54l7"))))
4198       (build-system asdf-build-system/sbcl)
4199       (arguments
4200        ;; Tests fail with: Component SMART-BUFFER-ASD::SMART-BUFFER-TEST not
4201        ;; found, required by #<SYSTEM "smart-buffer">. Why?
4202        `(#:tests? #f))
4203       (native-inputs
4204        `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4205          ("sbcl-prove" ,sbcl-prove)))
4206       (inputs
4207        `(("sbcl-xsubseq" ,sbcl-xsubseq)
4208          ("sbcl-flexi-streams" ,sbcl-flexi-streams)))
4209       (home-page "https://github.com/fukamachi/smart-buffer")
4210       (synopsis "Smart octets buffer")
4211       (description
4212        "Smart-buffer provides an output buffer which changes the destination
4213 depending on content size.")
4214       (license license:bsd-3))))
4215
4216 (define-public cl-smart-buffer
4217   (sbcl-package->cl-source-package sbcl-smart-buffer))
4218
4219 (define-public sbcl-fast-http
4220   (let ((commit "502a37715dcb8544cc8528b78143a942de662c5a")
4221         (revision "2"))
4222     (package
4223       (name "sbcl-fast-http")
4224       (version (git-version "0.2.0" revision commit))
4225       (source
4226        (origin
4227          (method git-fetch)
4228          (uri (git-reference
4229                (url "https://github.com/fukamachi/fast-http")
4230                (commit commit)))
4231          (file-name (git-file-name name version))
4232          (sha256
4233           (base32 "0al2g7g219jjljsf7b23pbilpgacxy5as5gs2nqf76b5qni396mi"))))
4234       (build-system asdf-build-system/sbcl)
4235       (arguments
4236        ;; Tests fail with: Component FAST-HTTP-ASD::FAST-HTTP-TEST not found,
4237        ;; required by #<SYSTEM "fast-http">. Why?
4238        `(#:tests? #f))
4239       (native-inputs
4240        `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4241          ("sbcl-prove" ,sbcl-prove)
4242          ("cl-syntax-interpol" ,sbcl-cl-syntax-interpol)))
4243       (inputs
4244        `(("sbcl-alexandria" ,sbcl-alexandria)
4245          ("sbcl-proc-parse" ,sbcl-proc-parse)
4246          ("sbcl-xsubseq" ,sbcl-xsubseq)
4247          ("sbcl-smart-buffer" ,sbcl-smart-buffer)
4248          ("sbcl-cl-utilities" ,sbcl-cl-utilities)))
4249       (home-page "https://github.com/fukamachi/fast-http")
4250       (synopsis "HTTP request/response parser for Common Lisp")
4251       (description
4252        "@code{fast-http} is a HTTP request/response protocol parser for Common
4253 Lisp.")
4254       ;; Author specified the MIT license
4255       (license license:expat))))
4256
4257 (define-public cl-fast-http
4258   (sbcl-package->cl-source-package sbcl-fast-http))
4259
4260 (define-public sbcl-static-vectors
4261   (package
4262     (name "sbcl-static-vectors")
4263     (version "1.8.4")
4264     (source
4265      (origin
4266        (method git-fetch)
4267        (uri (git-reference
4268              (url "https://github.com/sionescu/static-vectors.git")
4269              (commit (string-append "v" version))))
4270        (file-name (git-file-name name version))
4271        (sha256
4272         (base32 "0qvf9z6bhwhm8n45fjwkm7j8dcb58szfvndky65cyn4lpdval7m1"))))
4273     (native-inputs
4274      `(("sbcl-fiveam" ,sbcl-fiveam)))
4275     (inputs
4276      `(("sbcl-cffi-grovel" ,sbcl-cffi-grovel)
4277        ("sbcl-cffi" ,sbcl-cffi)))
4278     (build-system asdf-build-system/sbcl)
4279     (home-page "https://github.com/sionescu/static-vectors")
4280     (synopsis "Allocate SIMPLE-ARRAYs in static memory")
4281     (description
4282      "With @code{static-vectors}, you can create vectors allocated in static
4283 memory.")
4284     (license license:expat)))
4285
4286 (define-public cl-static-vectors
4287   (sbcl-package->cl-source-package sbcl-static-vectors))
4288
4289 (define-public ecl-static-vectors
4290   (sbcl-package->ecl-package sbcl-static-vectors))
4291
4292 (define-public sbcl-marshal
4293   (let ((commit "eff1b15f2b0af2f26f71ad6a4dd5c4beab9299ec")
4294         (revision "1"))
4295     (package
4296      (name "sbcl-marshal")
4297      (version (git-version "1.3.0" revision commit))
4298      (source
4299       (origin
4300        (method git-fetch)
4301        (uri (git-reference
4302              (url "https://github.com/wlbr/cl-marshal.git")
4303              (commit commit)))
4304        (file-name (git-file-name name version))
4305        (sha256
4306         (base32 "08qs6fhk38xpkkjkpcj92mxx0lgy4ygrbbzrmnivdx281syr0gwh"))))
4307      (build-system asdf-build-system/sbcl)
4308      (home-page "https://github.com/wlbr/cl-marshal")
4309      (synopsis "Simple (de)serialization of Lisp datastructures")
4310      (description
4311       "Simple and fast marshalling of Lisp datastructures.  Convert any object
4312 into a string representation, put it on a stream an revive it from there.
4313 Only minimal changes required to make your CLOS objects serializable.")
4314      (license license:expat))))
4315
4316 (define-public cl-marshal
4317   (sbcl-package->cl-source-package sbcl-marshal))
4318
4319 (define-public sbcl-checkl
4320   (let ((commit "80328800d047fef9b6e32dfe6bdc98396aee3cc9")
4321         (revision "1"))
4322     (package
4323       (name "sbcl-checkl")
4324       (version (git-version "0.0.0" revision commit))
4325       (source
4326        (origin
4327          (method git-fetch)
4328          (uri (git-reference
4329                (url "https://github.com/rpav/CheckL.git")
4330                (commit commit)))
4331          (file-name (git-file-name name version))
4332          (sha256
4333           (base32 "0bpisihx1gay44xmyr1dmhlwh00j0zzi04rp9fy35i95l2r4xdlx"))))
4334       (build-system asdf-build-system/sbcl)
4335       (arguments
4336        ;; Error while trying to load definition for system checkl-test from
4337        ;; pathname [...]/checkl-test.asd: The function CHECKL:DEFINE-TEST-OP
4338        ;; is undefined.
4339        '(#:tests? #f))
4340       (native-inputs
4341        `(("sbcl-fiveam" ,sbcl-fiveam)))
4342       (inputs
4343        `(("sbcl-marshal" ,sbcl-marshal)))
4344       (home-page "https://github.com/rpav/CheckL/")
4345       (synopsis "Dynamic testing for Common Lisp")
4346       (description
4347        "CheckL lets you write tests dynamically, it checks resulting values
4348 against the last run.")
4349       ;; The author specifies both LLGPL and "BSD", but the "BSD" license
4350       ;; isn't specified anywhere, so I don't know which kind.  LLGPL is the
4351       ;; stronger of the two and so I think only listing this should suffice.
4352       (license license:llgpl))))
4353
4354 (define-public cl-checkl
4355   (sbcl-package->cl-source-package sbcl-checkl))
4356
4357 (define-public sbcl-fast-io
4358   (let ((commit "603f4903dd74fb221859da7058ae6ca3853fe64b")
4359         (revision "2"))
4360     (package
4361      (name "sbcl-fast-io")
4362      (version (git-version "1.0.0" revision commit))
4363      (source
4364       (origin
4365        (method git-fetch)
4366        (uri (git-reference
4367              (url "https://github.com/rpav/fast-io.git")
4368              (commit commit)))
4369        (file-name (git-file-name name version))
4370        (sha256
4371         (base32 "00agvc0xx4w715i6ach05p995zpcpghn04xc06zyci06q677vw3n"))))
4372      (build-system asdf-build-system/sbcl)
4373      (arguments
4374       ;; Error while trying to load definition for system fast-io-test from
4375       ;; pathname [...]/fast-io-test.asd: The function CHECKL:DEFINE-TEST-OP
4376       ;; is undefined.
4377       '(#:tests? #f))
4378      (native-inputs
4379       `(("sbcl-fiveam" ,sbcl-fiveam)
4380         ("sbcl-checkl" ,sbcl-checkl)))
4381      (inputs
4382       `(("sbcl-alexandria" ,sbcl-alexandria)
4383         ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)
4384         ("sbcl-static-vectors" ,sbcl-static-vectors)))
4385      (home-page "https://github.com/rpav/fast-io")
4386      (synopsis "Fast octet-vector/stream I/O for Common Lisp")
4387      (description
4388       "Fast-io is about improving performance to octet-vectors and octet
4389 streams (though primarily the former, while wrapping the latter).")
4390      ;; Author specifies this as NewBSD which is an alias
4391      (license license:bsd-3))))
4392
4393 (define-public cl-fast-io
4394   (sbcl-package->cl-source-package sbcl-fast-io))
4395
4396 (define-public sbcl-jonathan
4397   (let ((commit "1f448b4f7ac8265e56e1c02b32ce383e65316300")
4398         (revision "1"))
4399     (package
4400      (name "sbcl-jonathan")
4401      (version (git-version "0.1.0" revision commit))
4402      (source
4403       (origin
4404        (method git-fetch)
4405        (uri (git-reference
4406              (url "https://github.com/Rudolph-Miller/jonathan.git")
4407              (commit commit)))
4408        (file-name (git-file-name name version))
4409        (sha256
4410         (base32 "14x4iwz3mbag5jzzzr4sb6ai0m9r4q4kyypbq32jmsk2dx1hi807"))))
4411      (build-system asdf-build-system/sbcl)
4412      (arguments
4413       ;; Tests fail with: Component JONATHAN-ASD::JONATHAN-TEST not found,
4414       ;; required by #<SYSTEM "jonathan">. Why?
4415       `(#:tests? #f))
4416      (native-inputs
4417       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4418         ("sbcl-prove" ,sbcl-prove)))
4419      (inputs
4420       `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
4421         ("sbcl-cl-syntax-annot" ,sbcl-cl-syntax-annot)
4422         ("sbcl-fast-io" ,sbcl-fast-io)
4423         ("sbcl-proc-parse" ,sbcl-proc-parse)
4424         ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)))
4425      (home-page "https://rudolph-miller.github.io/jonathan/overview.html")
4426      (synopsis "JSON encoder and decoder")
4427      (description
4428       "High performance JSON encoder and decoder.  Currently support: SBCL,
4429 CCL.")
4430      ;; Author specifies the MIT license
4431      (license license:expat))))
4432
4433 (define-public cl-jonathan
4434   (sbcl-package->cl-source-package sbcl-jonathan))
4435
4436 (define-public sbcl-http-body
4437   (let ((commit "dd01dc4f5842e3d29728552e5163acce8386eb73")
4438         (revision "1"))
4439     (package
4440      (name "sbcl-http-body")
4441      (version (git-version "0.1.0" revision commit))
4442      (source
4443       (origin
4444        (method git-fetch)
4445        (uri (git-reference
4446              (url "https://github.com/fukamachi/http-body")
4447              (commit commit)))
4448        (file-name (git-file-name name version))
4449        (sha256
4450         (base32 "1jd06snjvxcprhapgfq8sx0y5lrldkvhf206ix6d5a23dd6zcmr0"))))
4451      (build-system asdf-build-system/sbcl)
4452      (arguments
4453       ;; Tests fail with: Component HTTP-BODY-ASD::HTTP-BODY-TEST not
4454       ;; found, required by #<SYSTEM "http-body">. Why?
4455       `(#:tests? #f))
4456      (native-inputs
4457       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4458         ("sbcl-prove" ,sbcl-prove)))
4459      (inputs
4460       `(("sbcl-fast-http" ,sbcl-fast-http)
4461         ("sbcl-jonathan" ,sbcl-jonathan)
4462         ("sbcl-quri" ,sbcl-quri)))
4463      (home-page "https://github.com/fukamachi/http-body")
4464      (synopsis "HTTP POST data parser")
4465      (description
4466       "HTTP-Body parses HTTP POST data and returns POST parameters.  It
4467 supports application/x-www-form-urlencoded, application/json, and
4468 multipart/form-data.")
4469      (license license:bsd-2))))
4470
4471 (define-public cl-http-body
4472   (sbcl-package->cl-source-package sbcl-http-body))
4473
4474 (define-public sbcl-circular-streams
4475   (let ((commit "e770bade1919c5e8533dd2078c93c3d3bbeb38df")
4476         (revision "1"))
4477     (package
4478      (name "sbcl-circular-streams")
4479      (version (git-version "0.1.0" revision commit))
4480      (source
4481       (origin
4482        (method git-fetch)
4483        (uri (git-reference
4484              (url "https://github.com/fukamachi/circular-streams")
4485              (commit commit)))
4486        (file-name (git-file-name name version))
4487        (sha256
4488         (base32 "1wpw6d5cciyqcf92f7mvihak52pd5s47kk4qq6f0r2z2as68p5rs"))))
4489      (build-system asdf-build-system/sbcl)
4490      (arguments
4491       ;; The tests depend on cl-test-more which is now prove. Prove
4492       ;; tests aren't working for some reason.
4493       `(#:tests? #f))
4494      (inputs
4495       `(("sbcl-fast-io" ,sbcl-fast-io)
4496         ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)))
4497      (home-page "https://github.com/fukamachi/circular-streams")
4498      (synopsis "Circularly readable streams for Common Lisp")
4499      (description
4500       "Circular-Streams allows you to read streams circularly by wrapping real
4501 streams. Once you reach end-of-file of a stream, it's file position will be
4502 reset to 0 and you're able to read it again.")
4503      (license license:llgpl))))
4504
4505 (define-public cl-circular-streams
4506   (sbcl-package->cl-source-package sbcl-circular-streams))
4507
4508 (define-public sbcl-lack-request
4509   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4510         (revision "1"))
4511     (package
4512      (name "sbcl-lack-request")
4513      (version (git-version "0.1.0" revision commit))
4514      (source
4515       (origin
4516        (method git-fetch)
4517        (uri (git-reference
4518              (url "https://github.com/fukamachi/lack.git")
4519              (commit commit)))
4520        (file-name (git-file-name "lack-request" version))
4521        (sha256
4522         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4523      (build-system asdf-build-system/sbcl)
4524      (arguments
4525       '(#:asd-file "lack-request.asd"
4526         #:asd-system-name "lack-request"
4527         #:test-asd-file "t-lack-request.asd"
4528         ;; XXX: Component :CLACK-TEST not found
4529         #:tests? #f))
4530      (native-inputs
4531       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4532         ("sbcl-prove" ,sbcl-prove)))
4533      (inputs
4534       `(("sbcl-quri" ,sbcl-quri)
4535         ("sbcl-http-body" ,sbcl-http-body)
4536         ("sbcl-circular-streams" ,sbcl-circular-streams)))
4537      (home-page "https://github.com/fukamachi/lack")
4538      (synopsis "Lack, the core of Clack")
4539      (description
4540       "Lack is a Common Lisp library which allows web applications to be
4541 constructed of modular components.  It was originally a part of Clack, however
4542 it's going to be rewritten as an individual project since Clack v2 with
4543 performance and simplicity in mind.")
4544      (license license:llgpl))))
4545
4546 (define-public cl-lack-request
4547   (sbcl-package->cl-source-package sbcl-lack-request))
4548
4549 (define-public sbcl-local-time
4550   (let ((commit "62792705245168d3fc2e04164b9a143477284142")
4551         (revision "1"))
4552     (package
4553      (name "sbcl-local-time")
4554      (version (git-version "1.0.6" revision commit))
4555      (source
4556       (origin
4557        (method git-fetch)
4558        (uri (git-reference
4559              (url "https://github.com/dlowe-net/local-time.git")
4560              (commit commit)))
4561        (file-name (git-file-name name version))
4562        (sha256
4563         (base32 "1r5zq4l1lrgprdr2pw7wwry194yknnllyjf6lx7snypb3k4r3yir"))))
4564      (build-system asdf-build-system/sbcl)
4565      (arguments
4566       ;; TODO: Component :STEFIL not found, required by #<SYSTEM
4567       ;; "local-time/test">
4568       '(#:tests? #f))
4569      (native-inputs
4570       `(("stefil" ,sbcl-hu.dwim.stefil)))
4571      (inputs
4572       `(("sbcl-cl-fad" ,sbcl-cl-fad)))
4573      (home-page "https://common-lisp.net/project/local-time/")
4574      (synopsis "Time manipulation library for Common Lisp")
4575      (description
4576       "The LOCAL-TIME library is a Common Lisp library for the manipulation of
4577 dates and times.  It is based almost entirely upon Erik Naggum's paper \"The
4578 Long Painful History of Time\".")
4579      (license license:expat))))
4580
4581 (define-public cl-local-time
4582   (sbcl-package->cl-source-package sbcl-local-time))
4583
4584 (define-public sbcl-lack-response
4585   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4586         (revision "1"))
4587     (package
4588      (name "sbcl-lack-response")
4589      (version (git-version "0.1.0" revision commit))
4590      (source
4591       (origin
4592        (method git-fetch)
4593        (uri (git-reference
4594              (url "https://github.com/fukamachi/lack.git")
4595              (commit commit)))
4596        (file-name (git-file-name name version))
4597        (sha256
4598         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4599      (build-system asdf-build-system/sbcl)
4600      (arguments
4601       '(#:asd-file "lack-response.asd"
4602         #:asd-system-name "lack-response"
4603         ;; XXX: no tests for lack-response.
4604         #:tests? #f))
4605      (native-inputs
4606       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4607         ("sbcl-prove" ,sbcl-prove)))
4608      (inputs
4609       `(("sbcl-quri" ,sbcl-quri)
4610         ("sbcl-http-body" ,sbcl-http-body)
4611         ("sbcl-circular-streams" ,sbcl-circular-streams)
4612         ("sbcl-local-time" ,sbcl-local-time)))
4613      (home-page "https://github.com/fukamachi/lack")
4614      (synopsis "Lack, the core of Clack")
4615      (description
4616       "Lack is a Common Lisp library which allows web applications to be
4617 constructed of modular components.  It was originally a part of Clack, however
4618 it's going to be rewritten as an individual project since Clack v2 with
4619 performance and simplicity in mind.")
4620      (license license:llgpl))))
4621
4622 (define-public cl-lack-response
4623   (sbcl-package->cl-source-package sbcl-lack-response))
4624
4625 (define-public sbcl-lack-component
4626   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4627         (revision "1"))
4628     (package
4629      (name "sbcl-lack-component")
4630      (version (git-version "0.0.0" revision commit))
4631      (source
4632       (origin
4633        (method git-fetch)
4634        (uri (git-reference
4635              (url "https://github.com/fukamachi/lack.git")
4636              (commit commit)))
4637        (file-name (git-file-name "lack-component" version))
4638        (sha256
4639         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4640      (build-system asdf-build-system/sbcl)
4641      (arguments
4642       '(#:asd-file "lack-component.asd"
4643         #:asd-system-name "lack-component"
4644         #:test-asd-file "t-lack-component.asd"
4645         ;; XXX: Component :LACK-TEST not found
4646         #:tests? #f))
4647      (native-inputs
4648       `(("prove-asdf" ,sbcl-prove-asdf)))
4649      (home-page "https://github.com/fukamachi/lack")
4650      (synopsis "Lack, the core of Clack")
4651      (description
4652       "Lack is a Common Lisp library which allows web applications to be
4653 constructed of modular components.  It was originally a part of Clack, however
4654 it's going to be rewritten as an individual project since Clack v2 with
4655 performance and simplicity in mind.")
4656      (license license:llgpl))))
4657
4658 (define-public cl-lack-component
4659   (sbcl-package->cl-source-package sbcl-lack-component))
4660
4661 (define-public sbcl-lack-util
4662   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4663         (revision "1"))
4664     (package
4665      (name "sbcl-lack-util")
4666      (version (git-version "0.1.0" revision commit))
4667      (source
4668       (origin
4669        (method git-fetch)
4670        (uri (git-reference
4671              (url "https://github.com/fukamachi/lack.git")
4672              (commit commit)))
4673        (file-name (git-file-name "lack-util" version))
4674        (sha256
4675         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4676      (build-system asdf-build-system/sbcl)
4677      (arguments
4678       '(#:asd-file "lack-util.asd"
4679         #:asd-system-name "lack-util"
4680         #:test-asd-file "t-lack-util.asd"
4681         ;; XXX: Component :LACK-TEST not found
4682         #:tests? #f))
4683      (native-inputs
4684       `(("prove-asdf" ,sbcl-prove-asdf)))
4685      (inputs
4686       `(("sbcl-ironclad" ,sbcl-ironclad)))
4687      (home-page "https://github.com/fukamachi/lack")
4688      (synopsis "Lack, the core of Clack")
4689      (description
4690       "Lack is a Common Lisp library which allows web applications to be
4691 constructed of modular components.  It was originally a part of Clack, however
4692 it's going to be rewritten as an individual project since Clack v2 with
4693 performance and simplicity in mind.")
4694      (license license:llgpl))))
4695
4696 (define-public cl-lack-util
4697   (sbcl-package->cl-source-package sbcl-lack-util))
4698
4699 (define-public sbcl-lack-middleware-backtrace
4700   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4701         (revision "1"))
4702     (package
4703      (name "sbcl-lack-middleware-backtrace")
4704      (version (git-version "0.1.0" revision commit))
4705      (source
4706       (origin
4707        (method git-fetch)
4708        (uri (git-reference
4709              (url "https://github.com/fukamachi/lack.git")
4710              (commit commit)))
4711        (file-name (git-file-name "lack-middleware-backtrace" version))
4712        (sha256
4713         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4714      (build-system asdf-build-system/sbcl)
4715      (arguments
4716       '(#:asd-file "lack-middleware-backtrace.asd"
4717         #:asd-system-name "lack-middleware-backtrace"
4718         #:test-asd-file "t-lack-middleware-backtrace.asd"
4719         ;; XXX: Component :LACK not found
4720         #:tests? #f))
4721      (native-inputs
4722       `(("prove-asdf" ,sbcl-prove-asdf)))
4723      (home-page "https://github.com/fukamachi/lack")
4724      (synopsis "Lack, the core of Clack")
4725      (description
4726       "Lack is a Common Lisp library which allows web applications to be
4727 constructed of modular components.  It was originally a part of Clack, however
4728 it's going to be rewritten as an individual project since Clack v2 with
4729 performance and simplicity in mind.")
4730      (license license:llgpl))))
4731
4732 (define-public cl-lack-middleware-backtrace
4733   (sbcl-package->cl-source-package sbcl-lack-middleware-backtrace))
4734
4735 (define-public sbcl-trivial-mimes
4736   (let ((commit "303f8ac0aa6ca0bc139aa3c34822e623c3723fab")
4737         (revision "1"))
4738     (package
4739       (name "sbcl-trivial-mimes")
4740       (version (git-version "1.1.0" revision commit))
4741       (source
4742        (origin
4743          (method git-fetch)
4744          (uri (git-reference
4745                (url "https://github.com/Shinmera/trivial-mimes.git")
4746                (commit commit)))
4747          (file-name (git-file-name name version))
4748          (sha256
4749           (base32 "17jxgl47r695bvsb7wi3n2ws5rp1zzgvw0zii8cy5ggw4b4ayv6m"))))
4750       (build-system asdf-build-system/sbcl)
4751       (arguments
4752        '(#:phases
4753          (modify-phases %standard-phases
4754            (add-after
4755                'unpack 'fix-paths
4756              (lambda* (#:key inputs #:allow-other-keys)
4757                (let ((anchor "#p\"/etc/mime.types\""))
4758                  (substitute* "mime-types.lisp"
4759                    ((anchor all)
4760                     (string-append
4761                      anchor "\n"
4762                      "(asdf:system-relative-pathname :trivial-mimes "
4763                      "\"../../share/common-lisp/" (%lisp-type)
4764                      "-source/trivial-mimes/mime.types\")")))))))))
4765       (native-inputs
4766        `(("stefil" ,sbcl-hu.dwim.stefil)))
4767       (inputs
4768        `(("sbcl-cl-fad" ,sbcl-cl-fad)))
4769       (home-page "https://shinmera.github.io/trivial-mimes/")
4770       (synopsis "Tiny Common Lisp library to detect mime types in files")
4771       (description
4772        "This is a teensy library that provides some functions to determine the
4773 mime-type of a file.")
4774       (license license:artistic2.0))))
4775
4776 (define-public cl-trivial-mimes
4777   (sbcl-package->cl-source-package sbcl-trivial-mimes))
4778
4779 (define-public ecl-trivial-mimes
4780   (sbcl-package->ecl-package sbcl-trivial-mimes))
4781
4782 (define-public sbcl-lack-middleware-static
4783   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4784         (revision "1"))
4785     (package
4786      (name "sbcl-lack-middleware-static")
4787      (version (git-version "0.1.0" revision commit))
4788      (source
4789       (origin
4790        (method git-fetch)
4791        (uri (git-reference
4792              (url "https://github.com/fukamachi/lack.git")
4793              (commit commit)))
4794        (file-name (git-file-name "lack-middleware-static" version))
4795        (sha256
4796         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4797      (build-system asdf-build-system/sbcl)
4798      (arguments
4799       '(#:asd-file "lack-middleware-static.asd"
4800         #:asd-system-name "lack-middleware-static"
4801         #:test-asd-file "t-lack-middleware-static.asd"
4802         ;; XXX: Component :LACK not found
4803         #:tests? #f))
4804      (native-inputs
4805       `(("prove-asdf" ,sbcl-prove-asdf)))
4806      (inputs
4807       `(("sbcl-ironclad" ,sbcl-ironclad)
4808         ("sbcl-trivial-mimes" ,sbcl-trivial-mimes)
4809         ("sbcl-local-time" ,sbcl-local-time)))
4810      (home-page "https://github.com/fukamachi/lack")
4811      (synopsis "Lack, the core of Clack")
4812      (description
4813       "Lack is a Common Lisp library which allows web applications to be
4814 constructed of modular components.  It was originally a part of Clack, however
4815 it's going to be rewritten as an individual project since Clack v2 with
4816 performance and simplicity in mind.")
4817      (license license:llgpl))))
4818
4819 (define-public cl-lack-middleware-static
4820   (sbcl-package->cl-source-package sbcl-lack-middleware-static))
4821
4822 (define-public sbcl-lack
4823   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4824         (revision "1"))
4825     (package
4826      (name "sbcl-lack")
4827      (version (git-version "0.1.0" revision commit))
4828      (source
4829       (origin
4830        (method git-fetch)
4831        (uri (git-reference
4832              (url "https://github.com/fukamachi/lack.git")
4833              (commit commit)))
4834        (file-name (git-file-name "lack" version))
4835        (sha256
4836         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4837      (build-system asdf-build-system/sbcl)
4838      (arguments
4839       '(#:test-asd-file "t-lack.asd"
4840         ;; XXX: Component :CLACK not found
4841         #:tests? #f))
4842      (native-inputs
4843       `(("prove-asdf" ,sbcl-prove-asdf)))
4844      (inputs
4845       `(("sbcl-lack-component" ,sbcl-lack-component)
4846         ("sbcl-lack-util" ,sbcl-lack-util)))
4847      (home-page "https://github.com/fukamachi/lack")
4848      (synopsis "Lack, the core of Clack")
4849      (description
4850       "Lack is a Common Lisp library which allows web applications to be
4851 constructed of modular components.  It was originally a part of Clack, however
4852 it's going to be rewritten as an individual project since Clack v2 with
4853 performance and simplicity in mind.")
4854      (license license:llgpl))))
4855
4856 (define-public cl-lack
4857   (sbcl-package->cl-source-package sbcl-lack))
4858
4859 (define-public sbcl-ningle
4860   (let ((commit "50bd4f09b5a03a7249bd4d78265d6451563b25ad")
4861         (revision "1"))
4862     (package
4863       (name "sbcl-ningle")
4864       (version (git-version "0.3.0" revision commit))
4865       (source
4866        (origin
4867          (method git-fetch)
4868          (uri (git-reference
4869                (url "https://github.com/fukamachi/ningle.git")
4870                (commit commit)))
4871          (file-name (git-file-name name version))
4872          (sha256
4873           (base32 "1bsl8cnxhacb8p92z9n89vhk1ikmij5zavk0m2zvmj7iqm79jzgw"))))
4874       (build-system asdf-build-system/sbcl)
4875       (arguments
4876        ;; TODO: pull in clack-test
4877        '(#:tests? #f
4878          #:phases
4879          (modify-phases %standard-phases
4880            (delete 'cleanup-files)
4881            (delete 'cleanup)
4882            (add-before 'cleanup 'combine-fasls
4883              (lambda* (#:key outputs #:allow-other-keys)
4884                (let* ((out (assoc-ref outputs "out"))
4885                       (lib (string-append out "/lib/sbcl"))
4886                       (ningle-path (string-append lib "/ningle"))
4887                       (fasl-files (find-files out "\\.fasl$")))
4888                  (mkdir-p ningle-path)
4889                  (let ((fasl-path (lambda (name)
4890                                     (string-append ningle-path
4891                                                    "/"
4892                                                    (basename name)
4893                                                    "--system.fasl"))))
4894                    (for-each (lambda (file)
4895                                (rename-file file
4896                                             (fasl-path
4897                                              (basename file ".fasl"))))
4898                              fasl-files))
4899                  fasl-files)
4900                #t)))))
4901       (native-inputs
4902        `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4903          ("sbcl-prove" ,sbcl-prove)))
4904       (inputs
4905        `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
4906          ("sbcl-cl-syntax-annot" ,sbcl-cl-syntax-annot)
4907          ("sbcl-myway" ,sbcl-myway)
4908          ("sbcl-lack-request" ,sbcl-lack-request)
4909          ("sbcl-lack-response" ,sbcl-lack-response)
4910          ("sbcl-lack-component" ,sbcl-lack-component)
4911          ("sbcl-alexandria" ,sbcl-alexandria)
4912          ("sbcl-babel" ,sbcl-babel)))
4913       (home-page "https://8arrow.org/ningle/")
4914       (synopsis "Super micro framework for Common Lisp")
4915       (description
4916        "Ningle is a lightweight web application framework for Common Lisp.")
4917       (license license:llgpl))))
4918
4919 (define-public cl-ningle
4920   (sbcl-package->cl-source-package sbcl-ningle))
4921
4922 (define-public sbcl-clack
4923   (let ((commit "e3e032843bb1220ab96263c411aa7f2feb4746e0")
4924         (revision "1"))
4925     (package
4926      (name "sbcl-clack")
4927      (version (git-version "2.0.0" revision commit))
4928      (source
4929       (origin
4930        (method git-fetch)
4931        (uri (git-reference
4932              (url "https://github.com/fukamachi/clack.git")
4933              (commit commit)))
4934        (file-name (git-file-name name version))
4935        (sha256
4936         (base32 "1ymzs6qyrwhlj6cgqsnpyn6g5cbp7a3s1vgxwna20y2q7y4iacy0"))))
4937      (build-system asdf-build-system/sbcl)
4938      (inputs
4939       `(("sbcl-lack" ,sbcl-lack)
4940         ("sbcl-lack-middleware-backtrace" ,sbcl-lack-middleware-backtrace)
4941         ("sbcl-bordeaux-threads" ,sbcl-bordeaux-threads)))
4942      (home-page "https://github.com/fukamachi/clack")
4943      (synopsis "Web Application Environment for Common Lisp")
4944      (description
4945       "Clack is a web application environment for Common Lisp inspired by
4946 Python's WSGI and Ruby's Rack.")
4947      (license license:llgpl))))
4948
4949 (define-public cl-clack
4950   (sbcl-package->cl-source-package sbcl-clack))
4951
4952 (define-public sbcl-log4cl
4953   (let ((commit "611e094458504b938d49de904eab141285328c7c")
4954         (revision "1"))
4955     (package
4956       (name "sbcl-log4cl")
4957       (build-system asdf-build-system/sbcl)
4958       (version "1.1.2")
4959       (source
4960        (origin
4961          (method git-fetch)
4962          (uri (git-reference
4963                (url "https://github.com/sharplispers/log4cl")
4964                (commit commit)))
4965          (file-name (git-file-name name version))
4966          (sha256
4967           (base32
4968            "08jly0s0g26b56hhpfizxsb4j0yvbh946sd205gr42dkzv8l7dsc"))))
4969       ;; FIXME: tests require stefil, sbcl-hu.dwim.stefil wont work
4970       (arguments
4971        `(#:tests? #f))
4972       (inputs `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
4973       (synopsis "Common Lisp logging framework, modeled after Log4J")
4974       (home-page "https://github.com/7max/log4cl")
4975       (description "This is a Common Lisp logging framework that can log at
4976 various levels and mix text with expressions.")
4977       (license license:asl2.0))))
4978
4979 (define-public cl-log4cl
4980   (sbcl-package->cl-source-package sbcl-log4cl))
4981
4982 (define-public ecl-log4cl
4983   (sbcl-package->ecl-package sbcl-log4cl))
4984
4985 (define-public sbcl-find-port
4986   (let ((commit "00c96a25af93a0f8681d34ec548861f2d7485478")
4987         (revision "1"))
4988     (package
4989       (name "sbcl-find-port")
4990       (build-system asdf-build-system/sbcl)
4991       (version "0.1")
4992       (home-page "https://github.com/eudoxia0/find-port")
4993       (source
4994        (origin
4995          (method git-fetch)
4996          (uri (git-reference
4997                (url home-page)
4998                (commit commit)))
4999          (file-name (git-file-name name version))
5000          (sha256
5001           (base32
5002            "0d6dzbb45jh0rx90wgs6v020k2xa87mvzas3mvfzvivjvqqlpryq"))))
5003       (native-inputs
5004        `(("fiveam" ,sbcl-fiveam)))
5005       (inputs
5006        `(("sbcl-usocket" ,sbcl-usocket)))
5007       (synopsis "Find open ports programmatically in Common Lisp")
5008       (description "This is a small Common Lisp library that finds an open
5009 port within a range.")
5010       (license license:expat))))
5011
5012 (define-public cl-find-port
5013   (sbcl-package->cl-source-package sbcl-find-port))
5014
5015 (define-public ecl-find-port
5016   (sbcl-package->ecl-package sbcl-find-port))
5017
5018 (define-public sbcl-clunit
5019   (let ((commit "6f6d72873f0e1207f037470105969384f8380628")
5020         (revision "1"))
5021     (package
5022       (name "sbcl-clunit")
5023       (version (git-version "0.2.3" revision commit))
5024       (source
5025        (origin
5026          (method git-fetch)
5027          (uri (git-reference
5028                (url "https://github.com/tgutu/clunit.git")
5029                (commit commit)))
5030          (file-name (git-file-name name version))
5031          (sha256
5032           (base32
5033            "1idf2xnqzlhi8rbrqmzpmb3i1l6pbdzhhajkmhwbp6qjkmxa4h85"))))
5034       (build-system asdf-build-system/sbcl)
5035       (synopsis "CLUnit is a Common Lisp unit testing framework")
5036       (description
5037        "CLUnit is a Common Lisp unit testing framework.  It is designed
5038 to be easy to use so that you can quickly start testing.  CLUnit
5039 provides a rich set of features aimed at improving your unit testing
5040 experience.")
5041       (home-page "https://tgutu.github.io/clunit/")
5042       ;; MIT License
5043       (license license:expat))))
5044
5045 (define-public cl-clunit
5046   (sbcl-package->cl-source-package sbcl-clunit))
5047
5048 (define-public ecl-clunit
5049   (sbcl-package->ecl-package sbcl-clunit))
5050
5051 (define-public sbcl-py4cl
5052   (let ((commit "4c8a2b0814fd311f978964f825ce012290f60136")
5053         (revision "1"))
5054     (package
5055       (name "sbcl-py4cl")
5056       (version (git-version "0.0.0" revision commit))
5057       (source
5058        (origin
5059          (method git-fetch)
5060          (uri (git-reference
5061                (url "https://github.com/bendudson/py4cl.git")
5062                (commit commit)))
5063          (file-name (git-file-name name version))
5064          (sha256
5065           (base32
5066            "15mk7qdqjkj56gdnbyrdyz6r7m1h26ldvn6ch96pmvg5vmr1m45r"))
5067          (modules '((guix build utils)))))
5068       (build-system asdf-build-system/sbcl)
5069       (native-inputs
5070        `(("sbcl-clunit" ,sbcl-clunit)))
5071       (inputs
5072        `(("sbcl-trivial-garbage" ,sbcl-trivial-garbage)))
5073       (propagated-inputs
5074        ;; This package doesn't do anything without python available
5075        `(("python" ,python)
5076          ;; For multi-dimensional array support
5077          ("python-numpy" ,python-numpy)))
5078       (arguments
5079        '(#:phases
5080          (modify-phases %standard-phases
5081            (add-after 'unpack 'replace-*base-directory*-var
5082              (lambda* (#:key outputs #:allow-other-keys)
5083                ;; In the ASD, the author makes an attempt to
5084                ;; programatically determine the location of the
5085                ;; source-code so lisp can call into "py4cl.py". We can
5086                ;; hard-code this since we know where this file will
5087                ;; reside.
5088                (substitute* "src/callpython.lisp"
5089                  (("py4cl/config:\\*base-directory\\*")
5090                   (string-append
5091                    "\""
5092                    (assoc-ref outputs "out")
5093                    "/share/common-lisp/sbcl-source/py4cl/"
5094                    "\""))))))))
5095       (synopsis "Call python from Common Lisp")
5096       (description
5097        "Py4CL is a bridge between Common Lisp and Python, which enables Common
5098 Lisp to interact with Python code.  It uses streams to communicate with a
5099 separate python process, the approach taken by cl4py.  This is different to
5100 the CFFI approach used by burgled-batteries, but has the same goal.")
5101       (home-page "https://github.com/bendudson/py4cl")
5102       ;; MIT License
5103       (license license:expat))))
5104
5105 (define-public cl-py4cl
5106   (sbcl-package->cl-source-package sbcl-py4cl))
5107
5108 (define-public ecl-py4cl
5109   (sbcl-package->ecl-package sbcl-py4cl))
5110
5111 (define-public sbcl-parse-declarations
5112   (let ((commit "549aebbfb9403a7fe948654126b9c814f443f4f2")
5113         (revision "1"))
5114     (package
5115       (name "sbcl-parse-declarations")
5116       (version (git-version "1.0.0" revision commit))
5117       (source
5118        (origin
5119          (method git-fetch)
5120          (uri (git-reference
5121                (url (string-append
5122                      "https://gitlab.common-lisp.net/parse-declarations/"
5123                      "parse-declarations.git"))
5124                (commit commit)))
5125          (file-name (git-file-name name version))
5126          (sha256
5127           (base32 "03g5qks4c59nmxa48pbslxkfh77h8hn8566jddp6m9pl15dzzpxd"))))
5128       (build-system asdf-build-system/sbcl)
5129       (arguments
5130        `(#:asd-file "parse-declarations-1.0.asd"
5131          #:asd-system-name "parse-declarations-1.0"))
5132       (home-page "https://common-lisp.net/project/parse-declarations/")
5133       (synopsis "Parse, filter, and build declarations")
5134       (description
5135        "Parse-Declarations is a Common Lisp library to help writing
5136 macros which establish bindings.  To be semantically correct, such
5137 macros must take user declarations into account, as these may affect
5138 the bindings they establish.  Yet the ANSI standard of Common Lisp does
5139 not provide any operators to work with declarations in a convenient,
5140 high-level way.  This library provides such operators.")
5141       ;; MIT License
5142       (license license:expat))))
5143
5144 (define-public cl-parse-declarations
5145   (sbcl-package->cl-source-package sbcl-parse-declarations))
5146
5147 (define-public ecl-parse-declarations
5148   (sbcl-package->ecl-package sbcl-parse-declarations))
5149
5150 (define-public sbcl-cl-quickcheck
5151   (let ((commit "807b2792a30c883a2fbecea8e7db355b50ba662f")
5152         (revision "1"))
5153     (package
5154       (name "sbcl-cl-quickcheck")
5155       (version (git-version "0.0.4" revision commit))
5156       (source
5157        (origin
5158          (method git-fetch)
5159          (uri (git-reference
5160                (url "https://github.com/mcandre/cl-quickcheck.git")
5161                (commit commit)))
5162          (file-name (git-file-name name version))
5163          (sha256
5164           (base32
5165            "165lhypq5xkcys6hvzb3jq7ywnmqvzaflda29qk2cbs3ggas4767"))))
5166       (build-system asdf-build-system/sbcl)
5167       (synopsis
5168        "Common Lisp port of the QuickCheck unit test framework")
5169       (description
5170        "Common Lisp port of the QuickCheck unit test framework")
5171       (home-page "https://github.com/mcandre/cl-quickcheck")
5172       ;; MIT
5173       (license license:expat))))
5174
5175 (define-public cl-cl-quickcheck
5176   (sbcl-package->cl-source-package sbcl-cl-quickcheck))
5177
5178 (define-public ecl-cl-quickcheck
5179   (sbcl-package->ecl-package sbcl-cl-quickcheck))
5180
5181 (define-public sbcl-burgled-batteries3
5182   (let ((commit "f65f454d13bb6c40e17e9ec62e41eb5069e09760")
5183         (revision "2"))
5184     (package
5185       (name "sbcl-burgled-batteries3")
5186       (version (git-version "0.0.0" revision commit))
5187       (source
5188        (origin
5189          (method git-fetch)
5190          (uri (git-reference
5191                (url "https://github.com/snmsts/burgled-batteries3.git")
5192                (commit commit)))
5193          (file-name (git-file-name name version))
5194          (sha256
5195           (base32
5196            "1nzn7jawrfajyzwfnzrg2cmn9xxadcqh4szbpg0jggkhdkdzz4wa"))))
5197       (build-system asdf-build-system/sbcl)
5198       (arguments
5199        `(#:tests? #f
5200          #:modules (((guix build python-build-system) #:select (python-version))
5201                     ,@%asdf-build-system-modules)
5202          #:imported-modules ((guix build python-build-system)
5203                              ,@%asdf-build-system-modules)
5204          #:phases
5205          (modify-phases (@ (guix build asdf-build-system) %standard-phases)
5206            (add-after 'unpack 'set-*cpython-include-dir*-var
5207              (lambda* (#:key inputs #:allow-other-keys)
5208                (let ((python (assoc-ref inputs "python")))
5209                  (setenv "BB_PYTHON3_INCLUDE_DIR"
5210                          (string-append python "/include/python"
5211                                         (python-version python)
5212                                         "m"))
5213                  (setenv "BB_PYTHON3_DYLIB"
5214                          (string-append python "/lib/libpython3.so"))
5215                  #t))))))
5216       (native-inputs
5217        `(("sbcl-cl-fad" ,sbcl-cl-fad)
5218          ("sbcl-lift" ,sbcl-lift)
5219          ("sbcl-cl-quickcheck" ,sbcl-cl-quickcheck)))
5220       (inputs
5221        `(("python" ,python)
5222          ("sbcl-cffi" ,sbcl-cffi)
5223          ("sbcl-cffi-grovel" ,sbcl-cffi-grovel)
5224          ("sbcl-alexandria" , sbcl-alexandria)
5225          ("sbcl-parse-declarations-1.0" ,sbcl-parse-declarations)
5226          ("sbcl-trivial-garbage" ,sbcl-trivial-garbage)))
5227       (synopsis "Bridge between Python and Lisp (FFI bindings, etc.)")
5228       (description
5229        "This package provides a shim between Python3 (specifically, the
5230 CPython implementation of Python) and Common Lisp.")
5231       (home-page "https://github.com/snmsts/burgled-batteries3")
5232       (license license:expat))))
5233
5234 (define-public cl-burgled-batteries3
5235   (sbcl-package->cl-source-package sbcl-burgled-batteries3))
5236
5237 (define-public ecl-burgled-batteries3
5238   (sbcl-package->ecl-package sbcl-burgled-batteries3))
5239
5240 (define-public sbcl-metabang-bind
5241   (let ((commit "c93b7f7e1c18c954c2283efd6a7fdab36746ab5e")
5242         (revision "1"))
5243     (package
5244       (name "sbcl-metabang-bind")
5245       (version (git-version "0.8.0" revision commit))
5246       (source
5247        (origin
5248          (method git-fetch)
5249          (uri (git-reference
5250                (url "https://github.com/gwkkwg/metabang-bind.git")
5251                (commit commit)))
5252          (file-name (git-file-name name version))
5253          (sha256
5254           (base32
5255            "0hd0kr91795v77akpbcyqiss9p0p7ypa9dznrllincnmgvsxlmf0"))))
5256       (build-system asdf-build-system/sbcl)
5257       (native-inputs
5258        `(("sbcl-lift" ,sbcl-lift)))
5259       (synopsis "Macro that generalizes @code{multiple-value-bind} etc.")
5260       (description
5261        "Bind extends the idea of of let and destructing to provide a uniform
5262 syntax for all your accessor needs.  It combines @code{let},
5263 @code{destructuring-bind}, @code{with-slots}, @code{with-accessors}, structure
5264 editing, property or association-lists, and @code{multiple-value-bind} and a
5265 whole lot more into a single form.")
5266       (home-page "https://common-lisp.net/project/metabang-bind/")
5267       ;; MIT License
5268       (license license:expat))))
5269
5270 (define-public cl-metabang-bind
5271   (sbcl-package->cl-source-package sbcl-metabang-bind))
5272
5273 (define-public ecl-metabang-bind
5274   (sbcl-package->ecl-package sbcl-metabang-bind))
5275
5276 (define-public sbcl-fare-utils
5277   (let ((commit "66e9c6f1499140bc00ccc22febf2aa528cbb5724")
5278         (revision "1"))
5279     (package
5280       (name "sbcl-fare-utils")
5281       (version (git-version "1.0.0.5" revision commit))
5282       (source
5283        (origin
5284          (method git-fetch)
5285          (uri
5286           (git-reference
5287            (url
5288             "https://gitlab.common-lisp.net/frideau/fare-utils.git")
5289            (commit commit)))
5290          (file-name (git-file-name name version))
5291          (sha256
5292           (base32
5293            "01wsr1aap3jdzhn4hrqjbhsjx6qci9dbd3gh4gayv1p49rbg8aqr"))))
5294       (build-system asdf-build-system/sbcl)
5295       (arguments
5296        `(#:test-asd-file "test/fare-utils-test.asd"))
5297       (native-inputs
5298        `(("sbcl-hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
5299       (synopsis "Collection of utilities and data structures")
5300       (description
5301        "fare-utils is a small collection of utilities.  It contains a lot of
5302 basic everyday functions and macros.")
5303       (home-page "https://gitlab.common-lisp.net/frideau/fare-utils")
5304       ;; MIT License
5305       (license license:expat))))
5306
5307 (define-public cl-fare-utils
5308   (sbcl-package->cl-source-package sbcl-fare-utils))
5309
5310 (define-public ecl-fare-utils
5311   (sbcl-package->ecl-package sbcl-fare-utils))
5312
5313 (define-public sbcl-trivial-utf-8
5314   (let ((commit "4d427cfbb1c452436a0efb71c3205c9da67f718f")
5315         (revision "1"))
5316     (package
5317       (name "sbcl-trivial-utf-8")
5318       (version (git-version "0.0.0" revision commit))
5319       (source
5320        (origin
5321          (method git-fetch)
5322          (uri
5323           (git-reference
5324            (url (string-append "https://gitlab.common-lisp.net/"
5325                                "trivial-utf-8/trivial-utf-8.git"))
5326            (commit commit)))
5327          (file-name (git-file-name name version))
5328          (sha256
5329           (base32
5330            "1jz27gz8gvqdmvp3k9bxschs6d5b3qgk94qp2bj6nv1d0jc3m1l1"))))
5331       (arguments
5332        ;; Guix incorrectly assumes the "8" is part of the version
5333        ;; number and lobs it off.
5334        `(#:asd-file "trivial-utf-8.asd"
5335          #:asd-system-name "trivial-utf-8"))
5336       (build-system asdf-build-system/sbcl)
5337       (synopsis "UTF-8 input/output library")
5338       (description
5339        "The Babel library solves a similar problem while understanding more
5340 encodings.  Trivial UTF-8 was written before Babel existed, but for new
5341 projects you might be better off going with Babel.  The one plus that Trivial
5342 UTF-8 has is that it doesn't depend on any other libraries.")
5343       (home-page "https://common-lisp.net/project/trivial-utf-8/")
5344       (license license:bsd-3))))
5345
5346 (define-public cl-trivial-utf-8
5347   (sbcl-package->cl-source-package sbcl-trivial-utf-8))
5348
5349 (define-public ecl-trivial-utf-8
5350   (sbcl-package->ecl-package sbcl-trivial-utf-8))
5351
5352 (define-public sbcl-idna
5353   (package
5354     (name "sbcl-idna")
5355     (build-system asdf-build-system/sbcl)
5356     (version "0.2.2")
5357     (home-page "https://github.com/antifuchs/idna")
5358     (source
5359      (origin
5360        (method git-fetch)
5361        (uri (git-reference
5362              (url home-page)
5363              (commit version)))
5364        (file-name (git-file-name name version))
5365        (sha256
5366         (base32
5367          "00nbr3mffxhlq14gg9d16pa6691s4qh35inyw76v906s77khm5a2"))))
5368     (inputs
5369      `(("split-sequence" ,sbcl-split-sequence)))
5370     (synopsis "IDNA string encoding and decoding routines for Common Lisp")
5371     (description "This Common Lisp library provides string encoding and
5372 decoding routines for IDNA, the International Domain Names in Applications.")
5373     (license license:expat)))
5374
5375 (define-public cl-idna
5376   (sbcl-package->cl-source-package sbcl-idna))
5377
5378 (define-public ecl-idna
5379   (sbcl-package->ecl-package sbcl-idna))
5380
5381 (define-public sbcl-swap-bytes
5382   (package
5383     (name "sbcl-swap-bytes")
5384     (build-system asdf-build-system/sbcl)
5385     (version "1.2")
5386     (home-page "https://github.com/sionescu/swap-bytes")
5387     (source
5388      (origin
5389        (method git-fetch)
5390        (uri (git-reference
5391              (url home-page)
5392              (commit (string-append "v" version))))
5393        (file-name (git-file-name name version))
5394        (sha256
5395         (base32
5396          "1hw1v1lw26rifyznpnj1csphha9jgzwpiic16ni3pvs6hcsni9rz"))))
5397     (inputs
5398      `(("trivial-features" ,sbcl-trivial-features)))
5399     (native-inputs
5400      `(("fiveam" ,sbcl-fiveam)))
5401     (synopsis "Efficient endianness conversion for Common Lisp")
5402     (description "This Common Lisp library provides optimized byte-swapping
5403 primitives.  The library can change endianness of unsigned integers of length
5404 1/2/4/8.  Very useful in implementing various network protocols and file
5405 formats.")
5406     (license license:expat)))
5407
5408 (define-public cl-swap-bytes
5409   (sbcl-package->cl-source-package sbcl-swap-bytes))
5410
5411 (define-public ecl-swap-bytes
5412   (sbcl-package->ecl-package sbcl-swap-bytes))
5413
5414 (define-public sbcl-iolib.asdf
5415   ;; Latest release is from June 2017.
5416   (let ((commit "7f5ea3a8457a29d224b24653c2b3657fb1898021")
5417         (revision "2"))
5418     (package
5419       (name "sbcl-iolib.asdf")
5420       (build-system asdf-build-system/sbcl)
5421       (version (git-version "0.8.3" revision commit))
5422       (home-page "https://github.com/sionescu/iolib")
5423       (source
5424        (origin
5425          (method git-fetch)
5426          (uri (git-reference
5427                (url home-page)
5428                (commit commit)))
5429          (file-name (git-file-name name version))
5430          (sha256
5431           (base32
5432            "1bg5w7lm61hqk4b0svmri8a590q36z76jfa0sdgzb39r98c04w12"))))
5433       (inputs
5434        `(("alexandria" ,sbcl-alexandria)))
5435       (arguments
5436        '(#:asd-file "iolib.asdf.asd"))
5437       (synopsis "ASDF component classes for IOLib, a Common Lisp I/O library")
5438       (description "IOlib is to be a better and more modern I/O library than
5439 the standard Common Lisp library.  It contains a socket library, a DNS
5440 resolver, an I/O multiplexer(which supports @code{select(2)}, @code{epoll(4)}
5441 and @code{kqueue(2)}), a pathname library and file-system utilities.")
5442       (license license:expat))))
5443
5444 (define-public sbcl-iolib.conf
5445   (package
5446     (inherit sbcl-iolib.asdf)
5447     (name "sbcl-iolib.conf")
5448     (inputs
5449      `(("iolib.asdf" ,sbcl-iolib.asdf)))
5450     (arguments
5451      '(#:asd-file "iolib.conf.asd"))
5452     (synopsis "Compile-time configuration for IOLib, a Common Lisp I/O library")))
5453
5454 (define-public sbcl-iolib.common-lisp
5455   (package
5456     (inherit sbcl-iolib.asdf)
5457     (name "sbcl-iolib.common-lisp")
5458     (inputs
5459      `(("iolib.asdf" ,sbcl-iolib.asdf)
5460        ("iolib.conf" ,sbcl-iolib.conf)))
5461     (arguments
5462      '(#:asd-file "iolib.common-lisp.asd"))
5463     (synopsis "Slightly modified Common Lisp for IOLib, a Common Lisp I/O library")))
5464
5465 (define-public sbcl-iolib.base
5466   (package
5467     (inherit sbcl-iolib.asdf)
5468     (name "sbcl-iolib.base")
5469     (inputs
5470      `(("iolib.asdf" ,sbcl-iolib.asdf)
5471        ("iolib.conf" ,sbcl-iolib.conf)
5472        ("iolib.common-lisp" ,sbcl-iolib.common-lisp)
5473        ("split-sequence" ,sbcl-split-sequence)))
5474     (arguments
5475      '(#:asd-file "iolib.base.asd"))
5476     (synopsis "Base package for IOLib, a Common Lisp I/O library")))
5477
5478 (define-public sbcl-iolib.grovel
5479   (package
5480     (inherit sbcl-iolib.asdf)
5481     (name "sbcl-iolib.grovel")
5482     (inputs
5483      `(("iolib.asdf" ,sbcl-iolib.asdf)
5484        ("iolib.conf" ,sbcl-iolib.conf)
5485        ("iolib.base", sbcl-iolib.base)
5486        ("cffi", sbcl-cffi)))
5487     (arguments
5488      '(#:asd-file "iolib.grovel.asd"
5489        #:phases
5490        (modify-phases %standard-phases
5491          (add-after 'install 'install-header
5492            (lambda* (#:key outputs #:allow-other-keys)
5493              ;; This header is required by sbcl-iolib.
5494              (install-file "src/grovel/grovel-common.h"
5495                            (string-append (assoc-ref outputs "out")
5496                                           "/lib/sbcl"))
5497              #t)))))
5498     (synopsis "CFFI Groveller for IOLib, a Common Lisp I/O library")))
5499
5500 (define sbcl-iolib+syscalls
5501   (package
5502     (inherit sbcl-iolib.asdf)
5503     (name "sbcl-iolib+syscalls")
5504     (inputs
5505      `(("iolib.asdf" ,sbcl-iolib.asdf)
5506        ("iolib.conf" ,sbcl-iolib.conf)
5507        ("cffi-grovel" ,sbcl-cffi-grovel)
5508        ("iolib.base" ,sbcl-iolib.base)
5509        ("bordeaux-threads" ,sbcl-bordeaux-threads)
5510        ("idna" ,sbcl-idna)
5511        ("swap-bytes" ,sbcl-swap-bytes)
5512        ("libfixposix" ,libfixposix)
5513        ("cffi" ,sbcl-cffi)))
5514     (native-inputs
5515      `(("fiveam" ,sbcl-fiveam)))
5516     (arguments
5517      '(#:asd-file "iolib.asd"
5518        #:asd-system-name "iolib/syscalls"
5519        #:phases
5520        (modify-phases %standard-phases
5521          (add-after 'unpack 'fix-paths
5522            (lambda* (#:key inputs #:allow-other-keys)
5523              (substitute* "src/syscalls/ffi-functions-unix.lisp"
5524                (("\\(:default \"libfixposix\"\\)")
5525                 (string-append
5526                  "(:default \""
5527                  (assoc-ref inputs "libfixposix") "/lib/libfixposix\")")))
5528              ;; Socket tests need Internet access, disable them.
5529              (substitute* "iolib.asd"
5530                (("\\(:file \"sockets\" :depends-on \\(\"pkgdcl\" \"defsuites\"\\)\\)")
5531                 "")))))))
5532     (synopsis "Common Lisp I/O library")))
5533
5534 (define sbcl-iolib+multiplex
5535   (package
5536     (inherit sbcl-iolib+syscalls)
5537     (name "sbcl-iolib+multiplex")
5538     (inputs
5539      `(("iolib+syscalls" ,sbcl-iolib+syscalls)
5540        ,@(package-inputs sbcl-iolib+syscalls)))
5541     (arguments
5542      (substitute-keyword-arguments (package-arguments sbcl-iolib+syscalls)
5543        ((#:asd-system-name _) "iolib/multiplex")))))
5544
5545 (define sbcl-iolib+streams
5546   (package
5547     (inherit sbcl-iolib+syscalls)
5548     (name "sbcl-iolib+streams")
5549     (inputs
5550      `(("iolib+multiplex" ,sbcl-iolib+multiplex)
5551        ,@(package-inputs sbcl-iolib+syscalls)))
5552     (arguments
5553      (substitute-keyword-arguments (package-arguments sbcl-iolib+syscalls)
5554        ((#:asd-system-name _) "iolib/streams")))))
5555
5556 (define sbcl-iolib+sockets
5557   (package
5558     (inherit sbcl-iolib+syscalls)
5559     (name "sbcl-iolib+sockets")
5560     (inputs
5561      `(("iolib+syscalls" ,sbcl-iolib+syscalls)
5562        ("iolib+streams" ,sbcl-iolib+streams)
5563        ,@(package-inputs sbcl-iolib+syscalls)))
5564     (arguments
5565      (substitute-keyword-arguments (package-arguments sbcl-iolib+syscalls)
5566        ((#:asd-system-name _) "iolib/sockets")))))
5567
5568 (define-public sbcl-iolib
5569   (package
5570     (inherit sbcl-iolib+syscalls)
5571     (name "sbcl-iolib")
5572     (inputs
5573      `(("iolib+multiplex" ,sbcl-iolib+multiplex)
5574        ("iolib+streams" ,sbcl-iolib+streams)
5575        ("iolib+sockets" ,sbcl-iolib+sockets)
5576        ,@(package-inputs sbcl-iolib+syscalls)))
5577     (arguments
5578      (substitute-keyword-arguments (package-arguments sbcl-iolib+syscalls)
5579        ((#:asd-system-name _) "iolib")))))
5580
5581 (define-public cl-iolib
5582   (sbcl-package->cl-source-package sbcl-iolib))
5583
5584 (define-public sbcl-ieee-floats
5585   (let ((commit "566b51a005e81ff618554b9b2f0b795d3b29398d")
5586         (revision "1"))
5587     (package
5588       (name "sbcl-ieee-floats")
5589       (build-system asdf-build-system/sbcl)
5590       (version (git-version "20170924" revision commit))
5591       (home-page "https://github.com/marijnh/ieee-floats/")
5592       (source
5593        (origin
5594          (method git-fetch)
5595          (uri (git-reference
5596                (url home-page)
5597                (commit commit)))
5598          (file-name (git-file-name name version))
5599          (sha256
5600           (base32
5601            "1xyj49j9x3lc84cv3dhbf9ja34ywjk1c46dklx425fxw9mkwm83m"))))
5602       (native-inputs
5603        `(("fiveam" ,sbcl-fiveam)))
5604       (synopsis "IEEE 754 binary representation for floats in Common Lisp")
5605       (description "This is a Common Lisp library that converts
5606 floating point values to IEEE 754 binary representation.")
5607       (license license:bsd-3))))
5608
5609 (define-public cl-ieee-floats
5610   (sbcl-package->cl-source-package sbcl-ieee-floats))
5611
5612 (define sbcl-closure-common
5613   (let ((commit "e3c5f5f454b72b01b89115e581c3c52a7e201e5c")
5614         (revision "1"))
5615     (package
5616       (name "sbcl-closure-common")
5617       (build-system asdf-build-system/sbcl)
5618       (version (git-version "20101006" revision commit))
5619       (home-page "https://common-lisp.net/project/cxml/")
5620       (source
5621        (origin
5622          (method git-fetch)
5623          (uri (git-reference
5624                (url "https://github.com/sharplispers/closure-common")
5625                (commit commit)))
5626          (file-name (git-file-name name version))
5627          (sha256
5628           (base32
5629            "0k5r2qxn122pxi301ijir3nayi9sg4d7yiy276l36qmzwhp4mg5n"))))
5630       (inputs
5631        `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)
5632          ("babel" ,sbcl-babel)))
5633       (synopsis "Support Common Lisp library for CXML")
5634       (description "Closure-common is an internal helper library.  The name
5635 Closure is a reference to the web browser it was originally written for.")
5636       ;; TODO: License?
5637       (license #f))))
5638
5639 (define-public sbcl-cxml+xml
5640   (let ((commit "00b22bf4c4cf11c993d5866fae284f95ab18e6bf")
5641         (revision "1"))
5642     (package
5643       (name "sbcl-cxml+xml")
5644       (build-system asdf-build-system/sbcl)
5645       (version (git-version "0.0.0" revision commit))
5646       (home-page "https://common-lisp.net/project/cxml/")
5647       (source
5648        (origin
5649          (method git-fetch)
5650          (uri (git-reference
5651                (url "https://github.com/sharplispers/cxml")
5652                (commit commit)))
5653          (file-name (git-file-name name version))
5654          (sha256
5655           (base32
5656            "13kif7rf3gqdycsk9zq0d7y0g9y81krkl0z87k0p2fkbjfgrph37"))))
5657       (inputs
5658        `(("closure-common" ,sbcl-closure-common)
5659          ("puri" ,sbcl-puri)
5660          ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
5661       (arguments
5662        `(#:asd-file "cxml.asd"
5663          #:asd-system-name "cxml/xml"))
5664       (synopsis "Common Lisp XML parser")
5665       (description "CXML implements a namespace-aware, validating XML 1.0
5666 parser as well as the DOM Level 2 Core interfaces.  Two parser interfaces are
5667 offered, one SAX-like, the other similar to StAX.")
5668       (license license:llgpl))))
5669
5670 (define sbcl-cxml+dom
5671   (package
5672     (inherit sbcl-cxml+xml)
5673     (name "sbcl-cxml+dom")
5674     (inputs
5675      `(("closure-common" ,sbcl-closure-common)
5676        ("puri" ,sbcl-puri)
5677        ("cxml+xml" ,sbcl-cxml+xml)))
5678     (arguments
5679      `(#:asd-file "cxml.asd"
5680        #:asd-system-name "cxml/dom"))))
5681
5682 (define sbcl-cxml+klacks
5683   (package
5684     (inherit sbcl-cxml+xml)
5685     (name "sbcl-cxml+klacks")
5686     (inputs
5687      `(("closure-common" ,sbcl-closure-common)
5688        ("puri" ,sbcl-puri)
5689        ("cxml+xml" ,sbcl-cxml+xml)))
5690     (arguments
5691      `(#:asd-file "cxml.asd"
5692        #:asd-system-name "cxml/klacks"))))
5693
5694 (define sbcl-cxml+test
5695   (package
5696     (inherit sbcl-cxml+xml)
5697     (name "sbcl-cxml+test")
5698     (inputs
5699      `(("closure-common" ,sbcl-closure-common)
5700        ("puri" ,sbcl-puri)
5701        ("cxml+xml" ,sbcl-cxml+xml)))
5702     (arguments
5703      `(#:asd-file "cxml.asd"
5704        #:asd-system-name "cxml/test"))))
5705
5706 (define-public sbcl-cxml
5707   (package
5708     (inherit sbcl-cxml+xml)
5709     (name "sbcl-cxml")
5710     (inputs
5711      `(("closure-common" ,sbcl-closure-common)
5712        ("puri" ,sbcl-puri)
5713        ("trivial-gray-streams" ,sbcl-trivial-gray-streams)
5714        ("cxml+dom" ,sbcl-cxml+dom)
5715        ("cxml+klacks" ,sbcl-cxml+klacks)
5716        ("cxml+test" ,sbcl-cxml+test)))
5717     (arguments
5718      `(#:asd-file "cxml.asd"
5719        #:asd-system-name "cxml"
5720        #:phases
5721        (modify-phases %standard-phases
5722          (add-after 'build 'install-dtd
5723            (lambda* (#:key outputs #:allow-other-keys)
5724              (install-file "catalog.dtd"
5725                            (string-append
5726                             (assoc-ref outputs "out")
5727                             "/lib/" (%lisp-type)))))
5728          (add-after 'create-asd 'remove-component
5729            ;; XXX: The original .asd has no components, but our build system
5730            ;; creates an entry nonetheless.  We need to remove it for the
5731            ;; generated .asd to load properly.  See trivia.trivial for a
5732            ;; similar problem.
5733            (lambda* (#:key outputs #:allow-other-keys)
5734              (let* ((out (assoc-ref outputs "out"))
5735                     (asd (string-append out "/lib/sbcl/cxml.asd")))
5736                (substitute* asd
5737                  (("  :components
5738 ")
5739                   ""))
5740                (substitute* asd
5741                  ((" *\\(\\(:compiled-file \"cxml--system\"\\)\\)")
5742                   ""))))))))))
5743
5744 (define-public cl-cxml
5745   (sbcl-package->cl-source-package sbcl-cxml))
5746
5747 (define-public sbcl-cl-reexport
5748   (let ((commit "312f3661bbe187b5f28536cd7ec2956e91366c3b")
5749         (revision "1"))
5750     (package
5751       (name "sbcl-cl-reexport")
5752       (build-system asdf-build-system/sbcl)
5753       (version (git-version "0.1" revision commit))
5754       (home-page "https://github.com/takagi/cl-reexport")
5755       (source
5756        (origin
5757          (method git-fetch)
5758          (uri (git-reference
5759                (url home-page)
5760                (commit commit)))
5761          (file-name (git-file-name name version))
5762          (sha256
5763           (base32
5764            "1cwpn1m3wrl0fl9plznn7p464db646gnfc8zkyk97dyxski2aq0x"))))
5765       (inputs
5766        `(("alexandria" ,sbcl-alexandria)))
5767       (arguments
5768        ;; TODO: Tests fail because cl-test-more is missing, but I can't find it online.
5769        `(#:tests? #f))
5770       (synopsis "HTTP cookie manager for Common Lisp")
5771       (description "cl-cookie is a Common Lisp library featuring parsing of
5772 cookie headers, cookie creation, cookie jar creation and more.")
5773       (license license:llgpl))))
5774
5775 (define-public cl-reexport
5776   (sbcl-package->cl-source-package sbcl-cl-reexport))
5777
5778 (define-public sbcl-cl-cookie
5779   (let ((commit "cea55aed8b9ad25fafd13defbcb9fe8f41b29546")
5780         (revision "1"))
5781     (package
5782       (name "sbcl-cl-cookie")
5783       (build-system asdf-build-system/sbcl)
5784       (version (git-version "0.9.10" revision commit))
5785       (home-page "https://github.com/fukamachi/cl-cookie")
5786       (source
5787        (origin
5788          (method git-fetch)
5789          (uri (git-reference
5790                (url home-page)
5791                (commit commit)))
5792          (file-name (git-file-name name version))
5793          (sha256
5794           (base32
5795            "090g7z75h98zvc1ldx0vh4jn4086dhjm2w30jcwkq553qmyxwl8h"))))
5796       (inputs
5797        `(("proc-parse" ,sbcl-proc-parse)
5798          ("alexandria" ,sbcl-alexandria)
5799          ("quri" ,sbcl-quri)
5800          ("cl-ppcre" ,sbcl-cl-ppcre)
5801          ("local-time" ,sbcl-local-time)))
5802       (native-inputs
5803        `(("prove-asdf" ,sbcl-prove-asdf)
5804          ("prove" ,sbcl-prove)))
5805       (arguments
5806        ;; TODO: Tests fail because cl-cookie depends on cl-cookie-test.
5807        `(#:tests? #f))
5808       (synopsis "HTTP cookie manager for Common Lisp")
5809       (description "cl-cookie is a Common Lisp library featuring parsing of
5810 cookie headers, cookie creation, cookie jar creation and more.")
5811       (license license:bsd-2))))
5812
5813 (define-public cl-cookie
5814   (sbcl-package->cl-source-package sbcl-cl-cookie))
5815
5816 (define-public sbcl-dexador
5817   (let ((commit "953090f04c4d1a9ee6632b90133cdc297b68badc")
5818         (revision "1"))
5819     (package
5820       (name "sbcl-dexador")
5821       (build-system asdf-build-system/sbcl)
5822       (version "0.9.14" )
5823       (home-page "https://github.com/fukamachi/dexador")
5824       (source
5825        (origin
5826          (method git-fetch)
5827          (uri (git-reference
5828                (url home-page)
5829                (commit commit)))
5830          (file-name (git-file-name name version))
5831          (sha256
5832           (base32
5833            "0w18fz3301rpmwc3kwb810czcd24mbf7r1z8vdyc0v5crjfpw3mn"))))
5834       (inputs
5835        `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)
5836          ("babel" ,sbcl-babel)
5837          ("usocket" ,sbcl-usocket)
5838          ("fast-http" ,sbcl-fast-http)
5839          ("quri" ,sbcl-quri)
5840          ("fast-io" ,sbcl-fast-io)
5841          ("chunga" ,sbcl-chunga)
5842          ("cl-ppcre" ,sbcl-cl-ppcre)
5843          ("cl-cookie" ,sbcl-cl-cookie)
5844          ("trivial-mimes" ,sbcl-trivial-mimes)
5845          ("chipz" ,sbcl-chipz)
5846          ("cl-base64" ,sbcl-cl-base64)
5847          ("cl-reexport" ,sbcl-cl-reexport)
5848          ("cl+ssl" ,sbcl-cl+ssl)
5849          ("bordeaux-threads" ,sbcl-bordeaux-threads)
5850          ("alexandria" ,sbcl-alexandria)))
5851       (native-inputs
5852        `(("prove" ,sbcl-prove)
5853          ("prove-asdf" ,sbcl-prove-asdf)
5854          ("lack-request" ,sbcl-lack-request)
5855          ("clack" ,sbcl-clack)
5856          ("babel" ,sbcl-babel)
5857          ("alexandria" ,sbcl-alexandria)
5858          ("cl-ppcre" ,sbcl-cl-ppcre)
5859          ("local-time" ,sbcl-local-time)
5860          ("trivial-features" ,sbcl-trivial-features)))
5861       (arguments
5862        ;; TODO: Circular dependency: tests depend on clack-test which depends on dexador.
5863        `(#:tests? #f
5864          #:phases
5865          (modify-phases %standard-phases
5866            (add-after 'unpack 'fix-permissions
5867              (lambda _ (make-file-writable "t/data/test.gz") #t)))))
5868       (synopsis "Yet another HTTP client for Common Lisp")
5869       (description "Dexador is yet another HTTP client for Common Lisp with
5870 neat APIs and connection-pooling.  It is meant to supersede Drakma.")
5871       (license license:expat))))
5872
5873 (define-public cl-dexador
5874   (package
5875     (inherit (sbcl-package->cl-source-package sbcl-dexador))
5876     (arguments
5877      `(#:phases
5878        ;; asdf-build-system/source has its own phases and does not inherit
5879        ;; from asdf-build-system/sbcl phases.
5880        (modify-phases %standard-phases/source
5881          (add-after 'unpack 'fix-permissions
5882            (lambda _ (make-file-writable "t/data/test.gz") #t)))))))
5883
5884 (define-public ecl-dexador
5885   (sbcl-package->ecl-package sbcl-dexador))
5886
5887 (define-public sbcl-lisp-namespace
5888   (let ((commit "28107cafe34e4c1c67490fde60c7f92dc610b2e0")
5889         (revision "1"))
5890     (package
5891       (name "sbcl-lisp-namespace")
5892       (build-system asdf-build-system/sbcl)
5893       (version (git-version "0.1" revision commit))
5894       (home-page "https://github.com/guicho271828/lisp-namespace")
5895       (source
5896        (origin
5897          (method git-fetch)
5898          (uri (git-reference
5899                (url home-page)
5900                (commit commit)))
5901          (file-name (git-file-name name version))
5902          (sha256
5903           (base32
5904            "1jw2wykp06z2afb9nm1lgfzll5cjlj36pnknjx614057zkkxq4iy"))))
5905       (inputs
5906        `(("alexandria" ,sbcl-alexandria)))
5907       (native-inputs
5908        `(("fiveam" ,sbcl-fiveam)))
5909       (arguments
5910        `(#:test-asd-file "lisp-namespace.test.asd"
5911         ;; XXX: Component LISP-NAMESPACE-ASD::LISP-NAMESPACE.TEST not found
5912          #:tests? #f))
5913       (synopsis "LISP-N, or extensible namespaces in Common Lisp")
5914       (description "Common Lisp already has major 2 namespaces, function
5915 namespace and value namespace (or variable namespace), but there are actually
5916 more — e.g., class namespace.
5917 This library offers macros to deal with symbols from any namespace.")
5918       (license license:llgpl))))
5919
5920 (define-public cl-lisp-namespace
5921   (sbcl-package->cl-source-package sbcl-lisp-namespace))
5922
5923 (define-public sbcl-trivial-cltl2
5924   (let ((commit "8eec8407df833e8f27df8a388bc10913f16d9e83")
5925         (revision "1"))
5926     (package
5927       (name "sbcl-trivial-cltl2")
5928       (build-system asdf-build-system/sbcl)
5929       (version (git-version "0.1.1" revision commit))
5930       (home-page "https://github.com/Zulu-Inuoe/trivial-cltl2")
5931       (source
5932        (origin
5933          (method git-fetch)
5934          (uri (git-reference
5935                (url home-page)
5936                (commit commit)))
5937          (file-name (git-file-name name version))
5938          (sha256
5939           (base32
5940            "1dyyxz17vqv8hlfwq287gl8xxbvcnq798ajb7p5jdjz91wqf4bgk"))))
5941       (synopsis "Simple CLtL2 compatibility layer for Common Lisp")
5942       (description "This library is a portable compatibility layer around
5943 \"Common Lisp the Language, 2nd
5944 Edition\" (@url{https://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node102.html})
5945 and it exports symbols from implementation-specific packages.")
5946       (license license:llgpl))))
5947
5948 (define-public cl-trivial-cltl2
5949   (sbcl-package->cl-source-package sbcl-trivial-cltl2))
5950
5951 (define-public sbcl-introspect-environment
5952   (let ((commit "fff42f8f8fd0d99db5ad6c5812e53de7d660020b")
5953         (revision "1"))
5954     (package
5955       (name "sbcl-introspect-environment")
5956       (build-system asdf-build-system/sbcl)
5957       (version (git-version "0.1" revision commit))
5958       (home-page "https://github.com/Bike/introspect-environment")
5959       (source
5960        (origin
5961          (method git-fetch)
5962          (uri (git-reference
5963                (url home-page)
5964                (commit commit)))
5965          (file-name (git-file-name name version))
5966          (sha256
5967           (base32
5968            "1i305n0wfmpac63ni4i3vixnnkl8daw5ncxy0k3dv92krgx6qzhp"))))
5969       (native-inputs
5970        `(("fiveam" ,sbcl-fiveam)))
5971       (synopsis "Common Lisp environment introspection portability layer")
5972       (description "This library is a small interface to portable but
5973 nonstandard introspection of Common Lisp environments.  It is intended to
5974 allow a bit more compile-time introspection of environments in Common Lisp.
5975
5976 Quite a bit of information is available at the time a macro or compiler-macro
5977 runs; inlining info, type declarations, that sort of thing.  This information
5978 is all standard - any Common Lisp program can @code{(declare (integer x))} and
5979 such.
5980
5981 This info ought to be accessible through the standard @code{&environment}
5982 parameters, but it is not.  Several implementations keep the information for
5983 their own purposes but do not make it available to user programs, because
5984 there is no standard mechanism to do so.
5985
5986 This library uses implementation-specific hooks to make information available
5987 to users.  This is currently supported on SBCL, CCL, and CMUCL.  Other
5988 implementations have implementations of the functions that do as much as they
5989 can and/or provide reasonable defaults.")
5990       (license license:wtfpl2))))
5991
5992 (define-public cl-introspect-environment
5993   (sbcl-package->cl-source-package sbcl-introspect-environment))
5994
5995 (define-public sbcl-type-i
5996   (let ((commit "dea233f45f94064105ec09f0767de338f67dcbe2")
5997         (revision "1"))
5998     (package
5999       (name "sbcl-type-i")
6000       (build-system asdf-build-system/sbcl)
6001       (version (git-version "0.1" revision commit))
6002       (home-page "https://github.com/guicho271828/type-i")
6003       (source
6004        (origin
6005          (method git-fetch)
6006          (uri (git-reference
6007                (url home-page)
6008                (commit commit)))
6009          (file-name (git-file-name name version))
6010          (sha256
6011           (base32
6012            "039g5pbrhh65s0bhr9314gmd2nwc2y5lp2377c5qrc2lxky89qs3"))))
6013       (inputs
6014        `(("alexandria" ,sbcl-alexandria)
6015          ("introspect-environment" ,sbcl-introspect-environment)
6016          ("trivia.trivial" ,sbcl-trivia.trivial)))
6017       (native-inputs
6018        `(("fiveam" ,sbcl-fiveam)))
6019       (arguments
6020        `(#:test-asd-file "type-i.test.asd"))
6021       (synopsis "Type inference utility on unary predicates for Common Lisp")
6022       (description "This library tries to provide a way to detect what kind of
6023 type the given predicate is trying to check.  This is different from inferring
6024 the return type of a function.")
6025       (license license:llgpl))))
6026
6027 (define-public cl-type-i
6028   (sbcl-package->cl-source-package sbcl-type-i))
6029
6030 (define-public sbcl-optima
6031   (let ((commit "373b245b928c1a5cce91a6cb5bfe5dd77eb36195")
6032         (revision "1"))
6033     (package
6034       (name "sbcl-optima")
6035       (build-system asdf-build-system/sbcl)
6036       (version (git-version "1.0" revision commit))
6037       (home-page "https://github.com/m2ym/optima")
6038       (source
6039        (origin
6040          (method git-fetch)
6041          (uri (git-reference
6042                (url home-page)
6043                (commit commit)))
6044          (file-name (git-file-name name version))
6045          (sha256
6046           (base32
6047            "1yw4ymq7ms89342kkvb3aqxgv0w38m9kd8ikdqxxzyybnkjhndal"))))
6048       (inputs
6049        `(("alexandria" ,sbcl-alexandria)
6050          ("closer-mop" ,sbcl-closer-mop)))
6051       (native-inputs
6052        `(("eos" ,sbcl-eos)))
6053       (arguments
6054        ;; XXX: Circular dependencies: tests depend on optima.ppcre which depends on optima.
6055        `(#:tests? #f
6056          #:test-asd-file "optima.test.asd"))
6057       (synopsis "Optimized pattern matching library for Common Lisp")
6058       (description "Optima is a fast pattern matching library which uses
6059 optimizing techniques widely used in the functional programming world.")
6060       (license license:expat))))
6061
6062 (define-public cl-optima
6063   (sbcl-package->cl-source-package sbcl-optima))
6064
6065 (define-public sbcl-fare-quasiquote
6066   (let ((commit "640d39a0451094071b3e093c97667b3947f43639")
6067         (revision "1"))
6068     (package
6069       (name "sbcl-fare-quasiquote")
6070       (build-system asdf-build-system/sbcl)
6071       (version (git-version "1.0.1" revision commit))
6072       (home-page "https://gitlab.common-lisp.net/frideau/fare-quasiquote")
6073       (source
6074        (origin
6075          (method git-fetch)
6076          (uri (git-reference
6077                (url (string-append "https://gitlab.common-lisp.net/frideau/"
6078                                    "fare-quasiquote.git"))
6079                (commit commit)))
6080          (file-name (git-file-name name version))
6081          (sha256
6082           (base32 "1g6q11l50kgija9f55lzqpcwvaq0ljiw8v1j265hnyg6nahjwjvg"))))
6083       (inputs
6084        `(("fare-utils" ,sbcl-fare-utils)))
6085       (arguments
6086        ;; XXX: Circular dependencies: Tests depend on subsystems,
6087        ;; which depend on the main systems.
6088        `(#:tests? #f
6089          #:phases
6090          (modify-phases %standard-phases
6091            ;; XXX: Require 1.0.0 version of fare-utils, and we package some
6092            ;; commits after 1.0.0.5, but ASDF fails to read the
6093            ;; "-REVISION-COMMIT" part generated by Guix.
6094            (add-after 'unpack 'patch-requirement
6095              (lambda _
6096                (substitute* "fare-quasiquote.asd"
6097                  (("\\(:version \"fare-utils\" \"1.0.0\"\\)")
6098                   "\"fare-utils\"")))))))
6099       (synopsis "Pattern-matching friendly implementation of quasiquote")
6100       (description "The main purpose of this n+2nd reimplementation of
6101 quasiquote is enable matching of quasiquoted patterns, using Optima or
6102 Trivia.")
6103       (license license:expat))))
6104
6105 (define-public cl-fare-quasiquote
6106   (sbcl-package->cl-source-package sbcl-fare-quasiquote))
6107
6108 (define-public sbcl-fare-quasiquote-optima
6109   (package
6110     (inherit sbcl-fare-quasiquote)
6111     (name "sbcl-fare-quasiquote-optima")
6112     (inputs
6113      `(("optima" ,sbcl-optima)
6114        ("fare-quasiquote" ,sbcl-fare-quasiquote)))
6115     (arguments
6116      '(#:phases
6117        (modify-phases %standard-phases
6118          (add-after 'unpack 'patch-requirement
6119            (lambda _
6120              (substitute* "fare-quasiquote-optima.asd"
6121                (("\\(:version \"optima\" \"1\\.0\"\\)")
6122                 "\"optima\""))
6123              #t)))))))
6124
6125 (define-public cl-fare-quasiquote-optima
6126   (sbcl-package->cl-source-package sbcl-fare-quasiquote-optima))
6127
6128 (define-public sbcl-fare-quasiquote-readtable
6129   (package
6130     (inherit sbcl-fare-quasiquote)
6131     (name "sbcl-fare-quasiquote-readtable")
6132     (inputs
6133      `(("fare-quasiquote" ,sbcl-fare-quasiquote)
6134        ("named-readtables" ,sbcl-named-readtables)))
6135     (description "The main purpose of this n+2nd reimplementation of
6136 quasiquote is enable matching of quasiquoted patterns, using Optima or
6137 Trivia.
6138
6139 This package uses fare-quasiquote with named-readtable.")))
6140
6141 (define-public cl-fare-quasiquote-readtable
6142   (sbcl-package->cl-source-package sbcl-fare-quasiquote-readtable))
6143
6144 ;; TODO: Add support for component-less system in asdf-build-system/sbcl.
6145 (define-public sbcl-fare-quasiquote-extras
6146   (package
6147     (inherit sbcl-fare-quasiquote)
6148     (name "sbcl-fare-quasiquote-extras")
6149     (build-system asdf-build-system/sbcl)
6150     (inputs
6151      `(("fare-quasiquote-optima" ,sbcl-fare-quasiquote-optima)
6152        ("fare-quasiquote-readtable" ,sbcl-fare-quasiquote-readtable)))
6153     (arguments
6154      `(#:phases
6155        (modify-phases %standard-phases
6156          (replace 'build
6157            (lambda* (#:key outputs #:allow-other-keys)
6158              (let* ((out (assoc-ref outputs "out"))
6159                     (lib (string-append out "/lib/" (%lisp-type))))
6160                (mkdir-p lib)
6161                (install-file "fare-quasiquote-extras.asd" lib)
6162                (make-file-writable
6163                 (string-append lib "/fare-quasiquote-extras.asd"))
6164                #t)))
6165          (add-after 'create-asd-file 'fix-asd-file
6166            (lambda* (#:key outputs #:allow-other-keys)
6167              (let* ((out (assoc-ref outputs "out"))
6168                     (lib (string-append out "/lib/" (%lisp-type)))
6169                     (asd (string-append lib "/fare-quasiquote-extras.asd")))
6170                (substitute* asd
6171                  ((":class")
6172                   "")
6173                  (("asdf/bundle:prebuilt-system")
6174                   "")
6175                  ((":components")
6176                   "")
6177                  (("\\(\\(:compiled-file \"fare-quasiquote-extras--system\"\\)\\)")
6178                   "")))
6179              #t)))))
6180     (description "This library combines @code{fare-quasiquote-readtable} and
6181 @code{fare-quasiquote-optima}.")))
6182
6183 (define-public cl-fare-quasiquote-extras
6184   (package
6185     (inherit cl-fare-quasiquote)
6186     (name "cl-fare-quasiquote-extras")
6187     (build-system asdf-build-system/source)
6188     (propagated-inputs
6189      `(("fare-quasiquote" ,cl-fare-quasiquote)
6190        ("fare-quasiquote-optima" ,cl-fare-quasiquote-optima)
6191        ("fare-quasiquote-readtable" ,cl-fare-quasiquote-readtable)))
6192     (description "This library combines @code{fare-quasiquote-readtable} and
6193 @code{fare-quasiquote-optima}.")))
6194
6195 (define-public sbcl-trivia.level0
6196   (let ((commit "574901ac376ae54c9d37169fd5efab9b3b8fcc63")
6197         (revision "1"))
6198     (package
6199       (name "sbcl-trivia.level0")
6200       (build-system asdf-build-system/sbcl)
6201       (version (git-version "0.0.0" revision commit))
6202       (home-page "https://github.com/guicho271828/trivia")
6203       (source
6204        (origin
6205          (method git-fetch)
6206          (uri (git-reference
6207                (url home-page)
6208                (commit commit)))
6209          (file-name (git-file-name name version))
6210          (sha256
6211           (base32
6212            "0hf53n71xzr9sjwrxis5fivx3drclf4s39h5ck8vh21ndqj9zvdk"))))
6213       (inputs
6214        `(("alexandria" ,sbcl-alexandria)))
6215       (synopsis "Pattern matching in Common Lisp")
6216       (description "Trivia is a pattern matching compiler that is compatible
6217 with Optima, another pattern matching library for Common Lisp.  It is meant to
6218 be faster and more extensible than Optima.")
6219       (license license:llgpl))))
6220
6221 (define-public sbcl-trivia.level1
6222   (package
6223     (inherit sbcl-trivia.level0)
6224     (name "sbcl-trivia.level1")
6225     (inputs
6226      `(("trivia.level0" ,sbcl-trivia.level0)))
6227     (description "Trivia is a pattern matching compiler that is compatible
6228 with Optima, another pattern matching library for Common Lisp.  It is meant to
6229 be faster and more extensible than Optima.
6230
6231 This system contains the core patterns of Trivia.")))
6232
6233 (define-public sbcl-trivia.level2
6234   (package
6235     (inherit sbcl-trivia.level0)
6236     (name "sbcl-trivia.level2")
6237     (inputs
6238      `(("trivia.level1" ,sbcl-trivia.level1)
6239        ("lisp-namespace" ,sbcl-lisp-namespace)
6240        ("trivial-cltl2" ,sbcl-trivial-cltl2)
6241        ("closer-mop" ,sbcl-closer-mop)))
6242     (description "Trivia is a pattern matching compiler that is compatible
6243 with Optima, another pattern matching library for Common Lisp.  It is meant to
6244 be faster and more extensible than Optima.
6245
6246 This system contains a non-optimized pattern matcher compatible with Optima,
6247 with extensible optimizer interface.")))
6248
6249 (define-public sbcl-trivia.trivial
6250   (package
6251     (inherit sbcl-trivia.level0)
6252     (name "sbcl-trivia.trivial")
6253     (inputs
6254      `(("trivia.level2" ,sbcl-trivia.level2)))
6255     (arguments
6256      `(#:phases
6257        (modify-phases %standard-phases
6258          (replace 'create-asd-file
6259            (lambda* (#:key outputs inputs #:allow-other-keys)
6260              (let* ((out (assoc-ref outputs "out"))
6261                     (lib (string-append out "/lib/" (%lisp-type)))
6262                     (level2 (assoc-ref inputs "trivia.level2")))
6263                (mkdir-p lib)
6264                (install-file "trivia.trivial.asd" lib)
6265                ;; XXX: This .asd does not have any component and the build
6266                ;; system fails to work in this case.  We should update the
6267                ;; build system to handle component-less .asd.
6268                ;; TODO: How do we append to file in Guile?  It seems that
6269                ;; (open-file ... "a") gets a "Permission denied".
6270                (substitute* (string-append lib "/trivia.trivial.asd")
6271                  (("\"\\)")
6272                   (string-append "\")
6273
6274 (progn (asdf/source-registry:ensure-source-registry)
6275        (setf (gethash
6276                \"trivia.level2\"
6277                asdf/source-registry:*source-registry*)
6278              #p\""
6279                                  level2
6280                                  "/share/common-lisp/sbcl-bundle-systems/trivia.level2.asd\"))")))))))))
6281     (description "Trivia is a pattern matching compiler that is compatible
6282 with Optima, another pattern matching library for Common Lisp.  It is meant to
6283 be faster and more extensible than Optima.
6284
6285 This system contains the base level system of Trivia with a trivial optimizer.")))
6286
6287 (define-public sbcl-trivia.balland2006
6288   (package
6289     (inherit sbcl-trivia.level0)
6290     (name "sbcl-trivia.balland2006")
6291     (inputs
6292      `(("trivia.trivial" ,sbcl-trivia.trivial)
6293        ("iterate" ,sbcl-iterate)
6294        ("type-i" ,sbcl-type-i)
6295        ("alexandria" ,sbcl-alexandria)))
6296     (arguments
6297      ;; Tests are done in trivia itself.
6298      `(#:tests? #f))
6299     (description "Trivia is a pattern matching compiler that is compatible
6300 with Optima, another pattern matching library for Common Lisp.  It is meant to
6301 be faster and more extensible than Optima.
6302
6303 This system contains the base level system of Trivia with a trivial optimizer.")))
6304
6305 (define-public sbcl-trivia.ppcre
6306   (package
6307     (inherit sbcl-trivia.level0)
6308     (name "sbcl-trivia.ppcre")
6309     (inputs
6310      `(("trivia.trivial" ,sbcl-trivia.trivial)
6311        ("cl-ppcre" ,sbcl-cl-ppcre)))
6312     (description "Trivia is a pattern matching compiler that is compatible
6313 with Optima, another pattern matching library for Common Lisp.  It is meant to
6314 be faster and more extensible than Optima.
6315
6316 This system contains the PPCRE extension.")))
6317
6318 (define-public sbcl-trivia.quasiquote
6319   (package
6320     (inherit sbcl-trivia.level0)
6321     (name "sbcl-trivia.quasiquote")
6322     (inputs
6323      `(("trivia.trivial" ,sbcl-trivia.trivial)
6324        ("fare-quasiquote" ,sbcl-fare-quasiquote)
6325        ("fare-quasiquote-readtable" ,sbcl-fare-quasiquote-readtable)))
6326     (description "Trivia is a pattern matching compiler that is compatible
6327 with Optima, another pattern matching library for Common Lisp.  It is meant to
6328 be faster and more extensible than Optima.
6329
6330 This system contains the fare-quasiquote extension.")))
6331
6332 (define-public sbcl-trivia.cffi
6333   (package
6334     (inherit sbcl-trivia.level0)
6335     (name "sbcl-trivia.cffi")
6336     (inputs
6337      `(("cffi" ,sbcl-cffi)
6338        ("trivia.trivial" ,sbcl-trivia.trivial)))
6339     (description "Trivia is a pattern matching compiler that is compatible
6340 with Optima, another pattern matching library for Common Lisp.  It is meant to
6341 be faster and more extensible than Optima.
6342
6343 This system contains the CFFI foreign slot access extension.")))
6344
6345 (define-public sbcl-trivia
6346   (package
6347     (inherit sbcl-trivia.level0)
6348     (name "sbcl-trivia")
6349     (inputs
6350      `(("trivia.balland2006" ,sbcl-trivia.balland2006)))
6351     (native-inputs
6352      `(("fiveam" ,sbcl-fiveam)
6353        ("trivia.ppcre" ,sbcl-trivia.ppcre)
6354        ("trivia.quasiquote" ,sbcl-trivia.quasiquote)
6355        ("trivia.cffi" ,sbcl-trivia.cffi)
6356        ("optima" ,sbcl-optima)))
6357     (arguments
6358      `(#:test-asd-file "trivia.test.asd"
6359        #:phases
6360        (modify-phases %standard-phases
6361          (add-after 'create-asd 'remove-component
6362            ;; XXX: The original .asd has no components, but our build system
6363            ;; creates an entry nonetheless.  We need to remove it for the
6364            ;; generated .asd to load properly.  See trivia.trivial for a
6365            ;; similar problem.
6366            (lambda* (#:key outputs #:allow-other-keys)
6367              (let* ((out (assoc-ref outputs "out"))
6368                     (asd (string-append out "/lib/" (%lisp-type) "/trivia.asd")))
6369                (substitute* asd
6370                  (("  :components
6371 ")
6372                   ""))
6373                (substitute* asd
6374                  ((" *\\(\\(:compiled-file \"trivia--system\"\\)\\)")
6375                   ""))))))))
6376     (description "Trivia is a pattern matching compiler that is compatible
6377 with Optima, another pattern matching library for Common Lisp.  It is meant to
6378 be faster and more extensible than Optima.")))
6379
6380 (define-public cl-trivia
6381   (sbcl-package->cl-source-package sbcl-trivia))
6382
6383 (define-public sbcl-mk-string-metrics
6384   (package
6385     (name "sbcl-mk-string-metrics")
6386     (version "0.1.2")
6387     (home-page "https://github.com/cbaggers/mk-string-metrics/")
6388     (source (origin
6389               (method git-fetch)
6390               (uri (git-reference
6391                     (url home-page)
6392                     (commit version)))
6393               (sha256
6394                (base32 "0bg0bv2mfd4k0g3x72x563hvmrx18xavaffr6xk5rh4if5j7kcf6"))
6395               (file-name (git-file-name name version))))
6396     (build-system asdf-build-system/sbcl)
6397     (synopsis "Calculate various string metrics efficiently in Common Lisp")
6398     (description "This library implements efficient algorithms that calculate
6399 various string metrics in Common Lisp:
6400
6401 @itemize
6402 @item Damerau-Levenshtein distance
6403 @item Hamming distance
6404 @item Jaccard similarity coefficient
6405 @item Jaro distance
6406 @item Jaro-Winkler distance
6407 @item Levenshtein distance
6408 @item Normalized Damerau-Levenshtein distance
6409 @item Normalized Levenshtein distance
6410 @item Overlap coefficient
6411 @end itemize\n")
6412     (license license:x11)))
6413
6414 (define-public cl-mk-string-metrics
6415   (sbcl-package->cl-source-package sbcl-mk-string-metrics))
6416
6417 (define-public sbcl-cl-str
6418   (let ((commit "eb480f283e28802d67b35bf916506701152f9a2a"))
6419     (package
6420       (name "sbcl-cl-str")
6421       (version (git-version "0.17" "1" commit))
6422       (home-page "https://github.com/vindarel/cl-str")
6423       (source (origin
6424                 (method git-fetch)
6425                 (uri (git-reference
6426                       (url home-page)
6427                       (commit commit)))
6428                 (sha256
6429                  (base32 "1hpq5m8zjjnzns370zy27z2vcm1p8n2ka5ij2x67gyc9amz9vla0"))
6430                 (file-name (git-file-name name version))))
6431       (build-system asdf-build-system/sbcl)
6432       (inputs
6433        `(("cl-ppcre" ,sbcl-cl-ppcre)
6434          ("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)
6435          ("cl-change-case" ,sbcl-cl-change-case)))
6436       (native-inputs
6437        `(("prove" ,sbcl-prove)
6438          ("prove-asdf" ,sbcl-prove-asdf)))
6439       (arguments
6440        `(#:asd-file "str.asd"
6441          #:asd-system-name "str"
6442          #:test-asd-file "str.test.asd"))
6443       (synopsis "Modern, consistent and terse Common Lisp string manipulation library")
6444       (description "A modern and consistent Common Lisp string manipulation
6445 library that focuses on modernity, simplicity and discoverability:
6446 @code{(str:trim s)} instead of @code{(string-trim '(#\\Space ...) s)}), or
6447 @code{str:concat strings} instead of an unusual format construct; one
6448 discoverable library instead of many; consistency and composability, where
6449 @code{s} is always the last argument, which makes it easier to feed pipes and
6450 arrows.")
6451       (license license:expat))))
6452
6453 (define-public cl-str
6454   (sbcl-package->cl-source-package sbcl-cl-str))
6455
6456 (define-public sbcl-cl-xmlspam
6457   (let ((commit "ea06abcca2a73a9779bcfb09081e56665f94e22a"))
6458     (package
6459       (name "sbcl-cl-xmlspam")
6460       (build-system asdf-build-system/sbcl)
6461       (version (git-version "0.0.0" "1" commit))
6462       (home-page "https://github.com/rogpeppe/cl-xmlspam")
6463       (source
6464        (origin
6465          (method git-fetch)
6466          (uri (git-reference
6467                (url home-page)
6468                (commit commit)))
6469          (file-name (string-append name "-" version))
6470          (sha256
6471           (base32
6472            "0w4rqvrgdgk3fwfq3kx4r7wwdr2bv3b6n3bdqwsiriw9psqzpz2s"))))
6473       (inputs
6474        `(("cxml" ,sbcl-cxml)
6475          ("cl-ppcre" ,sbcl-cl-ppcre)))
6476       (synopsis "Concise, regexp-like pattern matching on streaming XML for Common Lisp")
6477       (description "CXML does an excellent job at parsing XML elements, but what
6478 do you do when you have a XML file that's larger than you want to fit in
6479 memory, and you want to extract some information from it?  Writing code to deal
6480 with SAX events, or even using Klacks, quickly becomes tedious.
6481 @code{cl-xmlspam} (for XML Stream PAttern Matcher) is designed to make it easy
6482 to write code that mirrors the structure of the XML that it's parsing.  It
6483 also makes it easy to shift paradigms when necessary - the usual Lisp control
6484 constructs can be used interchangeably with pattern matching, and the full
6485 power of CXML is available when necessary.")
6486       (license license:bsd-3))))
6487
6488 ;; TODO: dbus uses ASDF's package-inferred-system which is not supported by
6489 ;; asdf-build-system/sbcl as of 2019-08-02.  We should fix
6490 ;; asdf-build-system/sbcl.
6491 (define-public cl-dbus
6492   (let ((commit "24b452df3a45ca5dc95015500f34baad175c981a")
6493         (revision "1"))
6494     (package
6495       (name "cl-dbus")
6496       (build-system asdf-build-system/source)
6497       (version (git-version "20190408" revision commit))
6498       (home-page "https://github.com/death/dbus")
6499       (source
6500        (origin
6501          (method git-fetch)
6502          (uri (git-reference
6503                (url home-page)
6504                (commit commit)))
6505          (file-name (git-file-name name version))
6506          (sha256
6507           (base32
6508            "0fw2q866yddbf23nk9pxphm9gsasx35vjyss82xzvndnjmzlqfl5"))))
6509       ;; Inputs must be propagated or else packages depending on this won't
6510       ;; have the necessary packages.
6511       (propagated-inputs
6512        `(("alexandria" ,sbcl-alexandria)
6513          ("trivial-garbage" ,sbcl-trivial-garbage)
6514          ("babel" ,sbcl-babel)
6515          ("iolib" ,sbcl-iolib)
6516          ("ieee-floats" ,sbcl-ieee-floats)
6517          ("flexi-streams" ,sbcl-flexi-streams)
6518          ("cl-xmlspam" ,sbcl-cl-xmlspam)
6519          ("ironclad" ,sbcl-ironclad)))
6520       (synopsis "D-Bus client library for Common Lisp")
6521       (description "This is a Common Lisp library that publishes D-Bus
6522 objects as well as send and notify other objects connected to a bus.")
6523       (license license:bsd-2))))
6524
6525 (define-public sbcl-cl-hooks
6526   (let ((commit "5b638083f3b4f1221a52631d9c8a0a265565cac7")
6527         (revision "1"))
6528     (package
6529       (name "sbcl-cl-hooks")
6530       (build-system asdf-build-system/sbcl)
6531       (version (git-version "0.2.1" revision commit))
6532       (home-page "https://github.com/scymtym/architecture.hooks")
6533       (source
6534        (origin
6535          (method git-fetch)
6536          (uri (git-reference
6537                (url home-page)
6538                (commit commit)))
6539          (file-name (git-file-name name version))
6540          (sha256
6541           (base32
6542            "0bg3l0a28lw5gqqjp6p6b5nhwqk46sgkb7184w5qbfngw1hk8x9y"))))
6543       (inputs
6544        `(("alexandria" ,sbcl-alexandria)
6545          ("let-plus" ,sbcl-let-plus)
6546          ("trivial-garbage" ,sbcl-trivial-garbage)
6547          ("closer-mop" ,sbcl-closer-mop)))
6548       (native-inputs
6549        `(("fiveam" ,sbcl-fiveam)))
6550       (synopsis "Hooks extension point mechanism (as in Emacs) for Common Lisp")
6551       (description "A hook, in the present context, is a certain kind of
6552 extension point in a program that allows interleaving the execution of
6553 arbitrary code with the execution of a the program without introducing any
6554 coupling between the two.  Hooks are used extensively in the extensible editor
6555 Emacs.
6556
6557 In the Common LISP Object System (CLOS), a similar kind of extensibility is
6558 possible using the flexible multi-method dispatch mechanism.  It may even seem
6559 that the concept of hooks does not provide any benefits over the possibilities
6560 of CLOS.  However, there are some differences:
6561
6562 @itemize
6563
6564 @item There can be only one method for each combination of specializers and
6565 qualifiers.  As a result this kind of extension point cannot be used by
6566 multiple extensions independently.
6567 @item Removing code previously attached via a @code{:before}, @code{:after} or
6568 @code{:around} method can be cumbersome.
6569 @item There could be other or even multiple extension points besides @code{:before}
6570 and @code{:after} in a single method.
6571 @item Attaching codes to individual objects using eql specializers can be
6572 cumbersome.
6573 @item Introspection of code attached a particular extension point is
6574 cumbersome since this requires enumerating and inspecting the methods of a
6575 generic function.
6576 @end itemize
6577
6578 This library tries to complement some of these weaknesses of method-based
6579 extension-points via the concept of hooks.")
6580       (license license:llgpl))))
6581
6582 (define-public cl-hooks
6583   (sbcl-package->cl-source-package sbcl-cl-hooks))
6584
6585 (define-public ecl-cl-hooks
6586   (sbcl-package->ecl-package sbcl-cl-hooks))
6587
6588 (define-public sbcl-s-sysdeps
6589   ;; No release since 2013.
6590   (let ((commit "9aa23bbdceb24bcdbe0e7c39fa1901858f823106")
6591         (revision "2"))
6592     (package
6593       (name "sbcl-s-sysdeps")
6594       (build-system asdf-build-system/sbcl)
6595       (version (git-version "1" revision commit))
6596       (home-page "https://github.com/svenvc/s-sysdeps")
6597       (source
6598        (origin
6599          (method git-fetch)
6600          (uri (git-reference
6601                (url home-page)
6602                (commit commit)))
6603          (file-name (git-file-name name version))
6604          (sha256
6605           (base32
6606            "1fh8r7kf8s3hvqdg6b71b8p7w3v2kkga9bw8j3qqdxhzr6anpm0b"))))
6607       (inputs
6608        `(("bordeaux-threads" ,sbcl-bordeaux-threads)
6609          ("usocket" ,sbcl-usocket)
6610          ("usocket-server" ,sbcl-usocket-server)))
6611       (synopsis "Common Lisp abstraction layer over platform dependent functionality")
6612       (description "@code{s-sysdeps} is an abstraction layer over platform
6613 dependent functionality.  This simple package is used as a building block in a
6614 number of other open source projects.
6615
6616 @code{s-sysdeps} abstracts:
6617
6618 @itemize
6619 @item managing processes,
6620 @item implementing a standard TCP/IP server,
6621 @item opening a client TCP/IP socket stream,
6622 @item working with process locks.
6623 @end itemize\n")
6624       (license license:llgpl))))
6625
6626 (define-public cl-s-sysdeps
6627   (sbcl-package->cl-source-package sbcl-s-sysdeps))
6628
6629 (define-public ecl-s-sysdeps
6630   (sbcl-package->ecl-package sbcl-s-sysdeps))
6631
6632 (define-public sbcl-cl-prevalence
6633   (let ((commit "da3ed6c4594b1c2fca90c178c1993973c4bf16c9")
6634         (revision "2"))
6635     (package
6636       (name "sbcl-cl-prevalence")
6637       (build-system asdf-build-system/sbcl)
6638       (version (git-version "5" revision commit))
6639       (home-page "https://github.com/40ants/cl-prevalence")
6640       (source
6641        (origin
6642          (method git-fetch)
6643          (uri (git-reference
6644                (url home-page)
6645                (commit commit)))
6646          (file-name (git-file-name name version))
6647          (sha256
6648           (base32
6649            "0bq905hv1626dl6b7s0zn4lbdh608g1pxaljl1fda6pwp9hmj95a"))))
6650       (inputs
6651        `(("s-sysdeps" ,sbcl-s-sysdeps)
6652          ("s-xml" ,sbcl-s-xml)))
6653       (synopsis "Implementation of object prevalence for Common Lisp")
6654       (description "This Common Lisp library implements object prevalence (see
6655 @url{https://en.wikipedia.org/wiki/System_prevalence}).  It allows
6656 for (de)serializing to and from s-exps as well as XML.  Serialization of arbitrary
6657 classes and cyclic data structures are supported.")
6658       (license license:llgpl))))
6659
6660 (define-public cl-prevalence
6661   (sbcl-package->cl-source-package sbcl-cl-prevalence))
6662
6663 (define-public ecl-cl-prevalence
6664   (sbcl-package->ecl-package sbcl-cl-prevalence))
6665
6666 (define-public sbcl-series
6667   (let ((commit "da9061b336119d1e5214aff9117171d494d5a58a")
6668         (revision "1"))
6669     (package
6670       (name "sbcl-series")
6671       (version (git-version "2.2.11" revision commit))
6672       (source
6673        (origin
6674          (method git-fetch)
6675          (uri (git-reference
6676                (url "git://git.code.sf.net/p/series/series")
6677                (commit commit)))
6678          (file-name (git-file-name name version))
6679          (sha256
6680           (base32
6681            "07hk2lhfx42zk018pxqvn4gs77vd4n4g8m4xxbqaxgca76mifwfw"))))
6682       (build-system asdf-build-system/sbcl)
6683       (arguments
6684        ;; Disable the tests, they are apparently buggy and I didn't find
6685        ;; a simple way to make them run and pass.
6686        '(#:tests? #f))
6687       (synopsis "Series data structure for Common Lisp")
6688       (description
6689        "This Common Lisp library provides a series data structure much like
6690 a sequence, with similar kinds of operations.  The difference is that in many
6691 situations, operations on series may be composed functionally and yet execute
6692 iteratively, without the need to construct intermediate series values
6693 explicitly.  In this manner, series provide both the clarity of a functional
6694 programming style and the efficiency of an iterative programming style.")
6695       (home-page "http://series.sourceforge.net/")
6696       (license license:expat))))
6697
6698 (define-public cl-series
6699   (sbcl-package->cl-source-package sbcl-series))
6700
6701 (define-public ecl-series
6702   (sbcl-package->ecl-package sbcl-series))
6703
6704 (define-public sbcl-periods
6705   (let ((commit "983d4a57325db3c8def942f163133cec5391ec28")
6706         (revision "1"))
6707     (package
6708       (name "sbcl-periods")
6709       (version (git-version "0.0.2" revision commit))
6710       (source
6711        (origin
6712          (method git-fetch)
6713          (uri (git-reference
6714                (url "https://github.com/jwiegley/periods.git")
6715                (commit commit)))
6716          (file-name (git-file-name name version))
6717          (sha256
6718           (base32
6719            "0z30jr3lxz3cmi019fsl4lgcgwf0yqpn95v9zkkkwgymdrkd4lga"))))
6720       (build-system asdf-build-system/sbcl)
6721       (inputs
6722        `(("local-time" ,sbcl-local-time)))
6723       (synopsis "Common Lisp library for manipulating date/time objects")
6724       (description
6725        "Periods is a Common Lisp library providing a set of utilities for
6726 manipulating times, distances between times, and both contiguous and
6727 discontiguous ranges of time.")
6728       (home-page "https://github.com/jwiegley/periods")
6729       (license license:bsd-3))))
6730
6731 (define-public cl-periods
6732   (sbcl-package->cl-source-package sbcl-periods))
6733
6734 (define-public ecl-periods
6735   (sbcl-package->ecl-package sbcl-periods))
6736
6737 (define-public sbcl-periods-series
6738   (package
6739     (inherit sbcl-periods)
6740     (name "sbcl-periods-series")
6741     (inputs
6742      `(("periods" ,sbcl-periods)
6743        ("series" ,sbcl-series)))
6744     (arguments
6745      '(#:asd-file "periods-series.asd"
6746        #:asd-system-name "periods-series"))
6747     (description
6748      "Periods-series is an extension of the periods Common Lisp library
6749 providing functions compatible with the series Common Lisp library.")))
6750
6751 (define-public cl-periods-series
6752   (sbcl-package->cl-source-package sbcl-periods-series))
6753
6754 (define-public ecl-periods-series
6755   (sbcl-package->ecl-package sbcl-periods-series))
6756
6757 (define-public sbcl-metatilities-base
6758   (let ((commit "6eaa9e3ff0939a93a92109dd0fcd218de85417d5")
6759         (revision "1"))
6760     (package
6761       (name "sbcl-metatilities-base")
6762       (version (git-version "0.6.6" revision commit))
6763       (source
6764        (origin
6765          (method git-fetch)
6766          (uri (git-reference
6767                (url "https://github.com/gwkkwg/metatilities-base.git")
6768                (commit commit)))
6769          (file-name (git-file-name name version))
6770          (sha256
6771           (base32
6772            "0xpa86pdzlnf4v5g64j3ifaplx71sx2ha8b7vvakswi652679ma0"))))
6773       (build-system asdf-build-system/sbcl)
6774       (native-inputs
6775        `(("lift" ,sbcl-lift)))
6776       (synopsis "Core of the metatilities Common Lisp library")
6777       (description
6778        "Metatilities-base is the core of the metatilities Common Lisp library
6779 which implements a set of utilities.")
6780       (home-page "https://common-lisp.net/project/metatilities-base/")
6781       (license license:expat))))
6782
6783 (define-public cl-metatilities-base
6784   (sbcl-package->cl-source-package sbcl-metatilities-base))
6785
6786 (define-public ecl-metatilities-base
6787   (sbcl-package->ecl-package sbcl-metatilities-base))
6788
6789 (define-public sbcl-cl-containers
6790   (let ((commit "3d1df53c22403121bffb5d553cf7acb1503850e7")
6791         (revision "3"))
6792     (package
6793       (name "sbcl-cl-containers")
6794       (version (git-version "0.12.1" revision commit))
6795       (source
6796        (origin
6797          (method git-fetch)
6798          (uri (git-reference
6799                (url "https://github.com/gwkkwg/cl-containers.git")
6800                (commit commit)))
6801          (file-name (git-file-name name version))
6802          (sha256
6803           (base32
6804            "18s6jfq11n8nv9k4biz32pm1s7y9zl054ry1gmdbcf39nisy377y"))))
6805       (build-system asdf-build-system/sbcl)
6806       (native-inputs
6807        `(("lift" ,sbcl-lift)))
6808       (inputs
6809        `(("metatilities-base" ,sbcl-metatilities-base)))
6810       (arguments
6811        '(#:phases
6812          (modify-phases %standard-phases
6813            (add-after 'unpack 'relax-version-checks
6814              (lambda _
6815                (substitute* "cl-containers.asd"
6816                  (("\\(:version \"metatilities-base\" \"0\\.6\\.6\"\\)")
6817                   "\"metatilities-base\""))
6818                (substitute* "cl-containers-test.asd"
6819                  (("\\(:version \"lift\" \"1\\.7\\.0\"\\)")
6820                   "\"lift\""))
6821                #t)))))
6822       (synopsis "Container library for Common Lisp")
6823       (description
6824        "Common Lisp ships with a set of powerful built in data structures
6825 including the venerable list, full featured arrays, and hash-tables.
6826 CL-containers enhances and builds on these structures by adding containers
6827 that are not available in native Lisp (for example: binary search trees,
6828 red-black trees, sparse arrays and so on), and by providing a standard
6829 interface so that they are simpler to use and so that changing design
6830 decisions becomes significantly easier.")
6831       (home-page "https://common-lisp.net/project/cl-containers/")
6832       (license license:expat))))
6833
6834 (define-public cl-containers
6835   (sbcl-package->cl-source-package sbcl-cl-containers))
6836
6837 (define-public ecl-cl-containers
6838   (sbcl-package->ecl-package sbcl-cl-containers))
6839
6840 (define-public sbcl-xlunit
6841   (let ((commit "3805d34b1d8dc77f7e0ee527a2490194292dd0fc")
6842         (revision "1"))
6843     (package
6844       (name "sbcl-xlunit")
6845       (version (git-version "0.6.3" revision commit))
6846       (source
6847        (origin
6848          (method git-fetch)
6849          (uri (git-reference
6850                (url "http://git.kpe.io/xlunit.git")
6851                (commit commit)))
6852          (file-name (git-file-name name version))
6853          (sha256
6854           (base32
6855            "0argfmp9nghs4sihyj3f8ch9qfib2b7ll07v5m9ziajgzsfl5xw3"))))
6856       (build-system asdf-build-system/sbcl)
6857       (arguments
6858        '(#:phases
6859          (modify-phases %standard-phases
6860            (add-after 'unpack 'fix-tests
6861              (lambda _
6862                (substitute* "xlunit.asd"
6863                  ((" :force t") ""))
6864                #t)))))
6865       (synopsis "Unit testing package for Common Lisp")
6866       (description
6867        "The XLUnit package is a toolkit for building test suites.  It is based
6868 on the XPTest package by Craig Brozensky and the JUnit package by Kent Beck.")
6869       (home-page "http://quickdocs.org/xlunit/")
6870       (license license:bsd-3))))
6871
6872 (define-public cl-xlunit
6873   (sbcl-package->cl-source-package sbcl-xlunit))
6874
6875 (define-public ecl-xlunit
6876   (sbcl-package->ecl-package sbcl-xlunit))
6877
6878 (define-public sbcl-fprog
6879   (let ((commit "7016d1a98215f82605d1c158e7a16504ca1f4636")
6880         (revision "1"))
6881     (package
6882       (name "sbcl-fprog")
6883       (version (git-version "1.0.0" revision commit))
6884       (source
6885        (origin
6886          (method git-fetch)
6887          (uri (git-reference
6888                (url "https://github.com/jwiegley/cambl.git")
6889                (commit commit)))
6890          (file-name (git-file-name name version))
6891          (sha256
6892           (base32
6893            "103mry04j2k9vznsxm7wcvccgxkil92cdrv52miwcmxl8daa4jiz"))))
6894       (build-system asdf-build-system/sbcl)
6895       (synopsis "Functional programming utilities for Common Lisp")
6896       (description
6897        "@code{fprog} is a Common Lisp library allowing iteration over
6898 immutable lists sharing identical sublists.")
6899       (home-page "https://github.com/jwiegley/cambl")
6900       (license license:bsd-3))))
6901
6902 (define-public cl-fprog
6903   (sbcl-package->cl-source-package sbcl-fprog))
6904
6905 (define-public ecl-fprog
6906   (sbcl-package->ecl-package sbcl-fprog))
6907
6908 (define-public sbcl-cambl
6909   (let ((commit "7016d1a98215f82605d1c158e7a16504ca1f4636")
6910         (revision "1"))
6911     (package
6912       (inherit sbcl-fprog)
6913       (name "sbcl-cambl")
6914       (version (git-version "4.0.0" revision commit))
6915       (native-inputs
6916        `(("xlunit" ,sbcl-xlunit)))
6917       (inputs
6918        `(("alexandria" ,sbcl-alexandria)
6919          ("cl-containers" ,sbcl-cl-containers)
6920          ("local-time" ,sbcl-local-time)
6921          ("periods" ,sbcl-periods)
6922          ("fprog" ,sbcl-fprog)))
6923       (synopsis "Commoditized amounts and balances for Common Lisp")
6924       (description
6925        "CAMBL is a Common Lisp library providing a convenient facility for
6926 working with commoditized values.  It does not allow compound units (and so is
6927 not suited for scientific operations) but does work rather nicely for the
6928 purpose of financial calculations."))))
6929
6930 (define-public cl-cambl
6931   (sbcl-package->cl-source-package sbcl-cambl))
6932
6933 (define-public ecl-cambl
6934   (sbcl-package->ecl-package sbcl-cambl))
6935
6936 (define-public sbcl-cl-ledger
6937   (let ((commit "08e0be41795e804cd36142e51756ad0b1caa377b")
6938         (revision "1"))
6939     (package
6940       (name "sbcl-cl-ledger")
6941       (version (git-version "4.0.0" revision commit))
6942       (source
6943        (origin
6944          (method git-fetch)
6945          (uri (git-reference
6946                (url "https://github.com/ledger/cl-ledger.git")
6947                (commit commit)))
6948          (file-name (git-file-name name version))
6949          (sha256
6950           (base32
6951            "1via0qf6wjcyxnfbmfxjvms0ik9j8rqbifgpmnhrzvkhrq9pv8h1"))))
6952       (build-system asdf-build-system/sbcl)
6953       (inputs
6954        `(("cambl" ,sbcl-cambl)
6955          ("cl-ppcre" ,sbcl-cl-ppcre)
6956          ("local-time" ,sbcl-local-time)
6957          ("periods-series" ,sbcl-periods-series)))
6958       (arguments
6959        '(#:phases
6960          (modify-phases %standard-phases
6961            (add-after 'unpack 'fix-system-definition
6962              (lambda _
6963                (substitute* "cl-ledger.asd"
6964                  (("  :build-operation program-op") "")
6965                  (("  :build-pathname \"cl-ledger\"") "")
6966                  (("  :entry-point \"ledger::main\"") ""))
6967                #t)))))
6968       (synopsis "Common Lisp port of the Ledger accounting system")
6969       (description
6970        "CL-Ledger is a Common Lisp port of the Ledger double-entry accounting
6971 system.")
6972       (home-page "https://github.com/ledger/cl-ledger")
6973       (license license:bsd-3))))
6974
6975 (define-public cl-ledger
6976   (sbcl-package->cl-source-package sbcl-cl-ledger))
6977
6978 (define-public ecl-cl-ledger
6979   (sbcl-package->ecl-package sbcl-cl-ledger))
6980
6981 (define-public sbcl-bst
6982   (let ((commit "34f9c7e8e0a9f2c952fe310ab36cb630d5d9c15a")
6983         (revision "1"))
6984     (package
6985       (name "sbcl-bst")
6986       (version (git-version "1.1" revision commit))
6987       (source
6988        (origin
6989          (method git-fetch)
6990          (uri (git-reference
6991                (url "https://github.com/glv2/bst.git")
6992                (commit commit)))
6993          (file-name (git-file-name name version))
6994          (sha256
6995           (base32
6996            "1amxns7hvvh4arwbh8ciwfzplg127vh37dnbamv1m1kmmnmihfc8"))))
6997       (build-system asdf-build-system/sbcl)
6998       (native-inputs
6999        `(("alexandria" ,sbcl-alexandria)
7000          ("fiveam" ,sbcl-fiveam)))
7001       (synopsis "Binary search tree for Common Lisp")
7002       (description
7003        "BST is a Common Lisp library for working with binary search trees that
7004 can contain any kind of values.")
7005       (home-page "https://github.com/glv2/bst")
7006       (license license:gpl3))))
7007
7008 (define-public cl-bst
7009   (sbcl-package->cl-source-package sbcl-bst))
7010
7011 (define-public ecl-bst
7012   (sbcl-package->ecl-package sbcl-bst))
7013
7014 (define-public sbcl-cl-octet-streams
7015   (package
7016     (name "sbcl-cl-octet-streams")
7017     (version "1.0")
7018     (source
7019      (origin
7020        (method git-fetch)
7021        (uri (git-reference
7022              (url "https://github.com/glv2/cl-octet-streams.git")
7023              (commit (string-append "v" version))))
7024        (file-name (git-file-name name version))
7025        (sha256
7026         (base32
7027          "1d7mn6ydv0j2x4r7clpc9ijjwrnfpxmvhifv8n5j7jh7s744sf8d"))))
7028     (build-system asdf-build-system/sbcl)
7029     (native-inputs
7030      `(("fiveam" ,sbcl-fiveam)))
7031     (inputs
7032      `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
7033     (synopsis "In-memory octet streams for Common Lisp")
7034     (description
7035      "CL-octet-streams is a library implementing in-memory octet
7036 streams for Common Lisp.  It was inspired by the trivial-octet-streams and
7037 cl-plumbing libraries.")
7038     (home-page "https://github.com/glv2/cl-octet-streams")
7039     (license license:gpl3+)))
7040
7041 (define-public cl-octet-streams
7042   (sbcl-package->cl-source-package sbcl-cl-octet-streams))
7043
7044 (define-public ecl-cl-octet-streams
7045   (sbcl-package->ecl-package sbcl-cl-octet-streams))
7046
7047 (define-public sbcl-lzlib
7048   (let ((commit "0de1db7129fef9a58a059d35a2fa2ecfc5b47b47")
7049         (revision "1"))
7050     (package
7051       (name "sbcl-lzlib")
7052       (version (git-version "1.0" revision commit))
7053       (source
7054        (origin
7055          (method git-fetch)
7056          (uri (git-reference
7057                (url "https://github.com/glv2/cl-lzlib.git")
7058                (commit commit)))
7059          (file-name (git-file-name name version))
7060          (sha256
7061           (base32
7062            "12ny7vj52fgnd8hb8fc8mry92vq4c1x72x2350191m4476j95clz"))))
7063       (build-system asdf-build-system/sbcl)
7064       (native-inputs
7065        `(("fiveam" ,sbcl-fiveam)))
7066       (inputs
7067        `(("cffi" ,sbcl-cffi)
7068          ("cl-octet-streams" ,sbcl-cl-octet-streams)
7069          ("lzlib" ,lzlib)))
7070       (arguments
7071        '(#:phases
7072          (modify-phases %standard-phases
7073            (add-after 'unpack 'fix-paths
7074              (lambda* (#:key inputs #:allow-other-keys)
7075                (substitute* "src/lzlib.lisp"
7076                  (("liblz\\.so")
7077                   (string-append (assoc-ref inputs "lzlib") "/lib/liblz.so")))
7078                #t)))))
7079       (synopsis "Common Lisp library for lzip (de)compression")
7080       (description
7081        "This Common Lisp library provides functions for lzip (LZMA)
7082 compression/decompression using bindings to the lzlib C library.")
7083       (home-page "https://github.com/glv2/cl-lzlib")
7084       (license license:gpl3+))))
7085
7086 (define-public cl-lzlib
7087   (sbcl-package->cl-source-package sbcl-lzlib))
7088
7089 (define-public ecl-lzlib
7090   (sbcl-package->ecl-package sbcl-lzlib))
7091
7092 (define-public sbcl-chanl
7093   (let ((commit "56e90a126c78b39bb621a01585e8d3b985238e8c")
7094         (revision "1"))
7095     (package
7096       (name "sbcl-chanl")
7097       (version (git-version "0.4.1" revision commit))
7098       (source
7099        (origin
7100          (method git-fetch)
7101          (uri (git-reference
7102                (url "https://github.com/zkat/chanl.git")
7103                (commit commit)))
7104          (file-name (git-file-name name version))
7105          (sha256
7106           (base32
7107            "0b1cf6c12qx5cy1fw2z42jgh566rp3l8nv5qf0qqc569s7bgmrh4"))))
7108       (build-system asdf-build-system/sbcl)
7109       (native-inputs
7110        `(("fiveam" ,sbcl-fiveam)))
7111       (inputs
7112        `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
7113       (synopsis "Portable channel-based concurrency for Common Lisp")
7114       (description "Common Lisp library for channel-based concurrency.  In
7115 a nutshell, you create various threads sequentially executing tasks you need
7116 done, and use channel objects to communicate and synchronize the state of these
7117 threads.")
7118       (home-page "https://github.com/zkat/chanl")
7119       (license (list license:expat license:bsd-3)))))
7120
7121 (define-public cl-chanl
7122   (sbcl-package->cl-source-package sbcl-chanl))
7123
7124 (define-public ecl-chanl
7125   (sbcl-package->ecl-package sbcl-chanl))
7126
7127 (define-public sbcl-cl-store
7128   (let ((commit "c787337a16ea8cf8a06227f35933a4ec774746b3")
7129         (revision "1"))
7130     (package
7131       (name "sbcl-cl-store")
7132       (version (git-version "0.8.11" revision commit))
7133       (source
7134        (origin
7135          (method git-fetch)
7136          (uri (git-reference
7137                (url "https://github.com/skypher/cl-store.git")
7138                (commit commit)))
7139          (file-name (git-file-name name version))
7140          (sha256
7141           (base32
7142            "194srkg8nrym19c6i7zbnkzshc1qhqa82m53qnkirz9fw928bqxr"))))
7143       (build-system asdf-build-system/sbcl)
7144       (native-inputs
7145        `(("rt" ,sbcl-rt)))
7146       (synopsis "Common Lisp library to serialize data")
7147       (description
7148        "CL-STORE is a portable serialization package which should give you the
7149 ability to store all Common Lisp data types into streams.")
7150       (home-page "https://www.common-lisp.net/project/cl-store/")
7151       (license license:expat))))
7152
7153 (define-public cl-store
7154   (sbcl-package->cl-source-package sbcl-cl-store))
7155
7156 (define-public ecl-cl-store
7157   (sbcl-package->ecl-package sbcl-cl-store))
7158
7159 (define-public sbcl-cl-gobject-introspection
7160   (let ((commit "7b703e2384945ea0ac39d9b766de434a08d81560")
7161         (revision "0"))
7162     (package
7163       (name "sbcl-cl-gobject-introspection")
7164       (version (git-version "0.3" revision commit))
7165       (home-page "https://github.com/andy128k/cl-gobject-introspection")
7166       (source
7167        (origin
7168          (method git-fetch)
7169          (uri (git-reference
7170                (url home-page)
7171                (commit commit)))
7172          (file-name (git-file-name name version))
7173          (sha256
7174           (base32
7175            "1zcqd2qj14f6b38vys8gr89s6cijsp9r8j43xa8lynilwva7bwyh"))))
7176       (build-system asdf-build-system/sbcl)
7177       (inputs
7178        `(("alexandria" ,sbcl-alexandria)
7179          ("cffi" ,sbcl-cffi)
7180          ("iterate" ,sbcl-iterate)
7181          ("trivial-garbage" ,sbcl-trivial-garbage)
7182          ("glib" ,glib)
7183          ("gobject-introspection" ,gobject-introspection)))
7184       (native-inputs
7185        `(("fiveam" ,sbcl-fiveam)))
7186       (arguments
7187        ;; TODO: Tests fail, see
7188        ;; https://github.com/andy128k/cl-gobject-introspection/issues/70.
7189        '(#:tests? #f
7190          #:phases
7191          (modify-phases %standard-phases
7192            (add-after (quote unpack) (quote fix-paths)
7193              (lambda* (#:key inputs #:allow-other-keys)
7194                (substitute* "src/init.lisp"
7195                  (("libgobject-2\\.0\\.so")
7196                   (string-append (assoc-ref inputs "glib") "/lib/libgobject-2.0.so"))
7197                  (("libgirepository-1\\.0\\.so")
7198                   (string-append (assoc-ref inputs "gobject-introspection")
7199                                  "/lib/libgirepository-1.0.so")))
7200                #t)))))
7201       (synopsis "Common Lisp bindings to GObject Introspection")
7202       (description
7203        "This library is a bridge between Common Lisp and GObject
7204 Introspection, which enables Common Lisp programs to access the full interface
7205 of C+GObject libraries without the need of writing dedicated bindings.")
7206       (license (list license:bsd-3
7207                      ;; Tests are under a different license.
7208                      license:llgpl)))))
7209
7210 (define-public cl-gobject-introspection
7211   (sbcl-package->cl-source-package sbcl-cl-gobject-introspection))
7212
7213 (define-public sbcl-string-case
7214   (let ((commit "718c761e33749e297cd2809c7ba3ade1985c49f7")
7215         (revision "0"))
7216     (package
7217       (name "sbcl-string-case")
7218       (version (git-version "0.0.2" revision commit))
7219       (home-page "https://github.com/pkhuong/string-case")
7220       (source
7221        (origin
7222          (method git-fetch)
7223          (uri (git-reference
7224                (url home-page)
7225                (commit commit)))
7226          (file-name (git-file-name name version))
7227          (sha256
7228           (base32
7229            "1n5i3yh0h5s636rcnwn7jwqy3rjflikra04lymimhpcshhjsk0md"))))
7230       (build-system asdf-build-system/sbcl)
7231       (synopsis "Efficient string= case in Common Lisp")
7232       (description
7233        "@code{string-case} is a Common Lisp macro that generates specialised decision
7234 trees to dispatch on string equality.")
7235       (license license:bsd-3))))
7236
7237 (define-public cl-string-case
7238   (sbcl-package->cl-source-package sbcl-string-case))
7239
7240 (define-public ecl-string-case
7241   (sbcl-package->ecl-package sbcl-string-case))
7242
7243 (define-public sbcl-global-vars
7244   (let ((commit "c749f32c9b606a1457daa47d59630708ac0c266e")
7245         (revision "0"))
7246     (package
7247       (name "sbcl-global-vars")
7248       (version (git-version "1.0.0" revision commit))
7249       (home-page "https://github.com/lmj/global-vars")
7250       (source
7251        (origin
7252          (method git-fetch)
7253          (uri (git-reference
7254                (url home-page)
7255                (commit commit)))
7256          (file-name (git-file-name name version))
7257          (sha256
7258           (base32
7259            "06m3xc8l3pgsapl8fvsi9wf6y46zs75cp9zn7zh6dc65v4s5wz3d"))))
7260       (build-system asdf-build-system/sbcl)
7261       (synopsis "Efficient global variables in Common Lisp")
7262       (description
7263        "In Common Lisp, a special variable that is never dynamically bound
7264 typically serves as a stand-in for a global variable.  The @code{global-vars}
7265 library provides true global variables that are implemented by some compilers.
7266 An attempt to rebind a global variable properly results in a compiler error.
7267 That is, a global variable cannot be dynamically bound.
7268
7269 Global variables therefore allow us to communicate an intended usage that
7270 differs from special variables.  Global variables are also more efficient than
7271 special variables, especially in the presence of threads.")
7272       (license license:expat))))
7273
7274 (define-public cl-global-vars
7275   (sbcl-package->cl-source-package sbcl-global-vars))
7276
7277 (define-public ecl-global-vars
7278   (sbcl-package->ecl-package sbcl-global-vars))
7279
7280 (define-public sbcl-trivial-file-size
7281   (let ((commit "1c1d672a01a446ba0391dbb4ffc40be3b0476f23")
7282         (revision "0"))
7283     (package
7284       (name "sbcl-trivial-file-size")
7285       (version (git-version "0.0.0" revision commit))
7286       (home-page "https://github.com/ruricolist/trivial-file-size")
7287       (source
7288        (origin
7289          (method git-fetch)
7290          (uri (git-reference
7291                (url home-page)
7292                (commit commit)))
7293          (file-name (git-file-name name version))
7294          (sha256
7295           (base32
7296            "17pp86c9zs4y7i1sh7q9gbfw9iqv6655k7fz8qbj9ly1ypgxp4qs"))))
7297       (build-system asdf-build-system/sbcl)
7298       (native-inputs
7299        `(("fiveam" ,sbcl-fiveam)))
7300       (synopsis "Size of a file in bytes in Common Lisp")
7301       (description
7302        "The canonical way to determine the size of a file in bytes, using Common Lisp,
7303 is to open the file with an element type of (unsigned-byte 8) and then
7304 calculate the length of the stream.  This is less than ideal.  In most cases
7305 it is better to get the size of the file from its metadata, using a system
7306 call.
7307
7308 This library exports a single function, file-size-in-octets.  It returns the
7309 size of a file in bytes, using system calls when possible.")
7310       (license license:expat))))
7311
7312 (define-public cl-trivial-file-size
7313   (sbcl-package->cl-source-package sbcl-trivial-file-size))
7314
7315 (define-public ecl-trivial-file-size
7316   (sbcl-package->ecl-package sbcl-trivial-file-size))
7317
7318 (define-public sbcl-trivial-macroexpand-all
7319   (let ((commit "933270ac7107477de1bc92c1fd641fe646a7a8a9")
7320         (revision "0"))
7321     (package
7322       (name "sbcl-trivial-macroexpand-all")
7323       (version (git-version "0.0.0" revision commit))
7324       (home-page "https://github.com/cbaggers/trivial-macroexpand-all")
7325       (source
7326        (origin
7327          (method git-fetch)
7328          (uri (git-reference
7329                (url home-page)
7330                (commit commit)))
7331          (file-name (git-file-name name version))
7332          (sha256
7333           (base32
7334            "191hnn4b5j4i3crydmlzbm231kj0h7l8zj6mzj69r1npbzkas4bd"))))
7335       (build-system asdf-build-system/sbcl)
7336       (native-inputs
7337        `(("fiveam" ,sbcl-fiveam)))
7338       (synopsis "Portable macroexpand-all for Common Lisp")
7339       (description
7340        "This library provides a macroexpand-all function that calls the
7341 implementation specific equivalent.")
7342       (license license:unlicense))))
7343
7344 (define-public cl-trivial-macroexpand-all
7345   (sbcl-package->cl-source-package sbcl-trivial-macroexpand-all))
7346
7347 (define-public ecl-trivial-macroexpand-all
7348   (sbcl-package->ecl-package sbcl-trivial-macroexpand-all))
7349
7350 (define-public sbcl-serapeum
7351   (let ((commit "64f0c4a161bbbda7c275012ca1415b4293b9e169")
7352         (revision "1"))
7353     (package
7354       (name "sbcl-serapeum")
7355       (version (git-version "0.0.0" revision commit))
7356       (home-page "https://github.com/ruricolist/serapeum")
7357       (source
7358        (origin
7359          (method git-fetch)
7360          (uri (git-reference
7361                (url home-page)
7362                (commit commit)))
7363          (file-name (git-file-name name version))
7364          (sha256
7365           (base32
7366            "0djnj0py8hdjnk5j6shjq2kbmyxqd5sw79cilcfmpfz4dzjdgkx9"))))
7367       (build-system asdf-build-system/sbcl)
7368       (inputs
7369        `(("alexandria" ,sbcl-alexandria)
7370          ("trivia" ,sbcl-trivia)
7371          ("trivia.quasiquote" ,sbcl-trivia.quasiquote)
7372          ("split-sequence" ,sbcl-split-sequence)
7373          ("string-case" ,sbcl-string-case)
7374          ("parse-number" ,sbcl-parse-number)
7375          ("trivial-garbage" ,sbcl-trivial-garbage)
7376          ("bordeaux-threads" ,sbcl-bordeaux-threads)
7377          ("named-readtables" ,sbcl-named-readtables)
7378          ("fare-quasiquote-extras" ,sbcl-fare-quasiquote-extras)
7379          ("parse-declarations-1.0" ,sbcl-parse-declarations)
7380          ("global-vars" ,sbcl-global-vars)
7381          ("trivial-file-size" ,sbcl-trivial-file-size)
7382          ("trivial-macroexpand-all" ,sbcl-trivial-macroexpand-all)))
7383       (native-inputs
7384        `(("fiveam" ,sbcl-fiveam)
7385          ("local-time" ,sbcl-local-time)))
7386       (arguments
7387        '(#:phases
7388          (modify-phases %standard-phases
7389            (add-after 'unpack 'disable-failing-tests
7390              (lambda* (#:key inputs #:allow-other-keys)
7391                (substitute* "serapeum.asd"
7392                  ;; Guix does not have Quicklisp, and probably never will.
7393                  (("\\(:file \"quicklisp\"\\)") ""))
7394                #t)))))
7395       (synopsis "Common Lisp utility library beyond Alexandria")
7396       (description
7397        "Serapeum is a conservative library of Common Lisp utilities.  It is a
7398 supplement, not a competitor, to Alexandria.")
7399       (license license:expat))))
7400
7401 (define-public cl-serapeum
7402   (sbcl-package->cl-source-package sbcl-serapeum))
7403
7404 (define-public sbcl-arrows
7405   (let ((commit "df7cf0067e0132d9697ac8b1a4f1b9c88d4f5382")
7406         (revision "0"))
7407     (package
7408       (name "sbcl-arrows")
7409       (version (git-version "0.2.0" revision commit))
7410       (source
7411        (origin
7412          (method git-fetch)
7413          (uri (git-reference
7414                (url "https://gitlab.com/Harleqin/arrows.git")
7415                (commit commit)))
7416          (file-name (git-file-name name version))
7417          (sha256
7418           (base32
7419            "042k9vkssrqx9nhp14wdzm942zgdxvp35mba0p2syz98i75im2yy"))))
7420       (build-system asdf-build-system/sbcl)
7421       (native-inputs
7422        `(("hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
7423       (synopsis "Clojure-like arrow macros for Common Lisp")
7424       (description
7425        "This library implements the @code{->} and @code{->>} macros from
7426 Clojure, as well as several expansions on the idea.")
7427       (home-page "https://gitlab.com/Harleqin/arrows")
7428       (license license:public-domain))))
7429
7430 (define-public cl-arrows
7431   (sbcl-package->cl-source-package sbcl-arrows))
7432
7433 (define-public ecl-arrows
7434   (sbcl-package->ecl-package sbcl-arrows))
7435
7436 (define-public sbcl-simple-parallel-tasks
7437   (let ((commit "db460f7a3f7bbfe2d3a2223ed21e162068d04dda")
7438         (revision "0"))
7439     (package
7440       (name "sbcl-simple-parallel-tasks")
7441       (version (git-version "1.0" revision commit))
7442       (source
7443        (origin
7444          (method git-fetch)
7445          (uri (git-reference
7446                (url "https://github.com/glv2/simple-parallel-tasks.git")
7447                (commit commit)))
7448          (file-name (git-file-name name version))
7449          (sha256
7450           (base32
7451            "0amw3qk23wnlyrsgzszs6rs7y4zvxv8dr03rnqhc60mnm8ds4dd5"))))
7452       (build-system asdf-build-system/sbcl)
7453       (native-inputs
7454        `(("fiveam" ,sbcl-fiveam)))
7455       (inputs
7456        `(("chanl" ,sbcl-chanl)))
7457       (synopsis "Common Lisp library to evaluate some forms in parallel")
7458       (description "This is a simple Common Lisp library to evaluate some
7459 forms in parallel.")
7460       (home-page "https://github.com/glv2/simple-parallel-tasks")
7461       (license license:gpl3))))
7462
7463 (define-public cl-simple-parallel-tasks
7464   (sbcl-package->cl-source-package sbcl-simple-parallel-tasks))
7465
7466 (define-public ecl-simple-parallel-tasks
7467   (sbcl-package->ecl-package sbcl-simple-parallel-tasks))
7468
7469 (define-public sbcl-cl-heap
7470   (package
7471     (name "sbcl-cl-heap")
7472     (version "0.1.6")
7473     (source
7474      (origin
7475        (method url-fetch)
7476        (uri (string-append "https://common-lisp.net/project/cl-heap/releases/"
7477                            "cl-heap_" version ".tar.gz"))
7478        (sha256
7479         (base32
7480          "163hb07p2nxz126rpq3cj5dyala24n0by5i5786n2qcr1w0bak4i"))))
7481     (build-system asdf-build-system/sbcl)
7482     (native-inputs
7483      `(("xlunit" ,sbcl-xlunit)))
7484     (arguments
7485      `(#:test-asd-file "cl-heap-tests.asd"))
7486     (synopsis "Heap and priority queue data structures for Common Lisp")
7487     (description
7488      "CL-HEAP provides various implementations of heap data structures (a
7489 binary heap and a Fibonacci heap) as well as an efficient priority queue.")
7490     (home-page "https://common-lisp.net/project/cl-heap/")
7491     (license license:gpl3+)))
7492
7493 (define-public cl-heap
7494   (sbcl-package->cl-source-package sbcl-cl-heap))
7495
7496 (define-public ecl-cl-heap
7497   (sbcl-package->ecl-package sbcl-cl-heap))
7498
7499 (define-public sbcl-curry-compose-reader-macros
7500   (let ((commit "beaa92dedf392726c042184bfd6149fa8d9e6ac2")
7501         (revision "0"))
7502     (package
7503       (name "sbcl-curry-compose-reader-macros")
7504       (version (git-version "1.0.0" revision commit))
7505       (source
7506        (origin
7507          (method git-fetch)
7508          (uri
7509           (git-reference
7510            (url "https://github.com/eschulte/curry-compose-reader-macros.git")
7511            (commit commit)))
7512          (file-name (git-file-name name version))
7513          (sha256
7514           (base32
7515            "0rv9bl8xrad5wfcg5zs1dazvnpmvqz6297lbn8bywsrcfnlf7h98"))))
7516       (build-system asdf-build-system/sbcl)
7517       (inputs
7518        `(("alexandria" ,sbcl-alexandria)
7519          ("named-readtables" ,sbcl-named-readtables)))
7520       (synopsis "Reader macros for partial application and composition")
7521       (description
7522        "This Common Lisp library provides reader macros for concise expression
7523 of function partial application and composition.")
7524       (home-page "https://eschulte.github.io/curry-compose-reader-macros/")
7525       (license license:public-domain))))
7526
7527 (define-public cl-curry-compose-reader-macros
7528   (sbcl-package->cl-source-package sbcl-curry-compose-reader-macros))
7529
7530 (define-public ecl-curry-compose-reader-macros
7531   (sbcl-package->ecl-package sbcl-curry-compose-reader-macros))
7532
7533 (define-public sbcl-yason
7534   (package
7535     (name "sbcl-yason")
7536     (version "0.7.7")
7537     (source
7538      (origin
7539        (method git-fetch)
7540        (uri (git-reference
7541              (url "https://github.com/phmarek/yason.git")
7542              (commit (string-append "v" version))))
7543        (file-name (git-file-name name version))
7544        (sha256
7545         (base32
7546          "0479rbjgbj80jpk5bby18inlv1kfp771a82rlcq5psrz65qqa9bj"))))
7547     (build-system asdf-build-system/sbcl)
7548     (inputs
7549      `(("alexandria" ,sbcl-alexandria)
7550        ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
7551     (synopsis "Common Lisp JSON parser/encoder")
7552     (description
7553      "YASON is a Common Lisp library for encoding and decoding data in the
7554 JSON interchange format.")
7555     (home-page "https://github.com/phmarek/yason")
7556     (license license:bsd-3)))
7557
7558 (define-public cl-yason
7559   (sbcl-package->cl-source-package sbcl-yason))
7560
7561 (define-public ecl-yason
7562   (sbcl-package->ecl-package sbcl-yason))
7563
7564 (define-public sbcl-stefil
7565   (let ((commit "0398548ec95dceb50fc2c2c03e5fb0ce49b86c7a")
7566         (revision "0"))
7567     (package
7568       (name "sbcl-stefil")
7569       (version (git-version "0.1" revision commit))
7570       (source
7571        (origin
7572          (method git-fetch)
7573          (uri (git-reference
7574                (url "https://gitlab.common-lisp.net/stefil/stefil.git")
7575                (commit commit)))
7576          (file-name (git-file-name name version))
7577          (sha256
7578           (base32
7579            "0bqz64q2szzhf91zyqyssmvrz7da6442rs01808pf3wrdq28bclh"))))
7580       (build-system asdf-build-system/sbcl)
7581       (inputs
7582        `(("alexandria" ,sbcl-alexandria)
7583          ("iterate" ,sbcl-iterate)
7584          ("metabang-bind" ,sbcl-metabang-bind)))
7585       (propagated-inputs
7586        ;; Swank doesn't have a pre-compiled package, therefore we must
7587        ;; propagate its sources.
7588        `(("swank" ,cl-slime-swank)))
7589       (arguments
7590        '(#:phases
7591          (modify-phases %standard-phases
7592            (add-after 'unpack 'drop-unnecessary-dependency
7593              (lambda _
7594                (substitute* "package.lisp"
7595                  ((":stefil-system") ""))
7596                #t)))))
7597       (home-page "https://common-lisp.net/project/stefil/index-old.shtml")
7598       (synopsis "Simple test framework")
7599       (description
7600        "Stefil is a simple test framework for Common Lisp, with a focus on
7601 interactive development.")
7602       (license license:public-domain))))
7603
7604 (define-public cl-stefil
7605   (sbcl-package->cl-source-package sbcl-stefil))
7606
7607 (define-public sbcl-graph
7608   (let ((commit "78bf9ec930d8eae4f0861b5be76765fb1e45e24f")
7609         (revision "0"))
7610     (package
7611       (name "sbcl-graph")
7612       (version (git-version "0.0.0" revision commit))
7613       (source
7614        (origin
7615          (method git-fetch)
7616          (uri
7617           (git-reference
7618            (url "https://github.com/eschulte/graph.git")
7619            (commit commit)))
7620          (file-name (git-file-name name version))
7621          (sha256
7622           (base32
7623            "1qpij4xh8bqwc2myahpilcbh916v7vg0acz2fij14d3y0jm02h0g"))
7624          (patches (search-patches "sbcl-graph-asdf-definitions.patch"))))
7625       (build-system asdf-build-system/sbcl)
7626       (native-inputs
7627        `(("stefil" ,sbcl-stefil)))
7628       (inputs
7629        `(("alexandria" ,sbcl-alexandria)
7630          ("cl-heap" ,sbcl-cl-heap)
7631          ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
7632          ("metabang-bind" ,sbcl-metabang-bind)
7633          ("named-readtables" ,sbcl-named-readtables)))
7634       (arguments
7635        '(#:test-asd-file "graph-test.asd"))
7636       (synopsis "Graph data structure and algorithms for Common Lisp")
7637       (description
7638        "The GRAPH Common Lisp library provides a data structures to represent
7639 graphs, as well as some graph manipulation and analysis algorithms (shortest
7640 path, maximum flow, minimum spanning tree, etc.).")
7641       (home-page "https://eschulte.github.io/graph/")
7642       (license license:gpl3+))))
7643
7644 (define-public cl-graph
7645   (sbcl-package->cl-source-package sbcl-graph))
7646
7647 (define-public sbcl-graph-dot
7648   (package
7649     (inherit sbcl-graph)
7650     (name "sbcl-graph-dot")
7651     (inputs
7652      `(("alexandria" ,sbcl-alexandria)
7653        ("cl-ppcre" ,sbcl-cl-ppcre)
7654        ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
7655        ("graph" ,sbcl-graph)
7656        ("metabang-bind" ,sbcl-metabang-bind)
7657        ("named-readtables" ,sbcl-named-readtables)))
7658     (arguments
7659      (substitute-keyword-arguments (package-arguments sbcl-graph)
7660        ((#:asd-file _ "") "graph-dot.asd")
7661        ((#:asd-system-name _ #f) "graph-dot")))
7662     (synopsis "Serialize graphs to and from DOT format")))
7663
7664 (define-public sbcl-graph-json
7665   (package
7666     (inherit sbcl-graph)
7667     (name "sbcl-graph-json")
7668     (inputs
7669      `(("alexandria" ,sbcl-alexandria)
7670        ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
7671        ("graph" ,sbcl-graph)
7672        ("metabang-bind" ,sbcl-metabang-bind)
7673        ("named-readtables" ,sbcl-named-readtables)
7674        ("yason" ,sbcl-yason)))
7675     (arguments
7676      (substitute-keyword-arguments (package-arguments sbcl-graph)
7677        ((#:asd-file _ "") "graph-json.asd")
7678        ((#:asd-system-name _ #f) "graph-json")))
7679     (synopsis "Serialize graphs to and from JSON format")))
7680
7681 (define-public sbcl-trivial-indent
7682   (let ((commit "2d016941751647c6cc5bd471751c2cf68861c94a")
7683         (revision "0"))
7684     (package
7685       (name "sbcl-trivial-indent")
7686       (version (git-version "1.0.0" revision commit))
7687       (source
7688        (origin
7689          (method git-fetch)
7690          (uri
7691           (git-reference
7692            (url "https://github.com/Shinmera/trivial-indent")
7693            (commit commit)))
7694          (file-name (git-file-name name version))
7695          (sha256
7696           (base32
7697            "1sj90nqz17w4jq0ixz00gb9g5g6d2s7l8r17zdby27gxxh51w266"))))
7698       (build-system asdf-build-system/sbcl)
7699       (synopsis "Simple Common Lisp library to allow indentation hints for SWANK")
7700       (description
7701        "This library allows you to define custom indentation hints for your
7702 macros if the one recognised by SLIME automatically produces unwanted
7703 results.")
7704       (home-page "https://shinmera.github.io/trivial-indent/")
7705       (license license:zlib))))
7706
7707 (define-public cl-trivial-indent
7708   (sbcl-package->cl-source-package sbcl-trivial-indent))
7709
7710 (define-public sbcl-documentation-utils
7711   (let ((commit "98630dd5f7e36ae057fa09da3523f42ccb5d1f55")
7712         (revision "0"))
7713     (package
7714       (name "sbcl-documentation-utils")
7715       (version (git-version "1.2.0" revision commit))
7716       (source
7717        (origin
7718          (method git-fetch)
7719          (uri
7720           (git-reference
7721            (url "https://github.com/Shinmera/documentation-utils.git")
7722            (commit commit)))
7723          (file-name (git-file-name name version))
7724          (sha256
7725           (base32
7726            "098qhkqskmmrh4wix34mawf7p5c87yql28r51r75yjxj577k5idq"))))
7727       (build-system asdf-build-system/sbcl)
7728       (inputs
7729        `(("trivial-indent" ,sbcl-trivial-indent)))
7730       (synopsis "Few simple tools to document Common Lisp libraries")
7731       (description
7732        "This is a small library to help you with managing the Common Lisp
7733 docstrings for your library.")
7734       (home-page "https://shinmera.github.io/documentation-utils/")
7735       (license license:zlib))))
7736
7737 (define-public cl-documentation-utils
7738   (sbcl-package->cl-source-package sbcl-documentation-utils))
7739
7740 (define-public ecl-documentation-utils
7741   (sbcl-package->ecl-package sbcl-documentation-utils))
7742
7743 (define-public sbcl-form-fiddle
7744   (let ((commit "e0c23599dbb8cff3e83e012f3d86d0764188ad18")
7745         (revision "0"))
7746     (package
7747       (name "sbcl-form-fiddle")
7748       (version (git-version "1.1.0" revision commit))
7749       (source
7750        (origin
7751          (method git-fetch)
7752          (uri
7753           (git-reference
7754            (url "https://github.com/Shinmera/form-fiddle")
7755            (commit commit)))
7756          (file-name (git-file-name name version))
7757          (sha256
7758           (base32
7759            "041iznc9mpfyrl0sv5893ys9pbb2pvbn9g3clarqi7gsfj483jln"))))
7760       (build-system asdf-build-system/sbcl)
7761       (inputs
7762        `(("documentation-utils" ,sbcl-documentation-utils)))
7763       (synopsis "Utilities to destructure Common Lisp lambda forms")
7764       (description
7765        "Often times we need to destructure a form definition in a Common Lisp
7766 macro.  This library provides a set of simple utilities to help with that.")
7767       (home-page "https://shinmera.github.io/form-fiddle/")
7768       (license license:zlib))))
7769
7770 (define-public cl-form-fiddle
7771   (sbcl-package->cl-source-package sbcl-form-fiddle))
7772
7773 (define-public sbcl-parachute
7774   (let ((commit "ca04dd8e43010a6dfffa26dbe1d62af86008d666")
7775         (revision "0"))
7776     (package
7777       (name "sbcl-parachute")
7778       (version (git-version "1.1.1" revision commit))
7779       (source
7780        (origin
7781          (method git-fetch)
7782          (uri
7783           (git-reference
7784            (url "https://github.com/Shinmera/parachute")
7785            (commit commit)))
7786          (file-name (git-file-name name version))
7787          (sha256
7788           (base32
7789            "1mvsm3r0r6a2bg75nw0q7n9vlby3ch45qjl7hnb5k1z2n5x5lh60"))))
7790       (build-system asdf-build-system/sbcl)
7791       (inputs
7792        `(("documentation-utils" ,sbcl-documentation-utils)
7793          ("form-fiddle" ,sbcl-form-fiddle)))
7794       (synopsis "Extensible and cross-compatible testing framework for Common Lisp")
7795       (description
7796        "Parachute is a simple-to-use and extensible testing framework.
7797 In Parachute, things are organised as a bunch of named tests within a package.
7798 Each test can contain a bunch of test forms that make up its body.")
7799       (home-page "https://shinmera.github.io/parachute/")
7800       (license license:zlib))))
7801
7802 (define-public cl-parachute
7803   (sbcl-package->cl-source-package sbcl-parachute))
7804
7805 (define-public sbcl-array-utils
7806   (let ((commit "f90eb9070d0b2205af51126a35033574725e5c56")
7807         (revision "0"))
7808     (package
7809       (name "sbcl-array-utils")
7810       (version (git-version "1.1.1" revision commit))
7811       (source
7812        (origin
7813          (method git-fetch)
7814          (uri
7815           (git-reference
7816            (url "https://github.com/Shinmera/array-utils")
7817            (commit commit)))
7818          (file-name (git-file-name name version))
7819          (sha256
7820           (base32
7821            "0zhwfbpr53vs1ii4sx75dz2k9yhh1xpwdqqpg8nmfndxkmhpbi3x"))))
7822       (build-system asdf-build-system/sbcl)
7823       (native-inputs
7824        `(("parachute" ,sbcl-parachute)))
7825       (inputs
7826        `(("documentation-utils" ,sbcl-documentation-utils)))
7827       (synopsis "Tiny collection of array and vector utilities for Common Lisp")
7828       (description
7829        "A miniature toolkit that contains some useful shifting/popping/pushing
7830 functions for arrays and vectors.  Originally from Plump.")
7831       (home-page "https://shinmera.github.io/array-utils/")
7832       (license license:zlib))))
7833
7834 (define-public cl-array-utils
7835   (sbcl-package->cl-source-package sbcl-array-utils))
7836
7837 (define-public sbcl-plump
7838   (let ((commit "34f890fe46efdebe7bb70d218f1937e98f632bf9")
7839         (revision "1"))
7840     (package
7841       (name "sbcl-plump")
7842       (version (git-version "2.0.0" revision commit))
7843       (source
7844        (origin
7845          (method git-fetch)
7846          (uri
7847           (git-reference
7848            (url "https://github.com/Shinmera/plump")
7849            (commit commit)))
7850          (file-name (git-file-name name version))
7851          (sha256
7852           (base32
7853            "0a0x8wn6vv1ylxcwck12k18gy0a366kdm6ddxxk7yynl4mwnqgkh"))))
7854       (build-system asdf-build-system/sbcl)
7855       (inputs
7856        `(("array-utils" ,sbcl-array-utils)
7857          ("documentation-utils" ,sbcl-documentation-utils)))
7858       (synopsis "Lenient XML / XHTML / HTML parser for Common Lisp")
7859       (description
7860        "Plump is a parser for HTML/XML-like documents, focusing on being
7861 lenient towards invalid markup.  It can handle things like invalid attributes,
7862 bad closing tag order, unencoded entities, inexistent tag types, self-closing
7863 tags and so on.  It parses documents to a class representation and offers a
7864 small set of DOM functions to manipulate it.  It can be extended to parse to
7865 your own classes.")
7866       (home-page "https://shinmera.github.io/plump/")
7867       (license license:zlib))))
7868
7869 (define-public cl-plump
7870   (sbcl-package->cl-source-package sbcl-plump))
7871
7872 (define-public sbcl-antik-base
7873   (let ((commit "e4711a69b3d6bf37b5727af05c3cfd03e8428ba3")
7874         (revision "1"))
7875     (package
7876       (name "sbcl-antik-base")
7877       (version (git-version "0.0.0" revision commit))
7878       (source
7879        (origin
7880          (method git-fetch)
7881          (uri (git-reference
7882                (url "https://gitlab.common-lisp.net/antik/antik.git")
7883                (commit commit)))
7884          (file-name (git-file-name name version))
7885          (sha256
7886           (base32
7887            "047ga2c38par2xbgg4qx6hwv06qhf1c1f67as8xvir6s80lip1km"))))
7888       (build-system asdf-build-system/sbcl)
7889       (inputs
7890        `(("alexandria" ,sbcl-alexandria)
7891          ("cl-ppcre" ,sbcl-cl-ppcre)
7892          ("iterate" ,sbcl-iterate)
7893          ("metabang-bind" ,sbcl-metabang-bind)
7894          ("named-readtables" ,sbcl-named-readtables)
7895          ("split-sequence" ,sbcl-split-sequence)))
7896       (native-inputs
7897        `(("lisp-unit" ,sbcl-lisp-unit)))
7898       (synopsis "Scientific and engineering computation in Common Lisp")
7899       (description
7900        "Antik provides a foundation for scientific and engineering
7901 computation in Common Lisp.  It is designed not only to facilitate
7902 numerical computations, but to permit the use of numerical computation
7903 libraries and the interchange of data and procedures, whether
7904 foreign (non-Lisp) or Lisp libraries.  It is named after the
7905 Antikythera mechanism, one of the oldest examples of a scientific
7906 computer known.")
7907       (home-page "https://common-lisp.net/project/antik/")
7908       (license license:gpl3))))
7909
7910 (define-public cl-antik-base
7911   (sbcl-package->cl-source-package sbcl-antik-base))
7912
7913 (define-public ecl-antik-base
7914   (sbcl-package->ecl-package sbcl-antik-base))
7915
7916 (define-public sbcl-foreign-array
7917   (package
7918     (inherit sbcl-antik-base)
7919     (name "sbcl-foreign-array")
7920     (arguments
7921      (substitute-keyword-arguments (package-arguments sbcl-antik-base)
7922        ((#:asd-file _ "") "foreign-array.asd")
7923        ((#:asd-system-name _ #f) "foreign-array")))
7924     (inputs
7925      `(("antik-base" ,sbcl-antik-base)
7926        ("cffi" ,sbcl-cffi)
7927        ("trivial-garbage" ,sbcl-trivial-garbage)
7928        ("static-vectors" ,sbcl-static-vectors)))
7929     (synopsis "Common Lisp library providing access to foreign arrays")))
7930
7931 (define-public cl-foreign-array
7932   (sbcl-package->cl-source-package sbcl-foreign-array))
7933
7934 (define-public ecl-foreign-array
7935   (sbcl-package->ecl-package sbcl-foreign-array))
7936
7937 (define-public sbcl-physical-dimension
7938   (package
7939     (inherit sbcl-antik-base)
7940     (name "sbcl-physical-dimension")
7941     (inputs
7942      `(("fare-utils" ,sbcl-fare-utils)
7943        ("foreign-array" ,sbcl-foreign-array)
7944        ("trivial-utf-8" ,sbcl-trivial-utf-8)))
7945     (arguments
7946      (substitute-keyword-arguments (package-arguments sbcl-antik-base)
7947        ((#:asd-file _ "") "physical-dimension.asd")
7948        ((#:asd-system-name _ #f) "physical-dimension")))
7949     (synopsis
7950      "Common Lisp library providing computations with physical units")))
7951
7952 (define-public cl-physical-dimension
7953   (sbcl-package->cl-source-package sbcl-physical-dimension))
7954
7955 (define-public sbcl-science-data
7956   (package
7957     (inherit sbcl-antik-base)
7958     (name "sbcl-science-data")
7959     (inputs
7960      `(("physical-dimension" ,sbcl-physical-dimension)
7961        ("drakma" ,sbcl-drakma)))
7962     (arguments
7963      (substitute-keyword-arguments (package-arguments sbcl-antik-base)
7964        ((#:asd-file _ "") "science-data.asd")
7965        ((#:asd-system-name _ #f) "science-data")))
7966     (synopsis
7967      "Common Lisp library for scientific and engineering numerical data")))
7968
7969 (define-public cl-science-data
7970   (sbcl-package->cl-source-package sbcl-science-data))
7971
7972 (define-public sbcl-gsll
7973   (let ((commit "1a8ada22f9cf5ed7372d352b2317f4ccdb6ab308")
7974         (revision "1"))
7975     (package
7976       (name "sbcl-gsll")
7977       (version (git-version "0.0.0" revision commit))
7978       (source
7979        (origin
7980          (method git-fetch)
7981          (uri (git-reference
7982                (url "https://gitlab.common-lisp.net/antik/gsll.git")
7983                (commit commit)))
7984          (file-name (git-file-name name version))
7985          (sha256
7986           (base32
7987            "0z5nypfk26hxihb08p085644afawicrgb4xvadh3lmrn46qbjfn4"))))
7988       (build-system asdf-build-system/sbcl)
7989       (native-inputs
7990        `(("lisp-unit" ,sbcl-lisp-unit)))
7991       (inputs
7992        `(("alexandria" ,sbcl-alexandria)
7993          ("cffi-grovel" ,sbcl-cffi-grovel)
7994          ("cffi-libffi" ,sbcl-cffi-libffi)
7995          ("foreign-array" ,sbcl-foreign-array)
7996          ("gsl" ,gsl)
7997          ("metabang-bind" ,sbcl-metabang-bind)
7998          ("trivial-features" ,sbcl-trivial-features)
7999          ("trivial-garbage" ,sbcl-trivial-garbage)))
8000       (arguments
8001        `(#:tests? #f
8002          #:phases
8003          (modify-phases %standard-phases
8004            (add-after 'unpack 'fix-cffi-paths
8005              (lambda* (#:key inputs #:allow-other-keys)
8006                (substitute* "gsll.asd"
8007                  ((":depends-on \\(#:foreign-array")
8008                   ":depends-on (#:foreign-array #:cffi-libffi"))
8009                (substitute* "init/init.lisp"
8010                  (("libgslcblas.so" all)
8011                   (string-append
8012                    (assoc-ref inputs "gsl") "/lib/" all)))
8013                (substitute* "init/init.lisp"
8014                  (("libgsl.so" all)
8015                   (string-append
8016                    (assoc-ref inputs "gsl") "/lib/" all))))))))
8017       (synopsis "GNU Scientific Library for Lisp")
8018       (description
8019        "The GNU Scientific Library for Lisp (GSLL) allows the use of the
8020 GNU Scientific Library (GSL) from Common Lisp.  This library provides a
8021 full range of common mathematical operations useful to scientific and
8022 engineering applications.  The design of the GSLL interface is such
8023 that access to most of the GSL library is possible in a Lisp-natural
8024 way; the intent is that the user not be hampered by the restrictions
8025 of the C language in which GSL has been written.  GSLL thus provides
8026 interactive use of GSL for getting quick answers, even for someone not
8027 intending to program in Lisp.")
8028       (home-page "https://common-lisp.net/project/gsll/")
8029       (license license:gpl3))))
8030
8031 (define-public cl-gsll
8032   (sbcl-package->cl-source-package sbcl-gsll))
8033
8034 (define-public sbcl-antik
8035   (package
8036     (inherit sbcl-antik-base)
8037     (name "sbcl-antik")
8038     (inputs
8039      `(("gsll" ,sbcl-gsll)
8040        ("physical-dimension" ,sbcl-physical-dimension)))
8041     (arguments
8042      (substitute-keyword-arguments (package-arguments sbcl-antik-base)
8043        ((#:asd-file _ "") "antik.asd")
8044        ((#:asd-system-name _ #f) "antik")))))
8045
8046 (define-public cl-antik
8047   (sbcl-package->cl-source-package sbcl-antik))
8048
8049 (define-public sbcl-cl-interpol
8050   (let ((commit "1fd288d861db85bc4677cff3cdd6af75fda1afb4")
8051         (revision "1"))
8052     (package
8053       (name "sbcl-cl-interpol")
8054       (version (git-version "0.2.6" revision commit))
8055       (source
8056        (origin
8057          (method git-fetch)
8058          (uri (git-reference
8059                (url "https://github.com/edicl/cl-interpol.git")
8060                (commit commit)))
8061          (file-name (git-file-name name version))
8062          (sha256
8063           (base32
8064            "1hnikak52hmcq1r5f616m6qq1108qnkw80pja950nv1fq5p0ppjn"))))
8065       (build-system asdf-build-system/sbcl)
8066       (inputs
8067        `(("cl-unicode" ,sbcl-cl-unicode)
8068          ("named-readtables" ,sbcl-named-readtables)))
8069       (native-inputs
8070        `(("flexi-streams" ,sbcl-flexi-streams)))
8071       (synopsis "String interpolation for Common Lisp")
8072       (description
8073        "CL-INTERPOL is a library for Common Lisp which modifies the
8074 reader so that you can have interpolation within strings similar to
8075 Perl or Unix Shell scripts.  It also provides various ways to insert
8076 arbitrary characters into literal strings even if your editor/IDE
8077 doesn't support them.")
8078       (home-page "https://edicl.github.io/cl-interpol/")
8079       (license license:bsd-3))))
8080
8081 (define-public cl-interpol
8082   (sbcl-package->cl-source-package sbcl-cl-interpol))
8083
8084 (define-public ecl-cl-interpol
8085   (sbcl-package->ecl-package sbcl-cl-interpol))
8086
8087 (define sbcl-symbol-munger-boot0
8088   ;; There is a cyclical dependency between symbol-munger and lisp-unit2.
8089   ;; See https://github.com/AccelerationNet/symbol-munger/issues/4
8090   (let ((commit "cc2bb4b7acd454d756484aec81ba487648385fc3")
8091         (revision "1"))
8092     (package
8093       (name "sbcl-symbol-munger-boot0")
8094       (version (git-version "0.0.1" revision commit))
8095       (source
8096        (origin
8097          (method git-fetch)
8098          (uri (git-reference
8099                (url "https://github.com/AccelerationNet/symbol-munger.git")
8100                (commit commit)))
8101          (file-name (git-file-name name version))
8102          (sha256
8103           (base32
8104            "0diav5ricqsybqvbp4bkxyj3bn3v9n7xb2pqqc4vg1algsw2pyjl"))))
8105       (build-system asdf-build-system/sbcl)
8106       (arguments
8107        `(#:asd-file "symbol-munger.asd"
8108          #:asd-system-name "symbol-munger"))
8109       (inputs
8110        `(("iterate" ,sbcl-iterate)
8111          ("alexandria" ,sbcl-alexandria)))
8112       (native-inputs
8113        `(("lisp-unit" ,sbcl-lisp-unit)))
8114       (synopsis
8115        "Capitalization and spacing conversion functions for Common Lisp")
8116       (description
8117        "This is a Common Lisp library to change the capitalization and spacing
8118 of a string or a symbol.  It can convert to and from Lisp, english, underscore
8119 and camel-case rules.")
8120       (home-page "https://github.com/AccelerationNet/symbol-munger")
8121       ;; The package declares a BSD license, but all of the license
8122       ;; text is MIT.
8123       ;; See https://github.com/AccelerationNet/symbol-munger/issues/5
8124       (license license:expat))))
8125
8126 (define sbcl-lisp-unit2-boot0
8127   ;; There is a cyclical dependency between symbol-munger and lisp-unit2.
8128   ;; See https://github.com/AccelerationNet/symbol-munger/issues/4
8129   (let ((commit "fb9721524d1e4e73abb223ee036d74ce14a5505c")
8130         (revision "1"))
8131     (package
8132       (name "sbcl-lisp-unit2-boot0")
8133       (version (git-version "0.2.0" revision commit))
8134       (source
8135        (origin
8136          (method git-fetch)
8137          (uri (git-reference
8138                (url "https://github.com/AccelerationNet/lisp-unit2.git")
8139                (commit commit)))
8140          (file-name (git-file-name name version))
8141          (sha256
8142           (base32
8143            "1rsqy8y0jqll6xn9a593848f5wvd5ribv4csry1ly0hmdhfnqzlp"))))
8144       (build-system asdf-build-system/sbcl)
8145       (arguments
8146        `(#:asd-file "lisp-unit2.asd"
8147          #:asd-system-name "lisp-unit2"))
8148       (inputs
8149        `(("alexandria" ,sbcl-alexandria)
8150          ("cl-interpol" ,sbcl-cl-interpol)
8151          ("iterate" ,sbcl-iterate)
8152          ("symbol-munger-boot0" ,sbcl-symbol-munger-boot0)))
8153       (synopsis "Test Framework for Common Lisp")
8154       (description
8155        "LISP-UNIT2 is a Common Lisp library that supports unit testing in the
8156 style of JUnit for Java.  It is a new version of the lisp-unit library written
8157 by Chris Riesbeck.")
8158       (home-page "https://github.com/AccelerationNet/lisp-unit2")
8159       (license license:expat))))
8160
8161 (define-public sbcl-symbol-munger
8162   (let ((commit "97598d4c3c53fd5da72ab78908fbd5d8c7a13416")
8163         (revision "1"))
8164     (package
8165       (name "sbcl-symbol-munger")
8166       (version (git-version "0.0.1" revision commit))
8167       (source
8168        (origin
8169          (method git-fetch)
8170          (uri (git-reference
8171                (url "https://github.com/AccelerationNet/symbol-munger.git")
8172                (commit commit)))
8173          (file-name (git-file-name name version))
8174          (sha256
8175           (base32
8176            "0y8jywjy0ldyhp7bxf16fdvdd2qgqnd7nlhlqfpfnzxcqk4xy1km"))))
8177       (build-system asdf-build-system/sbcl)
8178       (inputs
8179        `(("alexandria" ,sbcl-alexandria)
8180          ("iterate" ,sbcl-iterate)))
8181       (native-inputs
8182        `(("lisp-unit2-boot0" ,sbcl-lisp-unit2-boot0)))
8183       (synopsis
8184        "Capitalization and spacing conversion functions for Common Lisp")
8185       (description
8186        "This is a Common Lisp library to change the capitalization and spacing
8187 of a string or a symbol.  It can convert to and from Lisp, english, underscore
8188 and camel-case rules.")
8189       (home-page "https://github.com/AccelerationNet/symbol-munger")
8190       ;; The package declares a BSD license, but all of the license
8191       ;; text is MIT.
8192       ;; See https://github.com/AccelerationNet/symbol-munger/issues/5
8193       (license license:expat))))
8194
8195 (define-public cl-symbol-munger
8196   (sbcl-package->cl-source-package sbcl-symbol-munger))
8197
8198 (define-public ecl-symbol-munger
8199   (sbcl-package->ecl-package sbcl-symbol-munger))
8200
8201 (define-public sbcl-lisp-unit2
8202   (package
8203     (inherit sbcl-lisp-unit2-boot0)
8204     (name "sbcl-lisp-unit2")
8205     (inputs
8206      `(("alexandria" ,sbcl-alexandria)
8207        ("cl-interpol" ,sbcl-cl-interpol)
8208        ("iterate" ,sbcl-iterate)
8209        ("symbol-munger" ,sbcl-symbol-munger)))))
8210
8211 (define-public cl-lisp-unit2
8212   (sbcl-package->cl-source-package sbcl-lisp-unit2))
8213
8214 (define-public ecl-lisp-unit2
8215   (sbcl-package->ecl-package sbcl-lisp-unit2))
8216
8217 (define-public sbcl-cl-csv
8218   (let ((commit "3eba29c8364b033fbe0d189c2500559278b6a362")
8219         (revision "1"))
8220     (package
8221       (name "sbcl-cl-csv")
8222       (version (git-version "1.0.6" revision commit))
8223       (source
8224        (origin
8225          (method git-fetch)
8226          (uri (git-reference
8227                (url "https://github.com/AccelerationNet/cl-csv.git")
8228                (commit commit)))
8229          (file-name (git-file-name name version))
8230          (sha256
8231           (base32
8232            "07h4ni89jzx93clx453hlnnb5g53hhlcmz5hghqv6ysam48lc8g6"))))
8233       (build-system asdf-build-system/sbcl)
8234       (arguments
8235        ;; See: https://github.com/AccelerationNet/cl-csv/pull/34
8236        `(#:tests? #f))
8237       (inputs
8238        `(("alexandria" ,sbcl-alexandria)
8239          ("cl-interpol" ,sbcl-cl-interpol)
8240          ("iterate" ,sbcl-iterate)))
8241       (native-inputs
8242        `(("lisp-unit2" ,sbcl-lisp-unit2)))
8243       (synopsis "Common lisp library for comma-separated values")
8244       (description
8245        "This is a Common Lisp library providing functions to read/write CSV
8246 from/to strings, streams and files.")
8247       (home-page "https://github.com/AccelerationNet/cl-csv")
8248       (license license:bsd-3))))
8249
8250 (define-public cl-csv
8251   (sbcl-package->cl-source-package sbcl-cl-csv))
8252
8253 (define-public ecl-cl-csv
8254   (sbcl-package->ecl-package sbcl-cl-csv))
8255
8256 (define-public sbcl-external-program
8257   (let ((commit "5888b8f1fd3953feeeacecbba4384ddda584a749")
8258         (revision "1"))
8259     (package
8260       (name "sbcl-external-program")
8261       (version (git-version "0.0.6" revision commit))
8262       (source
8263        (origin
8264          (method git-fetch)
8265          (uri (git-reference
8266                (url "https://github.com/sellout/external-program.git")
8267                (commit commit)))
8268          (file-name (git-file-name name version))
8269          (sha256
8270           (base32
8271            "0vww1x3yilb3bjwg6k184vaj4vxyxw4vralhnlm6lk4xac67kc9z"))))
8272       (build-system asdf-build-system/sbcl)
8273       (inputs
8274        `(("trivial-features" ,sbcl-trivial-features)))
8275       (native-inputs
8276        `(("fiveam" ,sbcl-fiveam)))
8277       (synopsis "Common Lisp library for running external programs")
8278       (description
8279        "EXTERNAL-PROGRAM enables running programs outside the Lisp
8280 process.  It is an attempt to make the RUN-PROGRAM functionality in
8281 implementations like SBCL and CCL as portable as possible without
8282 sacrificing much in the way of power.")
8283       (home-page "https://github.com/sellout/external-program")
8284       (license license:llgpl))))
8285
8286 (define-public cl-external-program
8287   (sbcl-package->cl-source-package sbcl-external-program))
8288
8289 (define-public ecl-external-program
8290   (sbcl-package->ecl-package sbcl-external-program))
8291
8292 (define sbcl-cl-ana-boot0
8293   (let ((commit "fa7cee4c50aa1c859652813049ba0da7c18a0df9")
8294         (revision "1"))
8295     (package
8296      (name "sbcl-cl-ana-boot0")
8297      (version (git-version "0.0.0" revision commit))
8298      (source
8299       (origin
8300        (method git-fetch)
8301        (uri (git-reference
8302              (url "https://github.com/ghollisjr/cl-ana.git")
8303              (commit commit)))
8304        (file-name (git-file-name name version))
8305        (sha256
8306         (base32
8307          "0mr47l57m276dbpap7irr4fcnk5fgknhf6mgv4043s8h73amk5qh"))))
8308      (build-system asdf-build-system/sbcl)
8309      (synopsis "Common Lisp data analysis library")
8310      (description
8311       "CL-ANA is a data analysis library in Common Lisp providing tabular and
8312 binned data analysis along with nonlinear least squares fitting and
8313 visualization.")
8314      (home-page "https://github.com/ghollisjr/cl-ana")
8315      (license license:gpl3))))
8316
8317 (define-public sbcl-cl-ana.pathname-utils
8318   (package
8319     (inherit sbcl-cl-ana-boot0)
8320     (name "sbcl-cl-ana.pathname-utils")
8321     (arguments
8322      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8323        ((#:asd-file _ "") "pathname-utils/cl-ana.pathname-utils.asd")
8324        ((#:asd-system-name _ #f) "cl-ana.pathname-utils")))))
8325
8326 (define-public cl-ana.pathname-utils
8327   (sbcl-package->cl-source-package sbcl-cl-ana.pathname-utils))
8328
8329 (define-public ecl-cl-ana.pathname-utils
8330   (sbcl-package->ecl-package sbcl-cl-ana.pathname-utils))
8331
8332 (define-public sbcl-cl-ana.package-utils
8333   (package
8334     (inherit sbcl-cl-ana-boot0)
8335     (name "sbcl-cl-ana.package-utils")
8336     (inputs
8337      `(("alexandria" ,sbcl-alexandria)))
8338     (arguments
8339      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8340        ((#:asd-file _ "") "package-utils/cl-ana.package-utils.asd")
8341        ((#:asd-system-name _ #f) "cl-ana.package-utils")))))
8342
8343 (define-public cl-ana.package-utils
8344   (sbcl-package->cl-source-package sbcl-cl-ana.package-utils))
8345
8346 (define-public ecl-cl-ana.package-utils
8347   (sbcl-package->ecl-package sbcl-cl-ana.package-utils))
8348
8349 (define-public sbcl-cl-ana.string-utils
8350   (package
8351     (inherit sbcl-cl-ana-boot0)
8352     (name "sbcl-cl-ana.string-utils")
8353     (inputs
8354      `(("split-sequence" ,sbcl-split-sequence)))
8355     (arguments
8356      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8357        ((#:asd-file _ "") "string-utils/cl-ana.string-utils.asd")
8358        ((#:asd-system-name _ #f) "cl-ana.string-utils")))))
8359
8360 (define-public cl-ana.string-utils
8361   (sbcl-package->cl-source-package sbcl-cl-ana.string-utils))
8362
8363 (define-public ecl-cl-ana.string-utils
8364   (sbcl-package->ecl-package sbcl-cl-ana.string-utils))
8365
8366 (define-public sbcl-cl-ana.functional-utils
8367   (package
8368     (inherit sbcl-cl-ana-boot0)
8369     (name "sbcl-cl-ana.functional-utils")
8370     (arguments
8371      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8372        ((#:asd-file _ "") "functional-utils/cl-ana.functional-utils.asd")
8373        ((#:asd-system-name _ #f) "cl-ana.functional-utils")))))
8374
8375 (define-public cl-ana.functional-utils
8376   (sbcl-package->cl-source-package sbcl-cl-ana.functional-utils))
8377
8378 (define-public ecl-cl-ana.functional-utils
8379   (sbcl-package->ecl-package sbcl-cl-ana.functional-utils))
8380
8381 (define-public sbcl-cl-ana.list-utils
8382   (package
8383     (inherit sbcl-cl-ana-boot0)
8384     (name "sbcl-cl-ana.list-utils")
8385     (inputs
8386      `(("alexandria" ,sbcl-alexandria)
8387        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
8388        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)))
8389     (arguments
8390      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8391        ((#:asd-file _ "") "list-utils/cl-ana.list-utils.asd")
8392        ((#:asd-system-name _ #f) "cl-ana.list-utils")))))
8393
8394 (define-public cl-ana.list-utils
8395   (sbcl-package->cl-source-package sbcl-cl-ana.list-utils))
8396
8397 (define-public ecl-cl-ana.list-utils
8398   (sbcl-package->ecl-package sbcl-cl-ana.list-utils))
8399
8400 (define-public sbcl-cl-ana.generic-math
8401   (package
8402     (inherit sbcl-cl-ana-boot0)
8403     (name "sbcl-cl-ana.generic-math")
8404     (inputs
8405      `(("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8406        ("cl-ana.package-utils" ,sbcl-cl-ana.package-utils)))
8407     (arguments
8408      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8409        ((#:asd-file _ "") "generic-math/cl-ana.generic-math.asd")
8410        ((#:asd-system-name _ #f) "cl-ana.generic-math")))))
8411
8412 (define-public cl-ana.generic-math
8413   (sbcl-package->cl-source-package sbcl-cl-ana.generic-math))
8414
8415 (define-public ecl-cl-ana.generic-math
8416   (sbcl-package->ecl-package sbcl-cl-ana.generic-math))
8417
8418 (define-public sbcl-cl-ana.math-functions
8419   (package
8420     (inherit sbcl-cl-ana-boot0)
8421     (name "sbcl-cl-ana.math-functions")
8422     (inputs
8423      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8424        ("gsll" ,sbcl-gsll)))
8425     (arguments
8426      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8427        ((#:asd-file _ "") "math-functions/cl-ana.math-functions.asd")
8428        ((#:asd-system-name _ #f) "cl-ana.math-functions")))))
8429
8430 (define-public cl-ana.math-functions
8431   (sbcl-package->cl-source-package sbcl-cl-ana.math-functions))
8432
8433 (define-public sbcl-cl-ana.calculus
8434   (package
8435     (inherit sbcl-cl-ana-boot0)
8436     (name "sbcl-cl-ana.calculus")
8437     (inputs
8438      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)))
8439     (arguments
8440      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8441        ((#:asd-file _ "") "calculus/cl-ana.calculus.asd")
8442        ((#:asd-system-name _ #f) "cl-ana.calculus")))))
8443
8444 (define-public cl-ana.calculus
8445   (sbcl-package->cl-source-package sbcl-cl-ana.calculus))
8446
8447 (define-public ecl-cl-ana.calculus
8448   (sbcl-package->ecl-package sbcl-cl-ana.calculus))
8449
8450 (define-public sbcl-cl-ana.symbol-utils
8451   (package
8452     (inherit sbcl-cl-ana-boot0)
8453     (name "sbcl-cl-ana.symbol-utils")
8454     (inputs
8455      `(("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)))
8456     (arguments
8457      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8458        ((#:asd-file _ "") "symbol-utils/cl-ana.symbol-utils.asd")
8459        ((#:asd-system-name _ #f) "cl-ana.symbol-utils")))))
8460
8461 (define-public cl-ana.symbol-utils
8462   (sbcl-package->cl-source-package sbcl-cl-ana.symbol-utils))
8463
8464 (define-public ecl-cl-ana.symbol-utils
8465   (sbcl-package->ecl-package sbcl-cl-ana.symbol-utils))
8466
8467 (define-public sbcl-cl-ana.macro-utils
8468   (package
8469     (inherit sbcl-cl-ana-boot0)
8470     (name "sbcl-cl-ana.macro-utils")
8471     (inputs
8472      `(("alexandria" ,sbcl-alexandria)
8473        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8474        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8475        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8476        ("split-sequence" ,sbcl-split-sequence)))
8477     (arguments
8478      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8479        ((#:asd-file _ "") "macro-utils/cl-ana.macro-utils.asd")
8480        ((#:asd-system-name _ #f) "cl-ana.macro-utils")))))
8481
8482 (define-public cl-ana.macro-utils
8483   (sbcl-package->cl-source-package sbcl-cl-ana.macro-utils))
8484
8485 (define-public ecl-cl-ana.macro-utils
8486   (sbcl-package->ecl-package sbcl-cl-ana.macro-utils))
8487
8488 (define-public sbcl-cl-ana.binary-tree
8489   (package
8490     (inherit sbcl-cl-ana-boot0)
8491     (name "sbcl-cl-ana.binary-tree")
8492     (inputs
8493      `(("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
8494        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8495        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)))
8496     (arguments
8497      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8498        ((#:asd-file _ "") "binary-tree/cl-ana.binary-tree.asd")
8499        ((#:asd-system-name _ #f) "cl-ana.binary-tree")))))
8500
8501 (define-public cl-ana.binary-tree
8502   (sbcl-package->cl-source-package sbcl-cl-ana.binary-tree))
8503
8504 (define-public ecl-cl-ana.binary-tree
8505   (sbcl-package->ecl-package sbcl-cl-ana.binary-tree))
8506
8507 (define-public sbcl-cl-ana.tensor
8508   (package
8509     (inherit sbcl-cl-ana-boot0)
8510     (name "sbcl-cl-ana.tensor")
8511     (inputs
8512      `(("alexandria" ,sbcl-alexandria)
8513        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8514        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8515        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8516        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)))
8517     (arguments
8518      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8519        ((#:asd-file _ "") "tensor/cl-ana.tensor.asd")
8520        ((#:asd-system-name _ #f) "cl-ana.tensor")))))
8521
8522 (define-public cl-ana.tensor
8523   (sbcl-package->cl-source-package sbcl-cl-ana.tensor))
8524
8525 (define-public ecl-cl-ana.tensor
8526   (sbcl-package->ecl-package sbcl-cl-ana.tensor))
8527
8528 (define-public sbcl-cl-ana.error-propogation
8529   (package
8530     (inherit sbcl-cl-ana-boot0)
8531     (name "sbcl-cl-ana.error-propogation")
8532     (inputs
8533      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8534        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)))
8535     (arguments
8536      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8537        ((#:asd-file _ "") "error-propogation/cl-ana.error-propogation.asd")
8538        ((#:asd-system-name _ #f) "cl-ana.error-propogation")))))
8539
8540 (define-public cl-ana.error-propogation
8541   (sbcl-package->cl-source-package sbcl-cl-ana.error-propogation))
8542
8543 (define-public sbcl-cl-ana.quantity
8544   (package
8545     (inherit sbcl-cl-ana-boot0)
8546     (name "sbcl-cl-ana.quantity")
8547     (inputs
8548      `(("alexandria" ,sbcl-alexandria)
8549        ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
8550        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8551        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8552        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8553        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)))
8554     (arguments
8555      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8556        ((#:asd-file _ "") "quantity/cl-ana.quantity.asd")
8557        ((#:asd-system-name _ #f) "cl-ana.quantity")))))
8558
8559 (define-public cl-ana.quantity
8560   (sbcl-package->cl-source-package sbcl-cl-ana.quantity))
8561
8562 (define-public sbcl-cl-ana.table
8563   (package
8564     (inherit sbcl-cl-ana-boot0)
8565     (name "sbcl-cl-ana.table")
8566     (inputs
8567      `(("alexandria" ,sbcl-alexandria)
8568        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
8569        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8570        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8571        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8572        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)))
8573     (arguments
8574      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8575        ((#:asd-file _ "") "table/cl-ana.table.asd")
8576        ((#:asd-system-name _ #f) "cl-ana.table")))))
8577
8578 (define-public cl-ana.table
8579   (sbcl-package->cl-source-package sbcl-cl-ana.table))
8580
8581 (define-public ecl-cl-ana.table
8582   (sbcl-package->ecl-package sbcl-cl-ana.table))
8583
8584 (define-public sbcl-cl-ana.table-utils
8585   (package
8586     (inherit sbcl-cl-ana-boot0)
8587     (name "sbcl-cl-ana.table-utils")
8588     (inputs
8589      `(("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8590        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8591        ("cl-ana.table" ,sbcl-cl-ana.table)))
8592     (arguments
8593      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8594        ((#:asd-file _ "") "table-utils/cl-ana.table-utils.asd")
8595        ((#:asd-system-name _ #f) "cl-ana.table-utils")))))
8596
8597 (define-public cl-ana.table-utils
8598   (sbcl-package->cl-source-package sbcl-cl-ana.table-utils))
8599
8600 (define-public ecl-cl-ana.table-utils
8601   (sbcl-package->ecl-package sbcl-cl-ana.table-utils))
8602
8603 (define-public sbcl-cl-ana.hdf-cffi
8604   (package
8605     (inherit sbcl-cl-ana-boot0)
8606     (name "sbcl-cl-ana.hdf-cffi")
8607     (inputs
8608      `(("cffi" ,sbcl-cffi)
8609        ("hdf5" ,hdf5-parallel-openmpi)))
8610     (arguments
8611      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8612        ((#:asd-file _ "") "hdf-cffi/cl-ana.hdf-cffi.asd")
8613        ((#:asd-system-name _ #f) "cl-ana.hdf-cffi")
8614        ((#:phases phases '%standard-phases)
8615         `(modify-phases ,phases
8616            (add-after 'unpack 'fix-paths
8617              (lambda* (#:key inputs #:allow-other-keys)
8618                (substitute* "hdf-cffi/hdf-cffi.lisp"
8619                  (("/usr/lib/i386-linux-gnu/hdf5/serial/libhdf5.so")
8620                   (string-append
8621                    (assoc-ref inputs "hdf5")
8622                    "/lib/libhdf5.so")))))))))))
8623
8624 (define-public cl-ana.hdf-cffi
8625   (sbcl-package->cl-source-package sbcl-cl-ana.hdf-cffi))
8626
8627 (define-public ecl-cl-ana.hdf-cffi
8628   (sbcl-package->ecl-package sbcl-cl-ana.hdf-cffi))
8629
8630 (define-public sbcl-cl-ana.int-char
8631   (package
8632     (inherit sbcl-cl-ana-boot0)
8633     (name "sbcl-cl-ana.int-char")
8634     (arguments
8635      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8636        ((#:asd-file _ "") "int-char/cl-ana.int-char.asd")
8637        ((#:asd-system-name _ #f) "cl-ana.int-char")))))
8638
8639 (define-public cl-ana.int-char
8640   (sbcl-package->cl-source-package sbcl-cl-ana.int-char))
8641
8642 (define-public ecl-cl-ana.int-char
8643   (sbcl-package->ecl-package sbcl-cl-ana.int-char))
8644
8645 (define-public sbcl-cl-ana.memoization
8646   (package
8647     (inherit sbcl-cl-ana-boot0)
8648     (name "sbcl-cl-ana.memoization")
8649     (inputs
8650      `(("alexandria" ,sbcl-alexandria)))
8651     (arguments
8652      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8653        ((#:asd-file _ "") "memoization/cl-ana.memoization.asd")
8654        ((#:asd-system-name _ #f) "cl-ana.memoization")))))
8655
8656 (define-public cl-ana.memoization
8657   (sbcl-package->cl-source-package sbcl-cl-ana.memoization))
8658
8659 (define-public ecl-cl-ana.memoization
8660   (sbcl-package->ecl-package sbcl-cl-ana.memoization))
8661
8662 (define-public sbcl-cl-ana.typespec
8663   (package
8664     (inherit sbcl-cl-ana-boot0)
8665     (name "sbcl-cl-ana.typespec")
8666     (inputs
8667      `(("alexandria" ,sbcl-alexandria)
8668        ("cffi" ,sbcl-cffi)
8669        ("cl-ana.int-char" ,sbcl-cl-ana.int-char)
8670        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8671        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
8672        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8673        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8674        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)))
8675     (arguments
8676      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8677        ((#:asd-file _ "") "typespec/cl-ana.typespec.asd")
8678        ((#:asd-system-name _ #f) "cl-ana.typespec")))))
8679
8680 (define-public cl-ana.typespec
8681   (sbcl-package->cl-source-package sbcl-cl-ana.typespec))
8682
8683 (define-public ecl-cl-ana.typespec
8684   (sbcl-package->ecl-package sbcl-cl-ana.typespec))
8685
8686 (define-public sbcl-cl-ana.hdf-typespec
8687   (package
8688     (inherit sbcl-cl-ana-boot0)
8689     (name "sbcl-cl-ana.hdf-typespec")
8690     (inputs
8691      `(("alexandria" ,sbcl-alexandria)
8692        ("cffi" ,sbcl-cffi)
8693        ("cl-ana.hdf-cffi" ,sbcl-cl-ana.hdf-cffi)
8694        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8695        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
8696        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8697        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8698        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
8699     (arguments
8700      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8701        ((#:asd-file _ "") "hdf-typespec/cl-ana.hdf-typespec.asd")
8702        ((#:asd-system-name _ #f) "cl-ana.hdf-typespec")))))
8703
8704 (define-public cl-ana.hdf-typespec
8705   (sbcl-package->cl-source-package sbcl-cl-ana.hdf-typespec))
8706
8707 (define-public ecl-cl-ana.hdf-typespec
8708   (sbcl-package->ecl-package sbcl-cl-ana.hdf-typespec))
8709
8710 (define-public sbcl-cl-ana.hdf-utils
8711   (package
8712     (inherit sbcl-cl-ana-boot0)
8713     (name "sbcl-cl-ana.hdf-utils")
8714     (inputs
8715      `(("alexandria" ,sbcl-alexandria)
8716        ("cffi" ,sbcl-cffi)
8717        ("cl-ana.hdf-cffi" ,sbcl-cl-ana.hdf-cffi)
8718        ("cl-ana.hdf-typespec" ,sbcl-cl-ana.hdf-typespec)
8719        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8720        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
8721        ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
8722        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8723        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
8724     (arguments
8725      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8726        ((#:asd-file _ "") "hdf-utils/cl-ana.hdf-utils.asd")
8727        ((#:asd-system-name _ #f) "cl-ana.hdf-utils")))))
8728
8729 (define-public cl-ana.hdf-utils
8730   (sbcl-package->cl-source-package sbcl-cl-ana.hdf-utils))
8731
8732 (define-public ecl-cl-ana.hdf-utils
8733   (sbcl-package->ecl-package sbcl-cl-ana.hdf-utils))
8734
8735 (define-public sbcl-cl-ana.typed-table
8736   (package
8737     (inherit sbcl-cl-ana-boot0)
8738     (name "sbcl-cl-ana.typed-table")
8739     (inputs
8740      `(("alexandria" ,sbcl-alexandria)
8741        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8742        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8743        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8744        ("cl-ana.table" ,sbcl-cl-ana.table)
8745        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
8746     (arguments
8747      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8748        ((#:asd-file _ "") "typed-table/cl-ana.typed-table.asd")
8749        ((#:asd-system-name _ #f) "cl-ana.typed-table")))))
8750
8751 (define-public cl-ana.typed-table
8752   (sbcl-package->cl-source-package sbcl-cl-ana.typed-table))
8753
8754 (define-public ecl-cl-ana.typed-table
8755   (sbcl-package->ecl-package sbcl-cl-ana.typed-table))
8756
8757 (define-public sbcl-cl-ana.hdf-table
8758   (package
8759     (inherit sbcl-cl-ana-boot0)
8760     (name "sbcl-cl-ana.hdf-table")
8761     (inputs
8762      `(("alexandria" ,sbcl-alexandria)
8763        ("cl-ana.binary-tree" ,sbcl-cl-ana.binary-tree)
8764        ("cl-ana.hdf-cffi" ,sbcl-cl-ana.hdf-cffi)
8765        ("cl-ana.hdf-typespec" ,sbcl-cl-ana.hdf-typespec)
8766        ("cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
8767        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8768        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
8769        ("cl-ana.table" ,sbcl-cl-ana.table)
8770        ("cl-ana.typed-table" ,sbcl-cl-ana.typed-table)
8771        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
8772     (arguments
8773      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8774        ((#:asd-file _ "") "hdf-table/cl-ana.hdf-table.asd")
8775        ((#:asd-system-name _ #f) "cl-ana.hdf-table")))))
8776
8777 (define-public cl-ana.hdf-table
8778   (sbcl-package->cl-source-package sbcl-cl-ana.hdf-table))
8779
8780 (define-public ecl-cl-ana.hdf-table
8781   (sbcl-package->ecl-package sbcl-cl-ana.hdf-table))
8782
8783 (define-public sbcl-cl-ana.gsl-cffi
8784   (package
8785     (inherit sbcl-cl-ana-boot0)
8786     (name "sbcl-cl-ana.gsl-cffi")
8787     (inputs
8788      `(("cffi" ,sbcl-cffi)
8789        ("gsl" ,gsl)))
8790     (arguments
8791      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8792        ((#:asd-file _ "") "gsl-cffi/cl-ana.gsl-cffi.asd")
8793        ((#:asd-system-name _ #f) "cl-ana.gsl-cffi")
8794        ((#:phases phases '%standard-phases)
8795         `(modify-phases ,phases
8796            (add-after 'unpack 'fix-paths
8797              (lambda* (#:key inputs #:allow-other-keys)
8798                (substitute* "gsl-cffi/gsl-cffi.lisp"
8799                  (("define-foreign-library gsl-cffi" all)
8800                   (string-append all " (:unix "
8801                                  (assoc-ref inputs "gsl")
8802                                  "/lib/libgsl.so)")))))))))))
8803
8804 (define-public cl-ana.gsl-cffi
8805   (sbcl-package->cl-source-package sbcl-cl-ana.gsl-cffi))
8806
8807 (define-public ecl-cl-ana.gsl-cffi
8808   (sbcl-package->ecl-package sbcl-cl-ana.gsl-cffi))
8809
8810 (define-public sbcl-cl-ana.ntuple-table
8811   (package
8812     (inherit sbcl-cl-ana-boot0)
8813     (name "sbcl-cl-ana.ntuple-table")
8814     (inputs
8815      `(("alexandria" ,sbcl-alexandria)
8816        ("cffi" ,sbcl-cffi)
8817        ("cl-ana.gsl-cffi" ,sbcl-cl-ana.gsl-cffi)
8818        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8819        ("cl-ana.table" ,sbcl-cl-ana.table)
8820        ("cl-ana.typed-table" ,sbcl-cl-ana.typed-table)
8821        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)
8822        ("gsll" ,sbcl-gsll)))
8823     (arguments
8824      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8825        ((#:asd-file _ "") "ntuple-table/cl-ana.ntuple-table.asd")
8826        ((#:asd-system-name _ #f) "cl-ana.ntuple-table")))))
8827
8828 (define-public cl-ana.ntuple-table
8829   (sbcl-package->cl-source-package sbcl-cl-ana.ntuple-table))
8830
8831 (define-public sbcl-cl-ana.csv-table
8832   (package
8833     (inherit sbcl-cl-ana-boot0)
8834     (name "sbcl-cl-ana.csv-table")
8835     (inputs
8836      `(("alexandria" ,sbcl-alexandria)
8837        ("antik" ,sbcl-antik)
8838        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8839        ("cl-ana.table" ,sbcl-cl-ana.table)
8840        ("cl-csv" ,sbcl-cl-csv)
8841        ("iterate" ,sbcl-iterate)))
8842     (arguments
8843      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8844        ((#:asd-file _ "") "csv-table/cl-ana.csv-table.asd")
8845        ((#:asd-system-name _ #f) "cl-ana.csv-table")))))
8846
8847 (define-public cl-ana.csv-table
8848   (sbcl-package->cl-source-package sbcl-cl-ana.csv-table))
8849
8850 (define-public sbcl-cl-ana.reusable-table
8851   (package
8852     (inherit sbcl-cl-ana-boot0)
8853     (name "sbcl-cl-ana.reusable-table")
8854     (inputs
8855      `(("alexandria" ,sbcl-alexandria)
8856        ("cl-ana.table" ,sbcl-cl-ana.table)))
8857     (arguments
8858      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8859        ((#:asd-file _ "") "reusable-table/cl-ana.reusable-table.asd")
8860        ((#:asd-system-name _ #f) "cl-ana.reusable-table")))))
8861
8862 (define-public cl-ana.reusable-table
8863   (sbcl-package->cl-source-package sbcl-cl-ana.reusable-table))
8864
8865 (define-public ecl-cl-ana.reusable-table
8866   (sbcl-package->ecl-package sbcl-cl-ana.reusable-table))
8867
8868 (define-public sbcl-cl-ana.linear-algebra
8869   (package
8870     (inherit sbcl-cl-ana-boot0)
8871     (name "sbcl-cl-ana.linear-algebra")
8872     (inputs
8873      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8874        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8875        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
8876        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
8877        ("gsll" ,sbcl-gsll)))
8878     (arguments
8879      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8880        ((#:asd-file _ "") "linear-algebra/cl-ana.linear-algebra.asd")
8881        ((#:asd-system-name _ #f) "cl-ana.linear-algebra")))))
8882
8883 (define-public cl-ana.linear-algebra
8884   (sbcl-package->cl-source-package sbcl-cl-ana.linear-algebra))
8885
8886 (define-public sbcl-cl-ana.lorentz
8887   (package
8888     (inherit sbcl-cl-ana-boot0)
8889     (name "sbcl-cl-ana.lorentz")
8890     (inputs
8891      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8892        ("cl-ana.linear-algebra" ,sbcl-cl-ana.linear-algebra)
8893        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
8894        ("iterate" ,sbcl-iterate)))
8895     (arguments
8896      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8897        ((#:asd-file _ "") "lorentz/cl-ana.lorentz.asd")
8898        ((#:asd-system-name _ #f) "cl-ana.lorentz")))))
8899
8900 (define-public cl-ana.lorentz
8901   (sbcl-package->cl-source-package sbcl-cl-ana.lorentz))
8902
8903 (define-public sbcl-cl-ana.clos-utils
8904   (package
8905     (inherit sbcl-cl-ana-boot0)
8906     (name "sbcl-cl-ana.clos-utils")
8907     (inputs
8908      `(("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8909        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8910        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
8911        ("closer-mop" ,sbcl-closer-mop)))
8912     (arguments
8913      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8914        ((#:asd-file _ "") "clos-utils/cl-ana.clos-utils.asd")
8915        ((#:asd-system-name _ #f) "cl-ana.clos-utils")))))
8916
8917 (define-public cl-ana.clos-utils
8918   (sbcl-package->cl-source-package sbcl-cl-ana.clos-utils))
8919
8920 (define-public ecl-cl-ana.clos-utils
8921   (sbcl-package->ecl-package sbcl-cl-ana.clos-utils))
8922
8923 (define-public sbcl-cl-ana.hash-table-utils
8924   (package
8925     (inherit sbcl-cl-ana-boot0)
8926     (name "sbcl-cl-ana.hash-table-utils")
8927     (arguments
8928      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8929        ((#:asd-file _ "") "hash-table-utils/cl-ana.hash-table-utils.asd")
8930        ((#:asd-system-name _ #f) "cl-ana.hash-table-utils")))))
8931
8932 (define-public cl-ana.hash-table-utils
8933   (sbcl-package->cl-source-package sbcl-cl-ana.hash-table-utils))
8934
8935 (define-public ecl-cl-ana.hash-table-utils
8936   (sbcl-package->ecl-package sbcl-cl-ana.hash-table-utils))
8937
8938 (define-public sbcl-cl-ana.map
8939   (package
8940     (inherit sbcl-cl-ana-boot0)
8941     (name "sbcl-cl-ana.map")
8942     (inputs
8943      `(("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)))
8944     (arguments
8945      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8946        ((#:asd-file _ "") "map/cl-ana.map.asd")
8947        ((#:asd-system-name _ #f) "cl-ana.map")))))
8948
8949 (define-public cl-ana.map
8950   (sbcl-package->cl-source-package sbcl-cl-ana.map))
8951
8952 (define-public ecl-cl-ana.map
8953   (sbcl-package->ecl-package sbcl-cl-ana.map))
8954
8955 (define-public sbcl-cl-ana.fitting
8956   (package
8957     (inherit sbcl-cl-ana-boot0)
8958     (name "sbcl-cl-ana.fitting")
8959     (inputs
8960      `(("alexandria" ,sbcl-alexandria)
8961        ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
8962        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8963        ("cl-ana.map" ,sbcl-cl-ana.map)
8964        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
8965        ("gsll" ,sbcl-gsll)))
8966     (arguments
8967      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8968        ((#:asd-file _ "") "fitting/cl-ana.fitting.asd")
8969        ((#:asd-system-name _ #f) "cl-ana.fitting")))))
8970
8971 (define-public cl-ana.fitting
8972   (sbcl-package->cl-source-package sbcl-cl-ana.fitting))
8973
8974 (define-public sbcl-cl-ana.histogram
8975   (package
8976     (inherit sbcl-cl-ana-boot0)
8977     (name "sbcl-cl-ana.histogram")
8978     (inputs
8979      `(("alexandria" ,sbcl-alexandria)
8980        ("iterate" ,sbcl-iterate)
8981        ("cl-ana.binary-tree" ,sbcl-cl-ana.binary-tree)
8982        ("cl-ana.clos-utils" ,sbcl-cl-ana.clos-utils)
8983        ("cl-ana.fitting" ,sbcl-cl-ana.fitting)
8984        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
8985        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8986        ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
8987        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8988        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8989        ("cl-ana.map" ,sbcl-cl-ana.map)
8990        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)))
8991     (arguments
8992      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8993        ((#:asd-file _ "") "histogram/cl-ana.histogram.asd")
8994        ((#:asd-system-name _ #f) "cl-ana.histogram")))))
8995
8996 (define-public cl-ana.histogram
8997   (sbcl-package->cl-source-package sbcl-cl-ana.histogram))
8998
8999 (define-public sbcl-cl-ana.file-utils
9000   (package
9001     (inherit sbcl-cl-ana-boot0)
9002     (name "sbcl-cl-ana.file-utils")
9003     (inputs
9004      `(("external-program" ,sbcl-external-program)
9005        ("split-sequence" ,sbcl-split-sequence)))
9006     (arguments
9007      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9008        ((#:asd-file _ "") "file-utils/cl-ana.file-utils.asd")
9009        ((#:asd-system-name _ #f) "cl-ana.file-utils")))))
9010
9011 (define-public cl-ana.file-utils
9012   (sbcl-package->cl-source-package sbcl-cl-ana.file-utils))
9013
9014 (define-public ecl-cl-ana.file-utils
9015   (sbcl-package->ecl-package sbcl-cl-ana.file-utils))
9016
9017 (define-public sbcl-cl-ana.statistics
9018   (package
9019     (inherit sbcl-cl-ana-boot0)
9020     (name "sbcl-cl-ana.statistics")
9021     (inputs
9022      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9023        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9024        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9025        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9026        ("cl-ana.map" ,sbcl-cl-ana.map)))
9027     (arguments
9028      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9029        ((#:asd-file _ "") "statistics/cl-ana.statistics.asd")
9030        ((#:asd-system-name _ #f) "cl-ana.statistics")))))
9031
9032 (define-public cl-ana.statistics
9033   (sbcl-package->cl-source-package sbcl-cl-ana.statistics))
9034
9035 (define-public sbcl-cl-ana.gnuplot-interface
9036   (package
9037     (inherit sbcl-cl-ana-boot0)
9038     (name "sbcl-cl-ana.gnuplot-interface")
9039     (inputs
9040      `(("external-program" ,sbcl-external-program)))
9041     (arguments
9042      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9043        ((#:asd-file _ "") "gnuplot-interface/cl-ana.gnuplot-interface.asd")
9044        ((#:asd-system-name _ #f) "cl-ana.gnuplot-interface")))))
9045
9046 (define-public cl-ana.gnuplot-interface
9047   (sbcl-package->cl-source-package sbcl-cl-ana.gnuplot-interface))
9048
9049 (define-public ecl-cl-ana.gnuplot-interface
9050   (sbcl-package->ecl-package sbcl-cl-ana.gnuplot-interface))
9051
9052 (define-public sbcl-cl-ana.plotting
9053   (package
9054     (inherit sbcl-cl-ana-boot0)
9055     (name "sbcl-cl-ana.plotting")
9056     (inputs
9057      `(("alexandria" ,sbcl-alexandria)
9058        ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
9059        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
9060        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9061        ("cl-ana.gnuplot-interface" ,sbcl-cl-ana.gnuplot-interface)
9062        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9063        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9064        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9065        ("cl-ana.map" ,sbcl-cl-ana.map)
9066        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
9067        ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
9068        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
9069        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
9070        ("external-program" ,sbcl-external-program)
9071        ("split-sequence" ,sbcl-split-sequence)))
9072     (arguments
9073      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9074        ((#:asd-file _ "") "plotting/cl-ana.plotting.asd")
9075        ((#:asd-system-name _ #f) "cl-ana.plotting")))))
9076
9077 (define-public cl-ana.plotting
9078   (sbcl-package->cl-source-package sbcl-cl-ana.plotting))
9079
9080 (define-public sbcl-cl-ana.table-viewing
9081   (package
9082     (inherit sbcl-cl-ana-boot0)
9083     (name "sbcl-cl-ana.table-viewing")
9084     (inputs
9085      `(("alexandria" ,sbcl-alexandria)
9086        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9087        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9088        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9089        ("cl-ana.plotting" ,sbcl-cl-ana.plotting)
9090        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
9091        ("cl-ana.table" ,sbcl-cl-ana.table)))
9092     (arguments
9093      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9094        ((#:asd-file _ "") "table-viewing/cl-ana.table-viewing.asd")
9095        ((#:asd-system-name _ #f) "cl-ana.table-viewing")))))
9096
9097 (define-public cl-ana.table-viewing
9098   (sbcl-package->cl-source-package sbcl-cl-ana.table-viewing))
9099
9100 (define-public sbcl-cl-ana.serialization
9101   (package
9102     (inherit sbcl-cl-ana-boot0)
9103     (name "sbcl-cl-ana.serialization")
9104     (inputs
9105      `(("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
9106        ("cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
9107        ("cl-ana.hdf-table" ,sbcl-cl-ana.hdf-table)
9108        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9109        ("cl-ana.int-char" ,sbcl-cl-ana.int-char)
9110        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9111        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
9112     (arguments
9113      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9114        ((#:asd-file _ "") "serialization/cl-ana.serialization.asd")
9115        ((#:asd-system-name _ #f) "cl-ana.serialization")))))
9116
9117 (define-public cl-ana.serialization
9118   (sbcl-package->cl-source-package sbcl-cl-ana.serialization))
9119
9120 (define-public sbcl-cl-ana.makeres
9121   (package
9122     (inherit sbcl-cl-ana-boot0)
9123     (name "sbcl-cl-ana.makeres")
9124     (inputs
9125      `(("alexandria" ,sbcl-alexandria)
9126        ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
9127        ("cl-ana.file-utils" ,sbcl-cl-ana.file-utils)
9128        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
9129        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9130        ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
9131        ("cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
9132        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9133        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9134        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9135        ("cl-ana.map" ,sbcl-cl-ana.map)
9136        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
9137        ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
9138        ("cl-ana.plotting" ,sbcl-cl-ana.plotting)
9139        ("cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
9140        ("cl-ana.serialization" ,sbcl-cl-ana.serialization)
9141        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
9142        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
9143        ("cl-ana.table" ,sbcl-cl-ana.table)
9144        ("external-program" ,sbcl-external-program)))
9145     (native-inputs
9146      `(("cl-fad" ,sbcl-cl-fad)))
9147     (arguments
9148      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9149        ((#:asd-file _ "") "makeres/cl-ana.makeres.asd")
9150        ((#:asd-system-name _ #f) "cl-ana.makeres")))))
9151
9152 (define-public cl-ana.makeres
9153   (sbcl-package->cl-source-package sbcl-cl-ana.makeres))
9154
9155 (define-public sbcl-cl-ana.makeres-macro
9156   (package
9157     (inherit sbcl-cl-ana-boot0)
9158     (name "sbcl-cl-ana.makeres-macro")
9159     (inputs
9160      `(("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9161        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)))
9162     (arguments
9163      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9164        ((#:asd-file _ "") "makeres-macro/cl-ana.makeres-macro.asd")
9165        ((#:asd-system-name _ #f) "cl-ana.makeres-macro")))))
9166
9167 (define-public cl-ana.makeres-macro
9168   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-macro))
9169
9170 (define-public sbcl-cl-ana.makeres-block
9171   (package
9172     (inherit sbcl-cl-ana-boot0)
9173     (name "sbcl-cl-ana.makeres-block")
9174     (inputs
9175      `(("alexandria" ,sbcl-alexandria)
9176        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9177        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9178        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)))
9179     (arguments
9180      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9181        ((#:asd-file _ "") "makeres-block/cl-ana.makeres-block.asd")
9182        ((#:asd-system-name _ #f) "cl-ana.makeres-block")))))
9183
9184 (define-public cl-ana.makeres-block
9185   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-block))
9186
9187 (define-public sbcl-cl-ana.makeres-progress
9188   (package
9189     (inherit sbcl-cl-ana-boot0)
9190     (name "sbcl-cl-ana.makeres-progress")
9191     (inputs
9192      `(("alexandria" ,sbcl-alexandria)
9193        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9194        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)))
9195     (arguments
9196      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9197        ((#:asd-file _ "") "makeres-progress/cl-ana.makeres-progress.asd")
9198        ((#:asd-system-name _ #f) "cl-ana.makeres-progress")))))
9199
9200 (define-public cl-ana.makeres-progress
9201   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-progress))
9202
9203 (define-public sbcl-cl-ana.makeres-table
9204   (package
9205     (inherit sbcl-cl-ana-boot0)
9206     (name "sbcl-cl-ana.makeres-table")
9207     (inputs
9208      `(("cl-ana.csv-table" ,sbcl-cl-ana.csv-table)
9209        ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
9210        ("cl-ana.hdf-table" ,sbcl-cl-ana.hdf-table)
9211        ("cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
9212        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9213        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9214        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)
9215        ("cl-ana.makeres-macro" ,sbcl-cl-ana.makeres-macro)
9216        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
9217        ("cl-ana.ntuple-table" ,sbcl-cl-ana.ntuple-table)
9218        ("cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
9219        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
9220        ("cl-ana.table" ,sbcl-cl-ana.table)))
9221     (native-inputs
9222      `(("cl-fad" ,sbcl-cl-fad)))
9223     (arguments
9224      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9225        ((#:asd-file _ "") "makeres-table/cl-ana.makeres-table.asd")
9226        ((#:asd-system-name _ #f) "cl-ana.makeres-table")))))
9227
9228 (define-public cl-ana.makeres-table
9229   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-table))
9230
9231 (define-public sbcl-cl-ana.makeres-graphviz
9232   (package
9233     (inherit sbcl-cl-ana-boot0)
9234     (name "sbcl-cl-ana.makeres-graphviz")
9235     (inputs
9236      `(("cl-ana.makeres" ,sbcl-cl-ana.makeres)
9237        ("external-program" ,sbcl-external-program)))
9238     (arguments
9239      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9240        ((#:asd-file _ "") "makeres-graphviz/cl-ana.makeres-graphviz.asd")
9241        ((#:asd-system-name _ #f) "cl-ana.makeres-graphviz")))))
9242
9243 (define-public cl-ana.makeres-graphviz
9244   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-graphviz))
9245
9246 (define-public sbcl-cl-ana.makeres-branch
9247   (package
9248     (inherit sbcl-cl-ana-boot0)
9249     (name "sbcl-cl-ana.makeres-branch")
9250     (inputs
9251      `(("alexandria" ,sbcl-alexandria)
9252        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9253        ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
9254        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9255        ("cl-ana.map" ,sbcl-cl-ana.map)
9256        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)))
9257     (arguments
9258      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9259        ((#:asd-file _ "") "makeres-branch/cl-ana.makeres-branch.asd")
9260        ((#:asd-system-name _ #f) "cl-ana.makeres-branch")))))
9261
9262 (define-public cl-ana.makeres-branch
9263   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-branch))
9264
9265 (define-public sbcl-cl-ana.makeres-utils
9266   (package
9267     (inherit sbcl-cl-ana-boot0)
9268     (name "sbcl-cl-ana.makeres-utils")
9269     (inputs
9270      `(("alexandria" ,sbcl-alexandria)
9271        ("cl-ana.file-utils" ,sbcl-cl-ana.file-utils)
9272        ("cl-ana.fitting" ,sbcl-cl-ana.fitting)
9273        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
9274        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9275        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9276        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9277        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9278        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)
9279        ("cl-ana.map" ,sbcl-cl-ana.map)
9280        ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
9281        ("cl-ana.plotting" ,sbcl-cl-ana.plotting)
9282        ("cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
9283        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
9284        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
9285        ("cl-ana.table" ,sbcl-cl-ana.table)))
9286     (native-inputs
9287      `(("cl-fad" ,sbcl-cl-fad)))
9288     (arguments
9289      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9290        ((#:asd-file _ "") "makeres-utils/cl-ana.makeres-utils.asd")
9291        ((#:asd-system-name _ #f) "cl-ana.makeres-utils")))))
9292
9293 (define-public cl-ana.makeres-utils
9294   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-utils))
9295
9296 (define-public sbcl-cl-ana.statistical-learning
9297   (package
9298     (inherit sbcl-cl-ana-boot0)
9299     (name "sbcl-cl-ana.statistical-learning")
9300     (inputs
9301      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9302        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
9303        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9304        ("cl-ana.linear-algebra" ,sbcl-cl-ana.linear-algebra)
9305        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9306        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9307        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
9308        ("cl-ana.map" ,sbcl-cl-ana.map)
9309        ("cl-ana.statistics" ,sbcl-cl-ana.statistics)))
9310     (native-inputs
9311      `(("cl-fad" ,sbcl-cl-fad)))
9312     (arguments
9313      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9314        ((#:asd-file _ "")
9315         "statistical-learning/cl-ana.statistical-learning.asd")
9316        ((#:asd-system-name _ #f) "cl-ana.statistical-learning")))))
9317
9318 (define-public cl-ana.statistical-learning
9319   (sbcl-package->cl-source-package sbcl-cl-ana.statistical-learning))
9320
9321 (define-public sbcl-cl-ana
9322   (package
9323     (inherit sbcl-cl-ana-boot0)
9324     (name "sbcl-cl-ana")
9325     (inputs
9326      `(("cl-ana.binary-tree" ,sbcl-cl-ana.binary-tree)
9327        ("cl-ana.calculus" ,sbcl-cl-ana.calculus)
9328        ("cl-ana.clos-utils" ,sbcl-cl-ana.clos-utils)
9329        ("cl-ana.csv-table" ,sbcl-cl-ana.csv-table)
9330        ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
9331        ("cl-ana.file-utils" ,sbcl-cl-ana.file-utils)
9332        ("cl-ana.fitting" ,sbcl-cl-ana.fitting)
9333        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9334        ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
9335        ("cl-ana.hdf-table" ,sbcl-cl-ana.hdf-table)
9336        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9337        ("cl-ana.int-char" ,sbcl-cl-ana.int-char)
9338        ("cl-ana.linear-algebra" ,sbcl-cl-ana.linear-algebra)
9339        ("cl-ana.lorentz" ,sbcl-cl-ana.lorentz)
9340        ("cl-ana.map" ,sbcl-cl-ana.map)
9341        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)
9342        ("cl-ana.makeres-block" ,sbcl-cl-ana.makeres-block)
9343        ("cl-ana.makeres-branch" ,sbcl-cl-ana.makeres-branch)
9344        ("cl-ana.makeres-graphviz" ,sbcl-cl-ana.makeres-graphviz)
9345        ("cl-ana.makeres-macro" ,sbcl-cl-ana.makeres-macro)
9346        ("cl-ana.makeres-progress" ,sbcl-cl-ana.makeres-progress)
9347        ("cl-ana.makeres-table" ,sbcl-cl-ana.makeres-table)
9348        ("cl-ana.makeres-utils" ,sbcl-cl-ana.makeres-utils)
9349        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
9350        ("cl-ana.ntuple-table" ,sbcl-cl-ana.ntuple-table)
9351        ("cl-ana.package-utils" ,sbcl-cl-ana.package-utils)
9352        ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
9353        ("cl-ana.plotting" ,sbcl-cl-ana.plotting)
9354        ("cl-ana.quantity" ,sbcl-cl-ana.quantity)
9355        ("cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
9356        ("cl-ana.serialization" ,sbcl-cl-ana.serialization)
9357        ("cl-ana.statistics" ,sbcl-cl-ana.statistics)
9358        ("cl-ana.statistical-learning" ,sbcl-cl-ana.statistical-learning)
9359        ("cl-ana.table" ,sbcl-cl-ana.table)
9360        ("cl-ana.table-utils" ,sbcl-cl-ana.table-utils)
9361        ("cl-ana.table-viewing" ,sbcl-cl-ana.table-viewing)
9362        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
9363        ("libffi" ,libffi)))
9364     (native-inputs
9365      `(("cl-fad" ,sbcl-cl-fad)))
9366     (arguments
9367      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9368        ((#:asd-file _ "") "cl-ana.asd")
9369        ((#:asd-system-name _ #f) "cl-ana")))))
9370
9371 (define-public cl-ana
9372   (sbcl-package->cl-source-package sbcl-cl-ana))
9373
9374 (define-public sbcl-archive
9375   (let ((commit "631271c091ed02994bec3980cb288a2cf32c7cdc")
9376         (revision "1"))
9377     (package
9378       (name "sbcl-archive")
9379       (version (git-version "0.9" revision commit))
9380       (source (origin
9381                 (method git-fetch)
9382                 (uri (git-reference
9383                       (url "https://github.com/sharplispers/archive.git")
9384                       (commit commit)))
9385                 (file-name (git-file-name name version))
9386                 (sha256
9387                  (base32
9388                   "0pvsc9fmybx7rxd0kmzq4shi6hszdpwdc1sfy7jwyfxf8n3hnv4p"))))
9389       (build-system asdf-build-system/sbcl)
9390       (inputs
9391        `(("cl-fad" ,sbcl-cl-fad)
9392          ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
9393       (synopsis "Common Lisp library for tar and cpio archives")
9394       (description
9395        "This is a Common Lisp library to read and write disk-based file
9396 archives such as those generated by the tar and cpio programs on Unix.")
9397       (home-page "https://github.com/sharplispers/archive")
9398       (license license:bsd-3))))
9399
9400 (define-public cl-archive
9401   (sbcl-package->cl-source-package sbcl-archive))
9402
9403 (define-public ecl-archive
9404   (sbcl-package->ecl-package sbcl-archive))
9405
9406 (define-public sbcl-misc-extensions
9407   (let ((commit "101c05112bf2f1e1bbf527396822d2f50ca6327a")
9408         (revision "1"))
9409     (package
9410       (name "sbcl-misc-extensions")
9411       (version (git-version "3.3" revision commit))
9412       (source
9413        (origin
9414          (method git-fetch)
9415          (uri (git-reference
9416                (url "https://gitlab.common-lisp.net/misc-extensions/devel.git")
9417                (commit commit)))
9418          (file-name (git-file-name name version))
9419          (sha256
9420           (base32
9421            "0gz5f4p70qzilnxsnf5lih2n9m4wjcw8hlw4w8mpn9jyhyppyyv0"))))
9422       (build-system asdf-build-system/sbcl)
9423       (synopsis "Collection of small macros and extensions for Common Lisp")
9424       (description
9425        "This project is intended as a catchall for small, general-purpose
9426 extensions to Common Lisp.  It contains:
9427
9428 @itemize
9429 @item @code{new-let}, a macro that combines and generalizes @code{let},
9430 @code{let*} and @code{multiple-value-bind},
9431 @item @code{gmap}, an iteration macro that generalizes @code{map}.
9432 @end itemize\n")
9433       (home-page "https://common-lisp.net/project/misc-extensions/")
9434       (license license:public-domain))))
9435
9436 (define-public cl-misc-extensions
9437   (sbcl-package->cl-source-package sbcl-misc-extensions))
9438
9439 (define-public ecl-misc-extensions
9440   (sbcl-package->ecl-package sbcl-misc-extensions))
9441
9442 (define-public sbcl-mt19937
9443   (package
9444     (name "sbcl-mt19937")
9445     (version "1.1")
9446     (source
9447      (origin
9448        (method url-fetch)
9449        (uri (string-append "https://common-lisp.net/project/asdf-packaging/"
9450                            "mt19937-latest.tar.gz"))
9451        (sha256
9452         (base32
9453          "1iw636b0iw5ygkv02y8i41lh7xj0acglv0hg5agryn0zzi2nf1xv"))))
9454     (build-system asdf-build-system/sbcl)
9455     (synopsis "Mersenne Twister pseudo-random number generator")
9456     (description
9457      "MT19937 is a portable Mersenne Twister pseudo-random number generator
9458 for Common Lisp.")
9459     (home-page "https://www.cliki.net/mt19937")
9460     (license license:public-domain)))
9461
9462 (define-public cl-mt19937
9463   (sbcl-package->cl-source-package sbcl-mt19937))
9464
9465 (define-public ecl-mt19937
9466   (sbcl-package->ecl-package sbcl-mt19937))
9467
9468 (define-public sbcl-fset
9469   (let ((commit "6d2f9ded8934d2b42f2571a0ba5bda091037d852")
9470         (revision "1"))
9471     (package
9472       (name "sbcl-fset")
9473       (version (git-version "1.3.2" revision commit))
9474       (source
9475        (origin
9476          (method git-fetch)
9477          (uri (git-reference
9478                (url "https://github.com/slburson/fset")
9479                (commit commit)))
9480          (file-name (git-file-name name version))
9481          (sha256
9482           (base32
9483            "127acblwrbqicx47h6sgvknz1cqyfn8p4xkhkn1m7hxh8w5gk1zy"))
9484          (snippet '(begin
9485                      ;; Remove obsolete copy of system definition.
9486                      (delete-file "Code/fset.asd")
9487                      #t))))
9488       (build-system asdf-build-system/sbcl)
9489       (inputs
9490        `(("misc-extensions" ,sbcl-misc-extensions)
9491          ("mt19937" ,sbcl-mt19937)
9492          ("named-readtables" ,sbcl-named-readtables)))
9493       (synopsis "Functional set-theoretic collections library")
9494       (description
9495        "FSet is a functional set-theoretic collections library for Common Lisp.
9496 Functional means that all update operations return a new collection rather than
9497 modifying an existing one in place.  Set-theoretic means that collections may
9498 be nested arbitrarily with no additional programmer effort; for instance, sets
9499 may contain sets, maps may be keyed by sets, etc.")
9500       (home-page "https://common-lisp.net/project/fset/Site/index.html")
9501       (license license:llgpl))))
9502
9503 (define-public cl-fset
9504   (sbcl-package->cl-source-package sbcl-fset))
9505
9506 (define-public sbcl-cl-cont
9507   (let ((commit "fc1fa7e6eb64894fdca13e688e6015fad5290d2a")
9508         (revision "1"))
9509     (package
9510       (name "sbcl-cl-cont")
9511       (version (git-version "0.3.8" revision commit))
9512       (source
9513        (origin
9514          (method git-fetch)
9515          (uri (git-reference
9516                (url "https://gitlab.common-lisp.net/cl-cont/cl-cont.git")
9517                (commit commit)))
9518          (file-name (git-file-name name version))
9519          (sha256
9520           (base32
9521            "1zf8zvb0i6jm3hhfks4w74hibm6avgc6f9s1qwgjrn2bcik8lrvz"))))
9522       (build-system asdf-build-system/sbcl)
9523       (inputs
9524        `(("alexandria" ,sbcl-alexandria)
9525          ("closer-mop" ,sbcl-closer-mop)))
9526       (native-inputs
9527        `(("rt" ,sbcl-rt)))
9528       (synopsis "Delimited continuations for Common Lisp")
9529       (description
9530        "This is a library that implements delimited continuations by
9531 transforming Common Lisp code to continuation passing style.")
9532       (home-page "https://common-lisp.net/project/cl-cont/")
9533       (license license:llgpl))))
9534
9535 (define-public cl-cont
9536   (sbcl-package->cl-source-package sbcl-cl-cont))
9537
9538 (define-public ecl-cl-cont
9539   (sbcl-package->ecl-package sbcl-cl-cont))
9540
9541 (define-public sbcl-cl-coroutine
9542   (let ((commit "de098f8d5debd8b14ef6864b5bdcbbf5ddbcfd72")
9543         (revision "1"))
9544     (package
9545       (name "sbcl-cl-coroutine")
9546       (version (git-version "0.1" revision commit))
9547       (source
9548        (origin
9549          (method git-fetch)
9550          (uri (git-reference
9551                (url "https://github.com/takagi/cl-coroutine.git")
9552                (commit commit)))
9553          (file-name (git-file-name name version))
9554          (sha256
9555           (base32
9556            "1cqdhdjxffgfs116l1swjlsmcbly0xgcgrckvaajd566idj9yj4l"))))
9557       (build-system asdf-build-system/sbcl)
9558       (inputs
9559        `(("alexandria" ,sbcl-alexandria)
9560          ("cl-cont" ,sbcl-cl-cont)))
9561       (native-inputs
9562        `(("prove" ,sbcl-prove)))
9563       (arguments
9564        `(;; TODO: Fix the tests. They fail with:
9565          ;; "Component CL-COROUTINE-ASD::CL-COROUTINE-TEST not found"
9566          #:tests? #f
9567          #:phases
9568          (modify-phases %standard-phases
9569            (add-after 'unpack 'fix-tests
9570              (lambda _
9571                (substitute* "cl-coroutine-test.asd"
9572                  (("cl-test-more")
9573                   "prove"))
9574                #t)))))
9575       (synopsis "Coroutine library for Common Lisp")
9576       (description
9577        "This is a coroutine library for Common Lisp implemented using the
9578 continuations of the @code{cl-cont} library.")
9579       (home-page "https://github.com/takagi/cl-coroutine")
9580       (license license:llgpl))))
9581
9582 (define-public cl-coroutine
9583   (sbcl-package->cl-source-package sbcl-cl-coroutine))
9584
9585 (define-public ecl-cl-coroutine
9586   (sbcl-package->ecl-package sbcl-cl-coroutine))
9587
9588 (define-public sbcl-vom
9589   (let ((commit "1aeafeb5b74c53741b79497e0ef4acf85c92ff24")
9590         (revision "1"))
9591     (package
9592       (name "sbcl-vom")
9593       (version (git-version "0.1.4" revision commit))
9594       (source
9595        (origin
9596          (method git-fetch)
9597          (uri (git-reference
9598                (url "https://github.com/orthecreedence/vom.git")
9599                (commit commit)))
9600          (file-name (git-file-name name version))
9601          (sha256
9602           (base32
9603            "0536kppj76ax4lrxhv42npkfjsmx45km2g439vf9jmw3apinz9cy"))))
9604       (build-system asdf-build-system/sbcl)
9605       (synopsis "Tiny logging utility for Common Lisp")
9606       (description
9607        "Vom is a logging library for Common Lisp.  It's goal is to be useful
9608 and small.  It does not provide a lot of features as other loggers do, but
9609 has a small codebase that's easy to understand and use.")
9610       (home-page "https://github.com/orthecreedence/vom")
9611       (license license:expat))))
9612
9613 (define-public cl-vom
9614   (sbcl-package->cl-source-package sbcl-vom))
9615
9616 (define-public ecl-vom
9617   (sbcl-package->ecl-package sbcl-vom))
9618
9619 (define-public sbcl-cl-libuv
9620   (let ((commit "32100c023c518038d0670a103eaa4d50dd785d29")
9621         (revision "1"))
9622     (package
9623       (name "sbcl-cl-libuv")
9624       (version (git-version "0.1.6" revision commit))
9625       (source
9626        (origin
9627          (method git-fetch)
9628          (uri (git-reference
9629                (url "https://github.com/orthecreedence/cl-libuv.git")
9630                (commit commit)))
9631          (file-name (git-file-name name version))
9632          (sha256
9633           (base32
9634            "1kwix4si8a8hza34ab2k7whrh7z0yrmx39v2wc3qblv9m244jkh1"))))
9635       (build-system asdf-build-system/sbcl)
9636       (inputs
9637        `(("alexandria" ,sbcl-alexandria)
9638          ("cffi" ,sbcl-cffi)
9639          ("cffi-grovel" ,sbcl-cffi-grovel)
9640          ("libuv" ,libuv)))
9641       (arguments
9642        `(#:phases
9643          (modify-phases %standard-phases
9644            (add-after 'unpack 'fix-paths
9645              (lambda* (#:key inputs #:allow-other-keys)
9646                (substitute* "lib.lisp"
9647                  (("/usr/lib/libuv.so")
9648                   (string-append (assoc-ref inputs "libuv")
9649                                  "/lib/libuv.so")))
9650                #t))
9651            (add-after 'fix-paths 'fix-system-definition
9652              (lambda _
9653                (substitute* "cl-libuv.asd"
9654                  (("#:cffi #:alexandria")
9655                   "#:cffi #:cffi-grovel #:alexandria"))
9656                #t)))))
9657       (synopsis "Common Lisp bindings to libuv")
9658       (description
9659        "This library provides low-level libuv bindings for Common Lisp.")
9660       (home-page "https://github.com/orthecreedence/cl-libuv")
9661       (license license:expat))))
9662
9663 (define-public cl-libuv
9664   (sbcl-package->cl-source-package sbcl-cl-libuv))
9665
9666 (define-public ecl-cl-libuv
9667   (sbcl-package->ecl-package sbcl-cl-libuv))
9668
9669 (define-public sbcl-cl-async-base
9670   (let ((commit "f6423e44404a44434d803605e0d2e17199158e28")
9671         (revision "1"))
9672     (package
9673       (name "sbcl-cl-async-base")
9674       (version (git-version "0.6.1" revision commit))
9675       (source
9676        (origin
9677          (method git-fetch)
9678          (uri (git-reference
9679                (url "https://github.com/orthecreedence/cl-async.git")
9680                (commit commit)))
9681          (file-name (git-file-name name version))
9682          (sha256
9683           (base32
9684            "11xi9dxb8mjgwzrkj88i0xkgk26z9w9ddxzbv6xsvfc1d4x5cf4x"))))
9685       (build-system asdf-build-system/sbcl)
9686       (inputs
9687        `(("bordeaux-threads" ,sbcl-bordeaux-threads)
9688          ("cffi" ,sbcl-cffi)
9689          ("cl-libuv" ,sbcl-cl-libuv)))
9690       (arguments
9691        `(#:asd-file "cl-async.asd"))
9692       (synopsis "Base system for cl-async")
9693       (description
9694        "Cl-async is a library for general purpose, non-blocking programming in
9695 Common Lisp.  It uses the libuv library as backend.")
9696       (home-page "https://orthecreedence.github.io/cl-async/")
9697       (license license:expat))))
9698
9699 (define-public cl-async-base
9700   (sbcl-package->cl-source-package sbcl-cl-async-base))
9701
9702 (define-public ecl-cl-async-base
9703   (sbcl-package->ecl-package sbcl-cl-async-base))
9704
9705 (define-public sbcl-cl-async-util
9706   (package
9707     (inherit sbcl-cl-async-base)
9708     (name "sbcl-cl-async-util")
9709     (inputs
9710      `(("bordeaux-threads" ,sbcl-bordeaux-threads)
9711        ("cffi" ,sbcl-cffi)
9712        ("cl-async-base" ,sbcl-cl-async-base)
9713        ("cl-libuv" ,sbcl-cl-libuv)
9714        ("cl-ppcre" ,sbcl-cl-ppcre)
9715        ("fast-io" ,sbcl-fast-io)
9716        ("vom" ,sbcl-vom)))
9717     (synopsis "Internal utilities for cl-async")))
9718
9719 (define-public cl-async-util
9720   (sbcl-package->cl-source-package sbcl-cl-async-util))
9721
9722 (define-public ecl-cl-async-util
9723   (sbcl-package->ecl-package sbcl-cl-async-util))
9724
9725 (define-public sbcl-cl-async
9726   (package
9727     (inherit sbcl-cl-async-base)
9728     (name "sbcl-cl-async")
9729     (inputs
9730      `(("babel" ,sbcl-babel)
9731        ("cffi" ,sbcl-cffi)
9732        ("cl-async-base" ,sbcl-cl-async-base)
9733        ("cl-async-util" ,sbcl-cl-async-util)
9734        ("cl-libuv" ,sbcl-cl-libuv)
9735        ("cl-ppcre" ,sbcl-cl-ppcre)
9736        ("static-vectors" ,sbcl-static-vectors)
9737        ("trivial-features" ,sbcl-trivial-features)
9738        ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
9739     (synopsis "Asynchronous operations for Common Lisp")))
9740
9741 (define-public cl-async
9742   (sbcl-package->cl-source-package sbcl-cl-async))
9743
9744 (define-public ecl-cl-async
9745   (sbcl-package->ecl-package sbcl-cl-async))
9746
9747 (define-public sbcl-cl-async-repl
9748   (package
9749     (inherit sbcl-cl-async-base)
9750     (name "sbcl-cl-async-repl")
9751     (inputs
9752      `(("bordeaux-threads" ,sbcl-bordeaux-threads)
9753        ("cl-async" ,sbcl-cl-async)))
9754     (arguments
9755      (substitute-keyword-arguments (package-arguments sbcl-cl-async-base)
9756        ((#:asd-file _ "") "cl-async-repl.asd")))
9757     (synopsis "REPL integration for cl-async")))
9758
9759 (define-public cl-async-repl
9760   (sbcl-package->cl-source-package sbcl-cl-async-repl))
9761
9762 (define-public ecl-cl-async-repl
9763   (sbcl-package->ecl-package sbcl-cl-async-repl))
9764
9765 (define-public sbcl-cl-async-ssl
9766   (package
9767     (inherit sbcl-cl-async-base)
9768     (name "sbcl-cl-async-ssl")
9769     (inputs
9770      `(("cffi" ,sbcl-cffi)
9771        ("cl-async" ,sbcl-cl-async)
9772        ("openssl" ,openssl)
9773        ("vom" ,sbcl-vom)))
9774     (arguments
9775      (substitute-keyword-arguments (package-arguments sbcl-cl-async-base)
9776        ((#:asd-file _ "") "cl-async-ssl.asd")
9777        ((#:phases phases '%standard-phases)
9778         `(modify-phases ,phases
9779            (add-after 'unpack 'fix-paths
9780              (lambda* (#:key inputs #:allow-other-keys)
9781                (substitute* "src/ssl/package.lisp"
9782                  (("libcrypto\\.so")
9783                   (string-append (assoc-ref inputs "openssl")
9784                                  "/lib/libcrypto.so"))
9785                  (("libssl\\.so")
9786                   (string-append (assoc-ref inputs "openssl")
9787                                  "/lib/libssl.so")))
9788                #t))))))
9789     (synopsis "SSL wrapper around cl-async socket implementation")))
9790
9791 (define-public cl-async-ssl
9792   (sbcl-package->cl-source-package sbcl-cl-async-ssl))
9793
9794 (define-public ecl-cl-async-ssl
9795   (sbcl-package->ecl-package sbcl-cl-async-ssl))
9796
9797 (define-public sbcl-blackbird
9798   (let ((commit "d361f81c1411dec07f6c2dcb11c78f7aea9aaca8")
9799         (revision "1"))
9800     (package
9801       (name "sbcl-blackbird")
9802       (version (git-version "0.5.2" revision commit))
9803       (source
9804        (origin
9805          (method git-fetch)
9806          (uri (git-reference
9807                (url "https://github.com/orthecreedence/blackbird.git")
9808                (commit commit)))
9809          (file-name (git-file-name name version))
9810          (sha256
9811           (base32
9812            "0xfds5yaya64arzr7w1x38karyz11swzbhxx1afldpradj9dh19c"))))
9813       (build-system asdf-build-system/sbcl)
9814       (inputs
9815        `(("vom" ,sbcl-vom)))
9816       (native-inputs
9817        `(("cl-async" ,sbcl-cl-async)
9818          ("fiveam" ,sbcl-fiveam)))
9819       (synopsis "Promise implementation for Common Lisp")
9820       (description
9821        "This is a standalone promise implementation for Common Lisp.  It is
9822 the successor to the now-deprecated cl-async-future project.")
9823       (home-page "https://orthecreedence.github.io/blackbird/")
9824       (license license:expat))))
9825
9826 (define-public cl-blackbird
9827   (sbcl-package->cl-source-package sbcl-blackbird))
9828
9829 (define-public ecl-blackbird
9830   (sbcl-package->ecl-package sbcl-blackbird))
9831
9832 (define-public sbcl-cl-async-future
9833   (let ((commit "ee36c22a69a9516407458d2ed8b475f1fc473959")
9834         (revision "1"))
9835     (package
9836       (name "sbcl-cl-async-future")
9837       (version (git-version "0.4.4.1" revision commit))
9838       (source
9839        (origin
9840          (method git-fetch)
9841          (uri (git-reference
9842                (url "https://github.com/orthecreedence/cl-async-future.git")
9843                (commit commit)))
9844          (file-name (git-file-name name version))
9845          (sha256
9846           (base32
9847            "0z0sc7qlzzxk99f4l26zp6rai9kv0kj0f599sxai5s44p17zbbvh"))))
9848       (build-system asdf-build-system/sbcl)
9849       (inputs
9850        `(("blackbird" ,sbcl-blackbird)))
9851       (native-inputs
9852        `(("cl-async" ,sbcl-cl-async)
9853          ("eos" ,sbcl-eos)))
9854       (synopsis "Futures implementation for Common Lisp")
9855       (description
9856        "This is futures implementation for Common Lisp.  It plugs in nicely
9857 to cl-async.")
9858       (home-page "https://orthecreedence.github.io/cl-async/future")
9859       (license license:expat))))
9860
9861 (define-public cl-async-future
9862   (sbcl-package->cl-source-package sbcl-cl-async-future))
9863
9864 (define-public ecl-cl-async-future
9865   (sbcl-package->ecl-package sbcl-cl-async-future))
9866
9867 (define-public sbcl-green-threads
9868   (let ((commit "fff5ebecb441a37e5c511773716aafd84a3c5840")
9869         (revision "1"))
9870     (package
9871       (name "sbcl-green-threads")
9872       (version (git-version "0.3" revision commit))
9873       (source
9874        (origin
9875          (method git-fetch)
9876          (uri (git-reference
9877                (url "https://github.com/thezerobit/green-threads.git")
9878                (commit commit)))
9879          (file-name (git-file-name name version))
9880          (sha256
9881           (base32
9882            "1czw7nr0dwfps76h8hjvglk1wdh53yqbfbvv30whwbgqx33iippz"))))
9883       (build-system asdf-build-system/sbcl)
9884       (inputs
9885        `(("cl-async-future" ,sbcl-cl-async-future)
9886          ("cl-cont" ,sbcl-cl-cont)))
9887       (native-inputs
9888        `(("prove" ,sbcl-prove)))
9889       (arguments
9890        `(;; TODO: Fix the tests. They fail with:
9891          ;; "The function BLACKBIRD::PROMISE-VALUES is undefined"
9892          #:tests? #f
9893          #:phases
9894          (modify-phases %standard-phases
9895            (add-after 'unpack 'fix-tests
9896              (lambda _
9897                (substitute* "green-threads-test.asd"
9898                  (("cl-test-more")
9899                   "prove"))
9900                #t)))))
9901       (synopsis "Cooperative multitasking library for Common Lisp")
9902       (description
9903        "This library allows for cooperative multitasking with help of cl-cont
9904 for continuations.  It tries to mimic the API of bordeaux-threads as much as
9905 possible.")
9906       (home-page "https://github.com/thezerobit/green-threads")
9907       (license license:bsd-3))))
9908
9909 (define-public cl-green-threads
9910   (sbcl-package->cl-source-package sbcl-green-threads))
9911
9912 (define-public ecl-green-threads
9913   (sbcl-package->ecl-package sbcl-green-threads))
9914
9915 (define-public sbcl-cl-base32
9916   (let ((commit "8cdee06fab397f7b0a19583b57e7f0c98405be85")
9917         (revision "1"))
9918     (package
9919       (name "sbcl-cl-base32")
9920       (version (git-version "0.1" revision commit))
9921       (source
9922        (origin
9923          (method git-fetch)
9924          (uri (git-reference
9925                (url "https://github.com/hargettp/cl-base32.git")
9926                (commit commit)))
9927          (file-name (git-file-name name version))
9928          (sha256
9929           (base32 "17jrng8jb05d64ggyd11hp308c2fl5drvf9g175blgrkkl8l4mf8"))))
9930       (build-system asdf-build-system/sbcl)
9931       (native-inputs
9932        `(("lisp-unit" ,sbcl-lisp-unit)))
9933       (synopsis "Common Lisp library for base32 encoding and decoding")
9934       (description
9935        "This package provides functions for base32 encoding and decoding as
9936 defined in RFC4648.")
9937       (home-page "https://github.com/hargettp/cl-base32")
9938       (license license:expat))))
9939
9940 (define-public cl-base32
9941   (sbcl-package->cl-source-package sbcl-cl-base32))
9942
9943 (define-public ecl-cl-base32
9944   (sbcl-package->ecl-package sbcl-cl-base32))
9945
9946 (define-public sbcl-cl-z85
9947   (let ((commit "85b3951a9cfa2603acb6aee15567684f9a108098")
9948         (revision "1"))
9949     (package
9950       (name "sbcl-cl-z85")
9951       (version (git-version "1.0" revision commit))
9952       (source
9953        (origin
9954          (method git-fetch)
9955          (uri (git-reference
9956                (url "https://github.com/glv2/cl-z85.git")
9957                (commit commit)))
9958          (file-name (git-file-name name version))
9959          (sha256
9960           (base32 "0r27pidjaxbm7k1rr90nnajwl5xm2kp65g1fv0fva17lzy45z1mp"))))
9961       (build-system asdf-build-system/sbcl)
9962       (native-inputs
9963        `(("cl-octet-streams" ,sbcl-cl-octet-streams)
9964          ("fiveam" ,sbcl-fiveam)))
9965       (synopsis "Common Lisp library for Z85 encoding and decoding")
9966       (description
9967        "This package provides functions to encode or decode byte vectors or
9968 byte streams using the Z85 format, which is a base-85 encoding used by
9969 ZeroMQ.")
9970       (home-page "https://github.com/glv2/cl-z85")
9971       (license license:gpl3+))))
9972
9973 (define-public cl-z85
9974   (sbcl-package->cl-source-package sbcl-cl-z85))
9975
9976 (define-public ecl-cl-z85
9977   (sbcl-package->ecl-package sbcl-cl-z85))
9978
9979 (define-public sbcl-ltk
9980   (package
9981     (name "sbcl-ltk")
9982     (version "0.992")
9983     (source
9984      (origin
9985        (method git-fetch)
9986        (uri (git-reference
9987              (url "https://github.com/herth/ltk.git")
9988              (commit version)))
9989        (file-name (git-file-name name version))
9990        (sha256
9991         (base32 "13l2q4mskzilya9xh5wy2xvy30lwn104bd8wrq6ifds56r82iy3x"))))
9992     (build-system asdf-build-system/sbcl)
9993     (inputs
9994      `(("imagemagick" ,imagemagick)
9995        ("tk" ,tk)))
9996     (arguments
9997      `(#:asd-file "ltk/ltk.asd"
9998        #:tests? #f
9999        #:phases (modify-phases %standard-phases
10000                   (add-after 'unpack 'fix-paths
10001                     (lambda* (#:key inputs #:allow-other-keys)
10002                       (substitute* "ltk/ltk.lisp"
10003                         (("#-freebsd \"wish\"")
10004                          (string-append "#-freebsd \""
10005                                         (assoc-ref inputs "tk")
10006                                         "/bin/wish\""))
10007                         (("do-execute \"convert\"")
10008                          (string-append "do-execute \""
10009                                         (assoc-ref inputs "imagemagick")
10010                                         "/bin/convert\"")))
10011                       #t)))))
10012     (synopsis "Common Lisp bindings for the Tk GUI toolkit")
10013     (description
10014      "LTK is a Common Lisp binding for the Tk graphics toolkit.  It is written
10015 in pure Common Lisp and does not require any Tk knowledge for its usage.")
10016     (home-page "http://www.peter-herth.de/ltk/")
10017     (license license:llgpl)))
10018
10019 (define-public cl-ltk
10020   (sbcl-package->cl-source-package sbcl-ltk))
10021
10022 (define-public ecl-ltk
10023   (sbcl-package->ecl-package sbcl-ltk))
10024
10025 (define-public sbcl-ltk-mw
10026   (package
10027     (inherit sbcl-ltk)
10028     (name "sbcl-ltk-mw")
10029     (inputs
10030      `(("ltk" ,sbcl-ltk)))
10031     (arguments
10032      (substitute-keyword-arguments (package-arguments sbcl-ltk)
10033        ((#:asd-file _) "ltk/ltk-mw.asd")
10034        ((#:phases _) '%standard-phases)))
10035     (synopsis "Extra widgets for LTK")
10036     (description
10037      "This is a collection of higher-level widgets built on top of LTK.")))
10038
10039 (define-public cl-ltk-mw
10040   (sbcl-package->cl-source-package sbcl-ltk-mw))
10041
10042 (define-public ecl-ltk-mw
10043   (sbcl-package->ecl-package sbcl-ltk-mw))
10044
10045 (define-public sbcl-ltk-remote
10046   (package
10047     (inherit sbcl-ltk)
10048     (name "sbcl-ltk-remote")
10049     (inputs
10050      `(("ltk" ,sbcl-ltk)))
10051     (arguments
10052      (substitute-keyword-arguments (package-arguments sbcl-ltk)
10053        ((#:asd-file _) "ltk/ltk-remote.asd")
10054        ((#:phases _) '%standard-phases)))
10055     (synopsis "Remote GUI support for LTK")
10056     (description
10057      "This LTK extension allows the GUI to be displayed on a computer different
10058 from the one running the Lisp program by using a TCP connection.")))
10059
10060 (define-public cl-ltk-remote
10061   (sbcl-package->cl-source-package sbcl-ltk-remote))
10062
10063 (define-public sbcl-cl-lex
10064   (let ((commit "f2dbbe25ef553005fb402d9a6203180c3fa1093b")
10065         (revision "1"))
10066     (package
10067       (name "sbcl-cl-lex")
10068       (version (git-version "1.1.3" revision commit))
10069       (source
10070        (origin
10071          (method git-fetch)
10072          (uri (git-reference
10073                (url "https://github.com/djr7C4/cl-lex.git")
10074                (commit commit)))
10075          (file-name (git-file-name name version))
10076          (sha256
10077           (base32 "1kg50f76bfpfxcv4dfivq1n9a0xlsra2ajb0vd68lxwgbidgyc2y"))))
10078       (build-system asdf-build-system/sbcl)
10079       (inputs
10080        `(("cl-ppcre" ,sbcl-cl-ppcre)))
10081       (synopsis "Common Lisp macros for generating lexical analyzers")
10082       (description
10083        "This is a Common Lisp library providing a set of macros for generating
10084 lexical analyzers automatically.  The lexers generated using @code{cl-lex} can
10085 be used with @code{cl-yacc}.")
10086       (home-page "https://github.com/djr7C4/cl-lex")
10087       (license license:gpl3))))
10088
10089 (define-public cl-lex
10090   (sbcl-package->cl-source-package sbcl-cl-lex))
10091
10092 (define-public ecl-cl-lex
10093   (sbcl-package->ecl-package sbcl-cl-lex))
10094
10095 (define-public sbcl-clunit2
10096   (let ((commit "5e28343734eb9b7aee39306a614af92c1062d50b")
10097         (revision "1"))
10098     (package
10099       (name "sbcl-clunit2")
10100       (version (git-version "0.2.4" revision commit))
10101       (source
10102        (origin
10103          (method git-fetch)
10104          (uri (git-reference
10105                (url "https://notabug.org/cage/clunit2.git")
10106                (commit commit)))
10107          (file-name (git-file-name name version))
10108          (sha256
10109           (base32 "1ngiapfki6nm8a555mzhb5p7ch79i3w665za5bmb5j7q34fy80vw"))))
10110       (build-system asdf-build-system/sbcl)
10111       (synopsis "Unit testing framework for Common Lisp")
10112       (description
10113        "CLUnit is a Common Lisp unit testing framework.  It is designed to be
10114 easy to use so that you can quickly start testing.")
10115       (home-page "https://notabug.org/cage/clunit2")
10116       (license license:expat))))
10117
10118 (define-public cl-clunit2
10119   (sbcl-package->cl-source-package sbcl-clunit2))
10120
10121 (define-public ecl-clunit2
10122   (sbcl-package->ecl-package sbcl-clunit2))
10123
10124 (define-public sbcl-cl-colors2
10125   (let ((commit "795aedee593b095fecde574bd999b520dd03ed24")
10126         (revision "1"))
10127     (package
10128       (name "sbcl-cl-colors2")
10129       (version (git-version "0.2.1" revision commit))
10130       (source
10131        (origin
10132          (method git-fetch)
10133          (uri (git-reference
10134                (url "https://notabug.org/cage/cl-colors2.git")
10135                (commit commit)))
10136          (file-name (git-file-name name version))
10137          (sha256
10138           (base32 "0hlyf4h5chkjdp9armla5w4kw5acikk159sym7y8c4jbjp9x47ih"))))
10139       (build-system asdf-build-system/sbcl)
10140       (native-inputs
10141        `(("clunit2" ,sbcl-clunit2)))
10142       (inputs
10143        `(("alexandria" ,sbcl-alexandria)
10144          ("cl-ppcre" ,sbcl-cl-ppcre)))
10145       (synopsis "Color library for Common Lisp")
10146       (description
10147        "This is a very simple color library for Common Lisp, providing:
10148
10149 @itemize
10150 @item Types for representing colors in HSV and RGB spaces.
10151 @item Simple conversion functions between the above types (and also
10152 hexadecimal representation for RGB).
10153 @item Some predefined colors (currently X11 color names -- of course
10154 the library does not depend on X11).
10155 @end itemize\n")
10156       (home-page "https://notabug.org/cage/cl-colors2")
10157       (license license:boost1.0))))
10158
10159 (define-public cl-colors2
10160   (sbcl-package->cl-source-package sbcl-cl-colors2))
10161
10162 (define-public ecl-cl-colors2
10163   (sbcl-package->ecl-package sbcl-cl-colors2))
10164
10165 (define-public sbcl-cl-jpeg
10166   (let ((commit "ec557038128df6895fbfb743bfe8faf8ec2534af")
10167         (revision "1"))
10168     (package
10169       (name "sbcl-cl-jpeg")
10170       (version (git-version "2.8" revision commit))
10171       (source
10172        (origin
10173          (method git-fetch)
10174          (uri (git-reference
10175                (url "https://github.com/sharplispers/cl-jpeg.git")
10176                (commit commit)))
10177          (file-name (git-file-name name version))
10178          (sha256
10179           (base32 "1bkkiqz8fqldlj1wbmrccjsvxcwj98h6s4b6gslr3cg2wmdv5xmy"))))
10180       (build-system asdf-build-system/sbcl)
10181       (synopsis "JPEG image library for Common Lisp")
10182       (description
10183        "This is a baseline JPEG codec written in Common Lisp.  It can be used
10184 for reading and writing JPEG image files.")
10185       (home-page "https://github.com/sharplispers/cl-jpeg")
10186       (license license:bsd-3))))
10187
10188 (define-public cl-jpeg
10189   (sbcl-package->cl-source-package sbcl-cl-jpeg))
10190
10191 (define-public ecl-cl-jpeg
10192   (sbcl-package->ecl-package sbcl-cl-jpeg))
10193
10194 (define-public sbcl-nodgui
10195   (let ((commit "bc59ed9b787dfc9e68ae3bd7f7e8507c5c619212")
10196         (revision "1"))
10197     (package
10198       (name "sbcl-nodgui")
10199       (version (git-version "0.0.5" revision commit))
10200       (source
10201        (origin
10202          (method git-fetch)
10203          (uri (git-reference
10204                (url "https://notabug.org/cage/nodgui.git")
10205                (commit commit)))
10206          (file-name (git-file-name name version))
10207          (sha256
10208           (base32 "0xx0dk54d882i598ydnwmy7mnfk0b7vib3ddsgpqxhjck1rwq8l8"))))
10209       (build-system asdf-build-system/sbcl)
10210       (inputs
10211        `(("alexandria" ,sbcl-alexandria)
10212          ("bordeaux-threads" ,sbcl-bordeaux-threads)
10213          ("cl-colors2" ,sbcl-cl-colors2)
10214          ("cl-jpeg" ,sbcl-cl-jpeg)
10215          ("cl-lex" ,sbcl-cl-lex)
10216          ("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)
10217          ("cl-unicode" ,sbcl-cl-unicode)
10218          ("cl-yacc" ,sbcl-cl-yacc)
10219          ("clunit2" ,sbcl-clunit2)
10220          ("named-readtables" ,sbcl-named-readtables)
10221          ("parse-number" ,sbcl-parse-number)
10222          ("tk" ,tk)))
10223       (arguments
10224        `(#:phases (modify-phases %standard-phases
10225                     (add-after 'unpack 'fix-paths
10226                       (lambda* (#:key inputs #:allow-other-keys)
10227                         (substitute* "src/wish-communication.lisp"
10228                           (("#-freebsd \"wish\"")
10229                            (string-append "#-freebsd \""
10230                                           (assoc-ref inputs "tk")
10231                                           "/bin/wish\"")))
10232                         #t)))))
10233       (synopsis "Common Lisp bindings for the Tk GUI toolkit")
10234       (description
10235        "Nodgui (@emph{No Drama GUI}) is a Common Lisp binding for the Tk GUI
10236 toolkit.  It also provides a few additional widgets more than the standard Tk
10237 ones.")
10238       (home-page "https://www.autistici.org/interzona/nodgui.html")
10239       (license license:llgpl))))
10240
10241 (define-public cl-nodgui
10242   (sbcl-package->cl-source-package sbcl-nodgui))
10243
10244 (define-public ecl-nodgui
10245   (sbcl-package->ecl-package sbcl-nodgui))
10246
10247 (define-public sbcl-salza2
10248   (package
10249     (name "sbcl-salza2")
10250     (version "2.0.9")
10251     (source
10252      (origin
10253        (method git-fetch)
10254        (uri (git-reference
10255              (url "https://github.com/xach/salza2.git")
10256              (commit (string-append "release-" version))))
10257        (file-name (git-file-name name version))
10258        (sha256
10259         (base32 "0p38rj4gq7j5k807php7hrz7l2zyyfshv8i9yms7i8lkgg3433ki"))))
10260     (build-system asdf-build-system/sbcl)
10261     (synopsis "Common Lisp library for zlib, deflate and gzip compression")
10262     (description
10263      "Salza2 is a Common Lisp library for creating compressed data in the zlib,
10264 deflate, or gzip data formats, described in RFC 1950, RFC 1951, and RFC 1952,
10265 respectively.")
10266     (home-page "https://www.xach.com/lisp/salza2/")
10267     (license license:bsd-2)))
10268
10269 (define-public cl-salza2
10270   (sbcl-package->cl-source-package sbcl-salza2))
10271
10272 (define-public ecl-salza2
10273   (sbcl-package->ecl-package sbcl-salza2))
10274
10275 (define-public sbcl-png-read
10276   (let ((commit "ec29f38a689972b9f1373f13bbbcd6b05deada88")
10277         (revision "1"))
10278     (package
10279       (name "sbcl-png-read")
10280       (version (git-version "0.3.1" revision commit))
10281       (source
10282        (origin
10283          (method git-fetch)
10284          (uri (git-reference
10285                (url "https://github.com/Ramarren/png-read.git")
10286                (commit commit)))
10287          (file-name (git-file-name name version))
10288          (sha256
10289           (base32 "0vyczbcwskrygrf1hgrsnk0jil8skmvf1kiaalw5jps4fjrfdkw0"))))
10290       (build-system asdf-build-system/sbcl)
10291       (inputs
10292        `(("babel" ,sbcl-babel)
10293          ("chipz" ,sbcl-chipz)
10294          ("iterate" ,sbcl-iterate)))
10295       (synopsis "PNG decoder for Common Lisp")
10296       (description "This is a Common Lisp library for reading PNG images.")
10297       (home-page "https://github.com/Ramarren/png-read")
10298       (license license:bsd-3))))
10299
10300 (define-public cl-png-read
10301   (sbcl-package->cl-source-package sbcl-png-read))
10302
10303 (define-public ecl-png-read
10304   (sbcl-package->ecl-package sbcl-png-read))
10305
10306 (define-public sbcl-zpng
10307   (package
10308     (name "sbcl-zpng")
10309     (version "1.2.2")
10310     (source
10311      (origin
10312        (method git-fetch)
10313        (uri (git-reference
10314              (url "https://github.com/xach/zpng.git")
10315              (commit (string-append "release-" version))))
10316        (file-name (git-file-name name version))
10317        (sha256
10318         (base32 "0b3ag3jhl3z7kdls3ahdsdxsfhhw5qrizk769984f4wkxhb69rcm"))))
10319     (build-system asdf-build-system/sbcl)
10320     (inputs
10321      `(("salza2" ,sbcl-salza2)))
10322     (synopsis "PNG encoder for Common Lisp")
10323     (description "This is a Common Lisp library for creating PNG images.")
10324     (home-page "https://www.xach.com/lisp/zpng/")
10325     (license license:bsd-2)))
10326
10327 (define-public cl-zpng
10328   (sbcl-package->cl-source-package sbcl-zpng))
10329
10330 (define-public ecl-zpng
10331   (sbcl-package->ecl-package sbcl-zpng))
10332
10333 (define-public sbcl-cl-qrencode
10334   (package
10335     (name "sbcl-cl-qrencode")
10336     (version "0.1.2")
10337     (source
10338      (origin
10339        (method git-fetch)
10340        (uri (git-reference
10341              (url "https://github.com/jnjcc/cl-qrencode.git")
10342              (commit (string-append "v" version))))
10343        (file-name (git-file-name name version))
10344        (sha256
10345         (base32 "1l5k131dchbf6cj8a8xqa731790p01p3qa1kdy2wa9dawy3ymkxr"))))
10346     (build-system asdf-build-system/sbcl)
10347     (native-inputs
10348      `(("lisp-unit" ,sbcl-lisp-unit)))
10349     (inputs
10350      `(("zpng" ,sbcl-zpng)))
10351     (synopsis "QR code encoder for Common Lisp")
10352     (description
10353      "This Common Lisp library provides function to make QR codes and to save
10354 them as PNG files.")
10355     (home-page "https://github.com/jnjcc/cl-qrencode")
10356     (license license:gpl2+)))
10357
10358 (define-public cl-qrencode
10359   (sbcl-package->cl-source-package sbcl-cl-qrencode))
10360
10361 (define-public ecl-cl-qrencode
10362   (sbcl-package->ecl-package sbcl-cl-qrencode))
10363
10364 (define-public sbcl-hdf5-cffi
10365   (let ((commit "5b5c88f191e470e4fe96b462334e3ce0806eed5c")
10366         (revision "1"))
10367     (package
10368       (name "sbcl-hdf5-cffi")
10369       (version (git-version "1.8.18" revision commit))
10370       (source
10371        (origin
10372          (method git-fetch)
10373          (uri (git-reference
10374                (url "https://github.com/hdfgroup/hdf5-cffi.git")
10375                (commit commit)))
10376          (file-name (git-file-name name version))
10377          (sha256
10378           (base32
10379            "0vda3075423xz83qky998lpac5b04dwfv7bwgh9jq8cs5v0zrxjf"))))
10380       (build-system asdf-build-system/sbcl)
10381       (synopsis "Common Lisp bindings for the HDF5 library")
10382       (description
10383        "@code{hdf5-cffi} is a CFFI wrapper for the HDF5 library.")
10384       (home-page "https://github.com/hdfgroup/hdf5-cffi")
10385       (license (license:non-copyleft
10386                 (string-append "https://github.com/HDFGroup/hdf5-cffi/raw/"
10387                                commit
10388                                "/LICENSE")))
10389       (inputs
10390        `(("cffi" ,sbcl-cffi)
10391          ("cffi-grovel" ,sbcl-cffi-grovel)
10392          ("hdf5" ,hdf5-1.10)))
10393       (native-inputs
10394        `(("fiveam" ,sbcl-fiveam)))
10395       (arguments
10396        `(#:asd-system-name "hdf5-cffi"
10397          #:asd-file "hdf5-cffi.asd"
10398          #:test-asd-file "hdf5-cffi.test.asd"
10399          ;; Tests depend on hdf5-cffi.examples.asd in addition to hdf5-cffi.asd,
10400          ;; I don't know if there is a way to tell asdf-build-system to load
10401          ;; an additional system first, so tests are disabled.
10402          #:tests? #f
10403          #:phases
10404          (modify-phases %standard-phases
10405            (add-after 'unpack 'fix-paths
10406              (lambda* (#:key inputs #:allow-other-keys)
10407                (substitute* "src/library.lisp"
10408                  (("libhdf5.so")
10409                   (string-append
10410                    (assoc-ref inputs "hdf5")
10411                    "/lib/libhdf5.so")))))
10412            (add-after 'unpack 'fix-dependencies
10413              (lambda* (#:key inputs #:allow-other-keys)
10414                (substitute* "hdf5-cffi.asd"
10415                  ((":depends-on \\(:cffi\\)")
10416                   ":depends-on (:cffi :cffi-grovel)"))
10417                (substitute* "hdf5-cffi.test.asd"
10418                  ((":depends-on \\(:cffi :hdf5-cffi")
10419                   ":depends-on (:cffi :cffi-grovel :hdf5-cffi"))))))))))
10420
10421 (define-public cl-hdf5-cffi
10422   (sbcl-package->cl-source-package sbcl-hdf5-cffi))
10423
10424 (define-public ecl-hdf5-cffi
10425   (sbcl-package->ecl-package sbcl-hdf5-cffi))
10426
10427 (define-public sbcl-cl-randist
10428   (package
10429     (name "sbcl-cl-randist")
10430     (version "0.4.2")
10431     (source
10432      (origin
10433        (method git-fetch)
10434        (uri (git-reference
10435              (url "https://github.com/lvaruzza/cl-randist.git")
10436              (commit "f088a54b540a7adefab7c04094a6103f9edda3d0")))
10437        (file-name (git-file-name name version))
10438        (sha256
10439         (base32
10440          "0l8hyd6nbxb7f50vyxz3rbbm7kgr1fnadc40jywy4xj5vi5kpj5g"))))
10441     (build-system asdf-build-system/sbcl)
10442     (synopsis "Random distributions for Common Lisp")
10443     (description
10444      "Manual translation from C to Common Lisp of some random number
10445 generation functions from the GSL library.")
10446     (home-page "https://github.com/lvaruzza/cl-randist")
10447     (license license:bsd-2)
10448     (arguments
10449      `(#:asd-system-name "cl-randist"
10450        #:asd-file "cl-randist.asd"
10451        #:tests? #f))))
10452
10453 (define-public cl-randist
10454   (sbcl-package->cl-source-package sbcl-cl-randist))
10455
10456 (define-public ecl-cl-randist
10457   (sbcl-package->ecl-package sbcl-cl-randist))
10458
10459 (define-public sbcl-float-features
10460   (package
10461     (name "sbcl-float-features")
10462     (version "1.0.0")
10463     (source
10464      (origin
10465        (method git-fetch)
10466        (uri (git-reference
10467              (url "https://github.com/Shinmera/float-features.git")
10468              (commit "d3ef60181635b0849aa28cfc238053b7ca4644b0")))
10469        (file-name (git-file-name name version))
10470        (sha256
10471         (base32
10472          "0yj419k7n59x6rh3grwr6frgwwyria2il6f7wxpfazm8cskv4lzr"))))
10473     (build-system asdf-build-system/sbcl)
10474     (synopsis "Common Lisp IEEE float portability library")
10475     (description
10476      "Portability library for IEEE float features that are not
10477 covered by the Common Lisp standard.")
10478     (home-page "https://github.com/Shinmera/float-features")
10479     (license license:zlib)
10480     (inputs
10481      `(("documentation-utils" ,sbcl-documentation-utils)))
10482     (arguments
10483      `(#:asd-system-name "float-features"
10484        #:asd-file "float-features.asd"
10485        #:tests? #f))))
10486
10487 (define-public cl-float-features
10488   (sbcl-package->cl-source-package sbcl-float-features))
10489
10490 (define-public ecl-float-features
10491   (sbcl-package->ecl-package sbcl-float-features))
10492
10493 (define-public sbcl-function-cache
10494   (package
10495     (name "sbcl-function-cache")
10496     (version "1.0.3")
10497     (source
10498      (origin
10499        (method git-fetch)
10500        (uri (git-reference
10501              (url "https://github.com/AccelerationNet/function-cache.git")
10502              (commit "6a5ada401e57da2c8abf046f582029926e61fce8")))
10503        (file-name (git-file-name name version))
10504        (sha256
10505         (base32
10506          "000vmd3f5rx5hs9nvphfric0gkzaadns31c6mxaslpv0k7pkrmc6"))))
10507     (build-system asdf-build-system/sbcl)
10508     (synopsis "Function caching / memoization library for Common Lisp")
10509     (description
10510      "A common lisp library that provides extensible function result
10511 caching based on arguments (an expanded form of memoization).")
10512     (home-page "https://github.com/AccelerationNet/function-cache")
10513     (license
10514      (license:non-copyleft
10515       "https://github.com/AccelerationNet/function-cache/blob/master/README.md"))
10516     (inputs
10517      `(("alexandria" ,sbcl-alexandria)
10518        ("cl-interpol" ,sbcl-cl-interpol)
10519        ("iterate" ,sbcl-iterate)
10520        ("symbol-munger" ,sbcl-symbol-munger)
10521        ("closer-mop" ,sbcl-closer-mop)))
10522     (arguments
10523      `(#:asd-system-name "function-cache"
10524        #:asd-file "function-cache.asd"
10525        #:tests? #f))))
10526
10527 (define-public cl-function-cache
10528   (sbcl-package->cl-source-package sbcl-function-cache))
10529
10530 (define-public ecl-function-cache
10531   (sbcl-package->ecl-package sbcl-function-cache))
10532
10533 (define-public sbcl-type-r
10534   (let ((commit "83c89e38f2f7a7b16f1012777ecaf878cfa6a267")
10535         (revision "1"))
10536     (package
10537       (name "sbcl-type-r")
10538       (version (git-version "0.0.0" revision commit))
10539       (source
10540        (origin
10541          (method git-fetch)
10542          (uri (git-reference
10543                (url "https://github.com/guicho271828/type-r.git")
10544                (commit commit)))
10545          (file-name (git-file-name name version))
10546          (sha256
10547           (base32
10548            "1arsxc2539rg8vbrdirz4xxj1b06mc6g6rqndz7a02g127qvk2sm"))))
10549       (build-system asdf-build-system/sbcl)
10550       (synopsis "Parser interface for Common Lisp built-in compound types")
10551       (description
10552        "Collections of accessor functions and patterns to access
10553 the elements in compound type specifier, e.g. @code{dimensions} in
10554 @code{(array element-type dimensions)}")
10555       (home-page "https://github.com/guicho271828/type-r")
10556       (license license:lgpl3+)
10557       (inputs
10558        `(("trivia" ,sbcl-trivia)
10559          ("alexandria" ,sbcl-alexandria)))
10560       (native-inputs
10561        `(("fiveam" ,sbcl-fiveam)))
10562       (arguments
10563        `(#:asd-system-name "type-r"
10564          #:asd-file "type-r.asd"
10565          #:test-asd-file "type-r.test.asd")))))
10566
10567 (define-public cl-type-r
10568   (sbcl-package->cl-source-package sbcl-type-r))
10569
10570 (define-public sbcl-trivialib-type-unify
10571   (let ((commit "62492ebf04db567dcf435ae84c50b7b8202ecf99")
10572         (revision "1"))
10573     (package
10574       (name "sbcl-trivialib-type-unify")
10575       (version (git-version "0.1" revision commit))
10576       (source
10577        (origin
10578          (method git-fetch)
10579          (uri (git-reference
10580                (url "https://github.com/guicho271828/trivialib.type-unify.git")
10581                (commit commit)))
10582          (file-name (git-file-name name version))
10583          (sha256
10584           (base32
10585            "1bkyfzbwv75p50zp8n1n9rh2r29pw3vgz91gmn2gzzkyq3khj1vh"))))
10586       (build-system asdf-build-system/sbcl)
10587       (synopsis "Common Lisp type unification")
10588       (description
10589        "Unifies a parametrized type specifier against an actual type specifier.
10590 Importantly, it handles complicated array-subtypes and number-related types
10591 correctly.")
10592       (home-page "https://github.com/guicho271828/trivialib.type-unify")
10593       (license license:lgpl3+)
10594       (inputs
10595        `(("alexandria" ,sbcl-alexandria)
10596          ("trivia" ,sbcl-trivia)
10597          ("introspect-environment" ,sbcl-introspect-environment)
10598          ("type-r" ,sbcl-type-r)))
10599       (native-inputs
10600        `(("fiveam" ,sbcl-fiveam)))
10601       (arguments
10602        `(#:asd-system-name "trivialib.type-unify"
10603          #:asd-file "trivialib.type-unify.asd"
10604          #:test-asd-file "trivialib.type-unify.test.asd")))))
10605
10606 (define-public cl-trivialib-type-unify
10607   (sbcl-package->cl-source-package sbcl-trivialib-type-unify))
10608
10609 (define-public sbcl-specialized-function
10610   (let ((commit "b96b6afaf8358bf91cc0703e62a5a4ee20d2b7bc")
10611         (revision "1"))
10612     (package
10613       (name "sbcl-specialized-function")
10614       (version (git-version "0.0.0" revision commit))
10615       (source
10616        (origin
10617          (method git-fetch)
10618          (uri (git-reference
10619                (url "https://github.com/numcl/specialized-function.git")
10620                (commit commit)))
10621          (file-name (git-file-name name version))
10622          (sha256
10623           (base32
10624            "12j45ff0n26578vmfbhb9mfbdchw4wy023k0m2ppgl9s0z4bhjaj"))))
10625       (build-system asdf-build-system/sbcl)
10626       (synopsis "Julia-like dispatch for Common Lisp")
10627       (description
10628        "This library is part of NUMCL.  It provides a macro
10629 @code{SPECIALIZED} that performs a Julia-like dispatch on the arguments,
10630 lazily compiling a type-specific version of the function from the same
10631 code.  The main target of this macro is speed.")
10632       (home-page "https://github.com/numcl/specialized-function")
10633       (license license:lgpl3+)
10634       (inputs
10635        `(("trivia" ,sbcl-trivia)
10636          ("alexandria" ,sbcl-alexandria)
10637          ("iterate" ,sbcl-iterate)
10638          ("lisp-namespace" ,sbcl-lisp-namespace)
10639          ("type-r" ,sbcl-type-r)
10640          ("trivial-cltl2" ,sbcl-trivial-cltl2)))
10641       (native-inputs
10642        `(("fiveam" ,sbcl-fiveam)))
10643       (arguments
10644        `(#:asd-system-name "specialized-function"
10645          #:asd-file "specialized-function.asd"
10646          #:test-asd-file "specialized-function.test.asd")))))
10647
10648 (define-public cl-specialized-function
10649   (sbcl-package->cl-source-package sbcl-specialized-function))
10650
10651 (define-public sbcl-constantfold
10652   (let ((commit "0ff1d97a3fbcb89264f6a2af6ce62b73e7b421f4")
10653         (revision "1"))
10654     (package
10655       (name "sbcl-constantfold")
10656       (version (git-version "0.1" revision commit))
10657       (source
10658        (origin
10659          (method git-fetch)
10660          (uri (git-reference
10661                (url "https://github.com/numcl/constantfold.git")
10662                (commit commit)))
10663          (file-name (git-file-name name version))
10664          (sha256
10665           (base32
10666            "153h0569z6bff1qbad0bdssplwwny75l7ilqwcfqfdvzsxf9jh06"))))
10667       (build-system asdf-build-system/sbcl)
10668       (synopsis "Support library for numcl")
10669       (description
10670        "Support library for numcl.  Registers a function as an
10671 additional form that is considered as a candidate for a constant.")
10672       (home-page "https://github.com/numcl/constantfold")
10673       (license license:lgpl3+)
10674       (inputs
10675        `(("trivia" ,sbcl-trivia)
10676          ("alexandria" ,sbcl-alexandria)
10677          ("iterate" ,sbcl-iterate)
10678          ("lisp-namespace" ,sbcl-lisp-namespace)))
10679       (native-inputs
10680        `(("fiveam" ,sbcl-fiveam)))
10681       (arguments
10682        `(#:asd-system-name "constantfold"
10683          #:asd-file "constantfold.asd"
10684          #:test-asd-file "constantfold.test.asd")))))
10685
10686 (define-public cl-constantfold
10687   (sbcl-package->cl-source-package sbcl-constantfold))
10688
10689 (define-public sbcl-gtype
10690   (let ((commit "42275e3606242ae91e9c8dfa30c18ced50a35b66")
10691         (revision "1"))
10692     (package
10693       (name "sbcl-gtype")
10694       (version (git-version "0.1" revision commit))
10695       (source
10696        (origin
10697          (method git-fetch)
10698          (uri (git-reference
10699                (url "https://github.com/numcl/gtype.git")
10700                (commit commit)))
10701          (file-name (git-file-name name version))
10702          (sha256
10703           (base32
10704            "1f56dba998v945jcxhha391557n6md1ql25b7icfwwfivhmlaa9b"))))
10705       (build-system asdf-build-system/sbcl)
10706       (synopsis "C++/Julia-like parametric types in Common Lisp")
10707       (description
10708        "Support library for numcl that provides Julia-like runtime parametric
10709 type correctness in Common Lisp.  It is based on CLtL2 extensions.")
10710       (home-page "https://github.com/numcl/gtype")
10711       (license license:lgpl3+)
10712       (inputs
10713        `(("trivialib.type-unify" ,sbcl-trivialib-type-unify)
10714          ("trivial-cltl2" ,sbcl-trivial-cltl2)
10715          ("trivia" ,sbcl-trivia)
10716          ("alexandria" ,sbcl-alexandria)
10717          ("iterate" ,sbcl-iterate)
10718          ("type-r" ,sbcl-type-r)))
10719       (native-inputs
10720        `(("fiveam" ,sbcl-fiveam)))
10721       (arguments
10722        `(#:asd-system-name "gtype"
10723          #:asd-file "gtype.asd"
10724          #:test-asd-file "gtype.test.asd")))))
10725
10726 (define-public cl-gtype
10727   (sbcl-package->cl-source-package sbcl-gtype))
10728
10729 (define-public sbcl-numcl
10730   (let ((commit "1cf7dfa59f763a24a501092870e9c5ee745d0c17")
10731         (revision "1"))
10732     (package
10733       (name "sbcl-numcl")
10734       (version (git-version "0.1.0" revision commit))
10735       (source
10736        (origin
10737          (method git-fetch)
10738          (uri (git-reference
10739                (url "https://github.com/numcl/numcl.git")
10740                (commit commit)))
10741          (file-name (git-file-name name version))
10742          (sha256
10743           (base32
10744            "0i3jby9hf4ii7blivgyza80g0vmjfhk8537i5i7kqqk0i5sdnym2"))))
10745       (build-system asdf-build-system/sbcl)
10746       (synopsis "Numpy clone in Common Lisp")
10747       (description
10748        "This is a Numpy clone in Common Lisp.  At the moment the
10749 library is written in pure Common Lisp, focusing more on correctness
10750 and usefulness, not speed.  Track the progress at
10751 @url{https://github.com/numcl/numcl/projects/1}.")
10752       (home-page "https://github.com/numcl/numcl")
10753       (license license:lgpl3+)
10754       (inputs
10755        `(("trivia" ,sbcl-trivia)
10756          ("alexandria" ,sbcl-alexandria)
10757          ("iterate" ,sbcl-iterate)
10758          ("lisp-namespace" ,sbcl-lisp-namespace)
10759          ("type-r" ,sbcl-type-r)
10760          ("constantfold" ,sbcl-constantfold)
10761          ("cl-randist" ,sbcl-cl-randist)
10762          ("float-features" ,sbcl-float-features)
10763          ("function-cache" ,sbcl-function-cache)
10764          ("specialized-function" ,sbcl-specialized-function)
10765          ("gtype" ,sbcl-gtype)))
10766       (native-inputs
10767        `(("fiveam" ,sbcl-fiveam)))
10768       (arguments
10769        `(#:asd-system-name "numcl"
10770          #:asd-file "numcl.asd"
10771          #:test-asd-file "numcl.test.asd")))))
10772
10773 (define-public cl-numcl
10774   (sbcl-package->cl-source-package sbcl-numcl))
10775
10776 (define-public sbcl-pzmq
10777   (let ((commit "7c7390eedc469d033c72dc497984d1536ee75826")
10778         (revision "1"))
10779     (package
10780       (name "sbcl-pzmq")
10781       (version (git-version "0.0.0" revision commit))
10782       (source
10783        (origin
10784          (method git-fetch)
10785          (uri (git-reference
10786                (url "https://github.com/orivej/pzmq.git")
10787                (commit commit)))
10788          (file-name (git-file-name name version))
10789          (sha256
10790           (base32 "0gmwzf7h90wa7v4wnk49g0hv2mdalljpwhyigxcb967wzv8lqci9"))))
10791       (build-system asdf-build-system/sbcl)
10792       (native-inputs
10793        `(("bordeaux-threads" ,sbcl-bordeaux-threads)
10794          ("fiveam" ,sbcl-fiveam)
10795          ("let-plus" ,sbcl-let-plus)))
10796       (inputs
10797        `(("cffi" ,sbcl-cffi)
10798          ("cffi-grovel" ,sbcl-cffi-grovel)
10799          ("zeromq" ,zeromq)))
10800       (arguments
10801        `(#:phases (modify-phases %standard-phases
10802                     (add-after 'unpack 'fix-paths
10803                       (lambda* (#:key inputs #:allow-other-keys)
10804                         (substitute* "c-api.lisp"
10805                           (("\"libzmq")
10806                            (string-append "\""
10807                                           (assoc-ref inputs "zeromq")
10808                                           "/lib/libzmq")))
10809                         #t)))))
10810       (synopsis "Common Lisp bindings for the ZeroMQ library")
10811       (description "This Common Lisp library provides bindings for the ZeroMQ
10812 lightweight messaging kernel.")
10813       (home-page "https://github.com/orivej/pzmq")
10814       (license license:unlicense))))
10815
10816 (define-public cl-pzmq
10817   (sbcl-package->cl-source-package sbcl-pzmq))
10818
10819 (define-public ecl-pzmq
10820   (sbcl-package->ecl-package sbcl-pzmq))
10821
10822 (define-public sbcl-clss
10823   (let ((revision "1")
10824         (commit "2a8e8615ab55870d4ca01928f3ed3bbeb4e75c8d"))
10825     (package
10826       (name "sbcl-clss")
10827       (version (git-version "0.3.1" revision commit))
10828       (source
10829        (origin
10830          (method git-fetch)
10831          (uri
10832           (git-reference
10833            (url "https://github.com/Shinmera/clss.git")
10834            (commit commit)))
10835          (sha256
10836           (base32 "0la4dbcda78x29szanylccrsljqrn9d1mhh569sqkyp44ni5fv91"))
10837          (file-name (git-file-name name version))))
10838       (inputs
10839        `(("array-utils" ,sbcl-array-utils)
10840          ("plump" ,sbcl-plump)))
10841       (build-system asdf-build-system/sbcl)
10842       (synopsis "DOM tree searching engine based on CSS selectors")
10843       (description "CLSS is a DOM traversal engine based on CSS
10844 selectors.  It makes use of the Plump-DOM and is used by lQuery.")
10845       (home-page "https://github.com/Shinmera/clss")
10846       (license license:zlib))))
10847
10848 (define-public cl-clss
10849   (sbcl-package->cl-source-package sbcl-clss))
10850
10851 (define-public ecl-clss
10852   (sbcl-package->ecl-package sbcl-clss))
10853
10854 (define-public sbcl-lquery
10855   (let ((revision "1")
10856         (commit "8048111c6b83956daa632e7a3ffbd8c9c203bd8d"))
10857     (package
10858       (name "sbcl-lquery")
10859       (version (git-version "3.2.1" revision commit))
10860       (source
10861        (origin
10862          (method git-fetch)
10863          (uri
10864           (git-reference
10865            (url "https://github.com/Shinmera/lquery.git")
10866            (commit commit)))
10867          (sha256
10868           (base32 "0520mcpxc2d6fdm8z61arpgd2z38kan7cf06qs373n5r64rakz6w"))
10869          (file-name (git-file-name name version))))
10870       (native-inputs
10871        `(("fiveam" ,sbcl-fiveam)))
10872       (inputs
10873        `(("array-utils" ,sbcl-array-utils)
10874          ("form-fiddle" ,sbcl-form-fiddle)
10875          ("plump" ,sbcl-plump)
10876          ("clss" ,sbcl-clss)))
10877       (build-system asdf-build-system/sbcl)
10878       (synopsis "Library to allow jQuery-like HTML/DOM manipulation")
10879       (description "@code{lQuery} is a DOM manipulation library written in
10880 Common Lisp, inspired by and based on the jQuery syntax and
10881 functions.  It uses Plump and CLSS as DOM and selector engines.  The
10882 main idea behind lQuery is to provide a simple interface for crawling
10883 and modifying HTML sites, as well as to allow for an alternative
10884 approach to templating.")
10885       (home-page "https://github.com/Shinmera/lquery")
10886       (license license:zlib))))
10887
10888 (define-public cl-lquery
10889   (sbcl-package->cl-source-package sbcl-lquery))
10890
10891 (define-public ecl-lquery
10892   (sbcl-package->ecl-package sbcl-lquery))
10893
10894 (define-public sbcl-cl-mysql
10895   (let ((commit "ab56c279c1815aec6ca0bfe85164ff7e85cfb6f9")
10896         (revision "1"))
10897     (package
10898       (name "sbcl-cl-mysql")
10899       (version (git-version "0.1" revision commit))
10900       (source
10901        (origin
10902          (method git-fetch)
10903          (uri (git-reference
10904                (url "https://github.com/hackinghat/cl-mysql.git")
10905                (commit commit)))
10906          (file-name (git-file-name name version))
10907          (sha256
10908           (base32 "0dg5ynx2ww94d0qfwrdrm7plkn43h64hs4iiq9mj2s1s4ixnp3lr"))))
10909       (build-system asdf-build-system/sbcl)
10910       (native-inputs
10911        `(("stefil" ,sbcl-stefil)))
10912       (inputs
10913        `(("cffi" ,sbcl-cffi)
10914          ("mariadb-lib" ,mariadb "lib")))
10915       (arguments
10916        `(#:tests? #f ; TODO: Tests require a running server
10917          #:phases
10918          (modify-phases %standard-phases
10919            (add-after 'unpack 'fix-paths
10920              (lambda* (#:key inputs #:allow-other-keys)
10921                (substitute* "system.lisp"
10922                  (("libmysqlclient_r" all)
10923                   (string-append (assoc-ref inputs "mariadb-lib")
10924                                  "/lib/"
10925                                  all)))
10926                #t)))))
10927       (synopsis "Common Lisp wrapper for MySQL")
10928       (description
10929        "@code{cl-mysql} is a Common Lisp implementation of a MySQL wrapper.")
10930       (home-page "http://www.hackinghat.com/index.php/cl-mysql")
10931       (license license:expat))))
10932
10933 (define-public cl-mysql
10934   (sbcl-package->cl-source-package sbcl-cl-mysql))
10935
10936 (define-public sbcl-simple-date
10937   (let ((commit "74469b25bbda990ec9b77e0d0eccdba0cd7e721a")
10938         (revision "1"))
10939     (package
10940       (name "sbcl-simple-date")
10941       (version (git-version "1.19" revision commit))
10942       (source
10943        (origin
10944          (method git-fetch)
10945          (uri (git-reference
10946                (url "https://github.com/marijnh/Postmodern.git")
10947                (commit commit)))
10948          (file-name (git-file-name name version))
10949          (sha256
10950           (base32 "0im7ymnyxjhn2w74jfg76k5gpr0gl33n31akx33hl28722ljd0hd"))))
10951       (build-system asdf-build-system/sbcl)
10952       (native-inputs
10953        `(("fiveam" ,sbcl-fiveam)))
10954       (synopsis "Basic date and time objects for Common Lisp")
10955       (description
10956        "@code{simple-date} is a very basic implementation of date and time
10957 objects, used to support storing and retrieving time-related SQL types.")
10958       (home-page "https://marijnhaverbeke.nl/postmodern/")
10959       (license license:zlib))))
10960
10961 (define-public cl-simple-date
10962   (sbcl-package->cl-source-package sbcl-simple-date))
10963
10964 (define-public ecl-simple-date
10965   (sbcl-package->ecl-package sbcl-simple-date))
10966
10967 (define-public sbcl-cl-postgres
10968   (package
10969     (inherit sbcl-simple-date)
10970     (name "sbcl-cl-postgres")
10971     (native-inputs
10972      `(("fiveam" ,sbcl-fiveam)
10973        ("simple-date" ,sbcl-simple-date)))
10974     (inputs
10975      `(("md5" ,sbcl-md5)
10976        ("split-sequence" ,sbcl-split-sequence)
10977        ("usocket" ,sbcl-usocket)))
10978     (arguments
10979      `(#:tests? #f)) ; TODO: Break simple-date/postgres-glue circular dependency
10980     (synopsis "Common Lisp interface for PostgreSQL")
10981     (description
10982      "@code{cl-postgres} is a low-level library used for interfacing with
10983 a PostgreSQL server over a socket.")))
10984
10985 (define-public cl-postgres
10986   (sbcl-package->cl-source-package sbcl-cl-postgres))
10987
10988 (define-public sbcl-simple-date-postgres-glue
10989   (package
10990     (inherit sbcl-simple-date)
10991     (name "sbcl-simple-date-postgres-glue")
10992     (inputs
10993      `(("cl-postgres" ,sbcl-cl-postgres)
10994        ("simple-date" ,sbcl-simple-date)))
10995     (arguments
10996      `(#:asd-file "simple-date.asd"
10997        #:asd-system-name "simple-date/postgres-glue"))))
10998
10999 (define-public cl-simple-date-postgres-glue
11000   (sbcl-package->cl-source-package sbcl-simple-date-postgres-glue))
11001
11002 (define-public sbcl-s-sql
11003   (package
11004     (inherit sbcl-simple-date)
11005     (name "sbcl-s-sql")
11006     (inputs
11007      `(("alexandria" ,sbcl-alexandria)
11008        ("cl-postgres" ,sbcl-cl-postgres)))
11009     (arguments
11010      `(#:tests? #f)) ; TODO: Break postmodern circular dependency
11011     (synopsis "Lispy DSL for SQL")
11012     (description
11013      "@code{s-sql} is a Common Lisp library that can be used to compile
11014 s-expressions to strings of SQL code, escaping any Lisp values inside, and
11015 doing as much as possible of the work at compile time.")))
11016
11017 (define-public cl-s-sql
11018   (sbcl-package->cl-source-package sbcl-s-sql))
11019
11020 (define-public sbcl-postmodern
11021   (package
11022     (inherit sbcl-simple-date)
11023     (name "sbcl-postmodern")
11024     (native-inputs
11025      `(("fiveam" ,sbcl-fiveam)
11026        ("simple-date" ,sbcl-simple-date)
11027        ("simple-date-postgres-glue" ,sbcl-simple-date-postgres-glue)))
11028     (inputs
11029      `(("alexandria" ,sbcl-alexandria)
11030        ("bordeaux-threads" ,sbcl-bordeaux-threads)
11031        ("cl-postgres" ,sbcl-cl-postgres)
11032        ("closer-mop" ,sbcl-closer-mop)
11033        ("global-vars" ,sbcl-global-vars)
11034        ("s-sql" ,sbcl-s-sql)
11035        ("split-sequence" ,sbcl-split-sequence)))
11036     (arguments
11037      ;; TODO: Fix missing dependency errors for simple-date/postgres-glue,
11038      ;; cl-postgres/tests and s-sql/tests.
11039      `(#:tests? #f))
11040     (synopsis "Common Lisp library for interacting with PostgreSQL")
11041     (description
11042      "@code{postmodern} is a Common Lisp library for interacting with
11043 PostgreSQL databases.  It provides the following features:
11044
11045 @itemize
11046 @item Efficient communication with the database server without need for
11047 foreign libraries.
11048 @item Support for UTF-8 on Unicode-aware Lisp implementations.
11049 @item A syntax for mixing SQL and Lisp code.
11050 @item Convenient support for prepared statements and stored procedures.
11051 @item A metaclass for simple database-access objects.
11052 @end itemize\n")))
11053
11054 (define-public cl-postmodern
11055   (sbcl-package->cl-source-package sbcl-postmodern))
11056
11057 (define-public sbcl-dbi
11058   (package
11059     (name "sbcl-dbi")
11060     (version "0.9.4")
11061     (source
11062      (origin
11063        (method git-fetch)
11064        (uri (git-reference
11065              (url "https://github.com/fukamachi/cl-dbi.git")
11066              (commit version)))
11067        (file-name (git-file-name name version))
11068        (sha256
11069         (base32 "0m1fsravfaizamdak84adh3jxc4j91maqnrb4m08bfbmb04cdqhs"))))
11070     (build-system asdf-build-system/sbcl)
11071     (inputs
11072      `(("bordeaux-threads" ,sbcl-bordeaux-threads)
11073        ("closer-mop" ,sbcl-closer-mop)
11074        ("split-sequence" ,sbcl-split-sequence)))
11075     (arguments
11076      `(#:tests? #f)) ; TODO: Break circular dependency with dbd-*
11077     (synopsis "Database independent interface for Common Lisp")
11078     (description
11079      "@code{dbi} is a Common Lisp library providing a database independent
11080 interface for MySQL, PostgreSQL and SQLite.")
11081     (home-page "https://github.com/fukamachi/cl-dbi")
11082     (license license:llgpl)))
11083
11084 (define-public cl-dbi
11085   (sbcl-package->cl-source-package sbcl-dbi))
11086
11087 (define-public sbcl-dbd-mysql
11088   (package
11089    (inherit sbcl-dbi)
11090    (name "sbcl-dbd-mysql")
11091    (inputs
11092     `(("cl-mysql" ,sbcl-cl-mysql)
11093       ("dbi" ,sbcl-dbi)))
11094    (synopsis "Database driver for MySQL")))
11095
11096 (define-public cl-dbd-mysql
11097   (sbcl-package->cl-source-package sbcl-dbd-mysql))
11098
11099 (define-public sbcl-dbd-postgres
11100   (package
11101    (inherit sbcl-dbi)
11102    (name "sbcl-dbd-postgres")
11103    (inputs
11104     `(("cl-postgres" ,sbcl-cl-postgres)
11105       ("dbi" ,sbcl-dbi)
11106       ("trivial-garbage" ,sbcl-trivial-garbage)))
11107    (synopsis "Database driver for PostgreSQL")))
11108
11109 (define-public cl-dbd-postgres
11110   (sbcl-package->cl-source-package sbcl-dbd-postgres))
11111
11112 (define-public sbcl-dbd-sqlite3
11113   (package
11114    (inherit sbcl-dbi)
11115    (name "sbcl-dbd-sqlite3")
11116    (inputs
11117     `(("cl-sqlite" ,sbcl-cl-sqlite)
11118       ("dbi" ,sbcl-dbi)
11119       ("trivial-garbage" ,sbcl-trivial-garbage)))
11120    (synopsis "Database driver for SQLite3")))
11121
11122 (define-public cl-dbd-sqlite3
11123   (sbcl-package->cl-source-package sbcl-dbd-sqlite3))
11124
11125 (define-public sbcl-uffi
11126   (package
11127     (name "sbcl-uffi")
11128     (version "2.1.2")
11129     (source
11130      (origin
11131        (method git-fetch)
11132        (uri (git-reference
11133              (url "http://git.kpe.io/uffi.git")
11134              (commit (string-append "v" version))))
11135        (file-name (git-file-name name version))
11136        (sha256
11137         (base32 "1hqszvz0a3wk4s9faa83sc3vjxcb5rxmjclyr17yzwg55z733kry"))))
11138     (build-system asdf-build-system/sbcl)
11139     (arguments
11140      `(#:tests? #f ; TODO: Fix use of deprecated ASDF functions
11141        #:phases
11142        (modify-phases %standard-phases
11143          (add-after 'unpack 'fix-permissions
11144            (lambda _
11145              (make-file-writable "doc/html.tar.gz")
11146              #t)))))
11147     (synopsis "Universal foreign function library for Common Lisp")
11148     (description
11149      "UFFI provides a universal foreign function interface (FFI)
11150  for Common Lisp.")
11151     (home-page "http://quickdocs.org/uffi/")
11152     (license license:llgpl)))
11153
11154 (define-public cl-uffi
11155   (package
11156     (inherit (sbcl-package->cl-source-package sbcl-uffi))
11157     (arguments
11158      `(#:phases
11159        ;; asdf-build-system/source has its own phases and does not inherit
11160        ;; from asdf-build-system/sbcl phases.
11161        (modify-phases %standard-phases/source
11162          (add-after 'unpack 'fix-permissions
11163            (lambda _
11164              (make-file-writable "doc/html.tar.gz")
11165              #t)))))))
11166
11167 (define-public sbcl-clsql
11168   (package
11169     (name "sbcl-clsql")
11170     (version "6.7.0")
11171     (source
11172      (origin
11173        (method git-fetch)
11174        (uri (git-reference
11175              (url "http://git.kpe.io/clsql.git")
11176              (commit (string-append "v" version))))
11177        (file-name (git-file-name name version))
11178        (sha256
11179         (base32 "1v1k3s5bsy3lgd9gk459bzpb1r0kdjda25s29samxw4gsgf1fqvp"))
11180        (snippet
11181         '(begin
11182            ;; Remove precompiled libraries.
11183            (delete-file "db-mysql/clsql_mysql.dll")
11184            (delete-file "uffi/clsql_uffi.dll")
11185            (delete-file "uffi/clsql_uffi.lib")
11186            #t))))
11187     (build-system asdf-build-system/sbcl)
11188     (native-inputs
11189      `(("cffi-uffi-compat" ,sbcl-cffi-uffi-compat)
11190        ("rt" ,sbcl-rt)
11191        ("uffi" ,sbcl-uffi)))
11192     (arguments
11193      `(#:phases
11194        (modify-phases %standard-phases
11195          (add-after 'unpack 'fix-permissions
11196            (lambda _
11197              (make-file-writable "doc/html.tar.gz")
11198              #t))
11199          (add-after 'unpack 'fix-tests
11200            (lambda _
11201              (substitute* "clsql.asd"
11202                (("clsql-tests :force t")
11203                 "clsql-tests"))
11204              #t)))))
11205     (synopsis "Common Lisp SQL Interface library")
11206     (description
11207      "@code{clsql} is a Common Lisp interface to SQL RDBMS based on the
11208 Xanalys CommonSQL interface for Lispworks.  It provides low-level database
11209 interfaces as well as a functional and an object oriented interface.")
11210     (home-page "http://clsql.kpe.io/")
11211     (license license:llgpl)))
11212
11213 (define-public cl-clsql
11214   (package
11215     (inherit (sbcl-package->cl-source-package sbcl-clsql))
11216     (native-inputs
11217      `(("rt" ,cl-rt)))
11218     (inputs
11219      `(("mysql" ,mysql)
11220        ("postgresql" ,postgresql)
11221        ("sqlite" ,sqlite)
11222        ("zlib" ,zlib)))
11223     (propagated-inputs
11224      `(("cl-postgres" ,cl-postgres)
11225        ("cffi-uffi-compat" ,cl-cffi-uffi-compat)
11226        ("md5" ,cl-md5)
11227        ("uffi" ,cl-uffi)))
11228     (arguments
11229      `(#:phases
11230        ;; asdf-build-system/source has its own phases and does not inherit
11231        ;; from asdf-build-system/sbcl phases.
11232        (modify-phases %standard-phases/source
11233          (add-after 'unpack 'fix-permissions
11234            (lambda _
11235              (make-file-writable "doc/html.tar.gz")
11236              #t)))))))
11237
11238 (define-public sbcl-clsql-uffi
11239   (package
11240     (inherit sbcl-clsql)
11241     (name "sbcl-clsql-uffi")
11242     (inputs
11243      `(("cffi-uffi-compat" ,sbcl-cffi-uffi-compat)
11244        ("clsql" ,sbcl-clsql)
11245        ("uffi" ,sbcl-uffi)))
11246     (synopsis "UFFI helper functions for Common Lisp SQL interface library")))
11247
11248 (define-public sbcl-clsql-sqlite3
11249   (package
11250     (inherit sbcl-clsql)
11251     (name "sbcl-clsql-sqlite3")
11252     (inputs
11253      `(("clsql" ,sbcl-clsql)
11254        ("clsql-uffi" ,sbcl-clsql-uffi)
11255        ("sqlite" ,sqlite)))
11256     (arguments
11257      (substitute-keyword-arguments (package-arguments sbcl-clsql)
11258        ((#:phases phases '%standard-phases)
11259         `(modify-phases ,phases
11260            (add-after 'unpack 'fix-paths
11261              (lambda* (#:key inputs #:allow-other-keys)
11262                (substitute* "db-sqlite3/sqlite3-loader.lisp"
11263                  (("libsqlite3")
11264                   (string-append (assoc-ref inputs "sqlite")
11265                                  "/lib/libsqlite3")))
11266                #t))))))
11267     (synopsis "SQLite3 driver for Common Lisp SQL interface library")))
11268
11269 (define-public sbcl-clsql-postgresql
11270   (package
11271     (inherit sbcl-clsql)
11272     (name "sbcl-clsql-postgresql")
11273     (inputs
11274      `(("clsql" ,sbcl-clsql)
11275        ("clsql-uffi" ,sbcl-clsql-uffi)
11276        ("postgresql" ,postgresql)))
11277     (arguments
11278      (substitute-keyword-arguments (package-arguments sbcl-clsql)
11279        ((#:phases phases '%standard-phases)
11280         `(modify-phases ,phases
11281            (add-after 'unpack 'fix-paths
11282              (lambda* (#:key inputs #:allow-other-keys)
11283                (substitute* "db-postgresql/postgresql-loader.lisp"
11284                  (("libpq")
11285                   (string-append (assoc-ref inputs "postgresql")
11286                                  "/lib/libpq")))
11287                #t))))))
11288     (synopsis "PostgreSQL driver for Common Lisp SQL interface library")))
11289
11290 (define-public sbcl-clsql-postgresql-socket3
11291   (package
11292     (inherit sbcl-clsql)
11293     (name "sbcl-clsql-postgresql-socket3")
11294     (inputs
11295      `(("cl-postgres" ,sbcl-cl-postgres)
11296        ("clsql" ,sbcl-clsql)
11297        ("md5" ,sbcl-md5)))
11298     (arguments
11299      (substitute-keyword-arguments (package-arguments sbcl-clsql)
11300        ((#:phases phases '%standard-phases)
11301         `(modify-phases ,phases
11302            (add-after 'create-asd-file 'fix-asd-file
11303              (lambda* (#:key outputs #:allow-other-keys)
11304                (let* ((out (assoc-ref outputs "out"))
11305                       (lib (string-append out "/lib/" (%lisp-type)))
11306                       (asd (string-append lib "/clsql-postgresql-socket3.asd")))
11307                  (substitute* asd
11308                    (("CLSQL-POSTGRESQL-SOCKET-SYSTEM::")
11309                     "")))
11310                #t))))))
11311     (synopsis "PostgreSQL driver for Common Lisp SQL interface library")))
11312
11313 (define-public sbcl-clsql-mysql
11314   (package
11315     (inherit sbcl-clsql)
11316     (name "sbcl-clsql-mysql")
11317     (inputs
11318      `(("mysql" ,mysql)
11319        ("sbcl-clsql" ,sbcl-clsql)
11320        ("sbcl-clsql-uffi" ,sbcl-clsql-uffi)
11321        ("zlib" ,zlib)))
11322     (arguments
11323      (substitute-keyword-arguments (package-arguments sbcl-clsql)
11324        ((#:phases phases '%standard-phases)
11325         `(modify-phases ,phases
11326            (add-after 'unpack 'fix-paths
11327              (lambda* (#:key inputs outputs #:allow-other-keys)
11328                (let ((lib (string-append "#p\""
11329                                          (assoc-ref outputs "out")
11330                                          "/lib/\"")))
11331                  (substitute* "clsql-mysql.asd"
11332                    (("#p\"/usr/lib/clsql/clsql_mysql\\.so\"")
11333                     lib))
11334                  (substitute* "db-mysql/mysql-loader.lisp"
11335                    (("libmysqlclient" all)
11336                     (string-append (assoc-ref inputs "mysql") "/lib/" all))
11337                    (("clsql-mysql-system::\\*library-file-dir\\*")
11338                     lib)))
11339                #t))
11340            (add-before 'build 'build-helper-library
11341              (lambda* (#:key inputs outputs #:allow-other-keys)
11342                (let* ((mysql (assoc-ref inputs "mysql"))
11343                       (inc-dir (string-append mysql "/include/mysql"))
11344                       (lib-dir (string-append mysql "/lib"))
11345                       (shared-lib-dir (string-append (assoc-ref outputs "out")
11346                                                      "/lib"))
11347                       (shared-lib (string-append shared-lib-dir
11348                                                  "/clsql_mysql.so")))
11349                  (mkdir-p shared-lib-dir)
11350                  (invoke "gcc" "-fPIC" "-shared"
11351                          "-I" inc-dir
11352                          "db-mysql/clsql_mysql.c"
11353                          "-Wl,-soname=clsql_mysql"
11354                          "-L" lib-dir "-lmysqlclient" "-lz"
11355                          "-o" shared-lib)
11356                  #t)))))))
11357     (synopsis "MySQL driver for Common Lisp SQL interface library")))
11358
11359 (define-public sbcl-sycamore
11360   (let ((commit "fd2820fec165ad514493426dea209728f64e6d18"))
11361     (package
11362       (name "sbcl-sycamore")
11363       (version "0.0.20120604")
11364       (source
11365        (origin
11366          (method git-fetch)
11367          (uri (git-reference
11368                (url "https://github.com/ndantam/sycamore/")
11369                (commit commit)))
11370          (file-name (git-file-name name version))
11371          (sha256
11372           (base32 "00bv1aj89q5vldmq92zp2364jq312zjq2mbd3iyz1s2b4widzhl7"))))
11373       (build-system asdf-build-system/sbcl)
11374       (arguments
11375        `(#:asd-file "src/sycamore.asd"))
11376       (inputs
11377        `(("alexandria" ,sbcl-alexandria)
11378          ("cl-ppcre" ,sbcl-cl-ppcre)))
11379       (synopsis "Purely functional data structure library in Common Lisp")
11380       (description
11381        "Sycamore is a fast, purely functional data structure library in Common Lisp.
11382 If features:
11383
11384 @itemize
11385 @item Fast, purely functional weight-balanced binary trees.
11386 @item Leaf nodes are simple-vectors, greatly reducing tree height.
11387 @item Interfaces for tree Sets and Maps (dictionaries).
11388 @item Ropes.
11389 @item Purely functional pairing heaps.
11390 @item Purely functional amortized queue.
11391 @end itemize\n")
11392       (home-page "http://ndantam.github.io/sycamore/")
11393       (license license:bsd-3))))
11394
11395 (define-public cl-sycamore
11396   (sbcl-package->cl-source-package sbcl-sycamore))
11397
11398 (define-public sbcl-trivial-package-local-nicknames
11399   (package
11400     (name "sbcl-trivial-package-local-nicknames")
11401     (version "0.2")
11402     (home-page "https://github.com/phoe/trivial-package-local-nicknames")
11403     (source
11404      (origin
11405        (method git-fetch)
11406        (uri (git-reference
11407              (url home-page)
11408              (commit "16b7ad4c2b120f50da65154191f468ea5598460e")))
11409        (file-name (git-file-name name version))
11410        (sha256
11411         (base32 "18qc27xkjzdcqrilpk3pm7djldwq5rm3ggd5h9cr8hqcd54i2fqg"))))
11412     (build-system asdf-build-system/sbcl)
11413     (synopsis "Common Lisp compatibility library for package local nicknames")
11414     (description
11415      "This library is a portable compatibility layer around package local nicknames (PLN).
11416 This was done so there is a portability library for the PLN API not included
11417 in DEFPACKAGE.")
11418     (license license:unlicense)))
11419
11420 (define-public cl-trivial-package-local-nicknames
11421   (sbcl-package->cl-source-package sbcl-trivial-package-local-nicknames))
11422
11423 (define-public sbcl-enchant
11424   (let ((commit "6af162a7bf10541cbcfcfa6513894900329713fa"))
11425     (package
11426       (name "sbcl-enchant")
11427       (version (git-version "0.0.0" "1" commit))
11428       (home-page "https://github.com/tlikonen/cl-enchant")
11429       (source
11430        (origin
11431          (method git-fetch)
11432          (uri (git-reference
11433                (url home-page)
11434                (commit commit)))
11435          (file-name (git-file-name name version))
11436          (sha256
11437           (base32 "19yh5ihirzi1d8xqy1cjqipzd6ly3245cfxa5s9xx496rryz0s01"))))
11438       (build-system asdf-build-system/sbcl)
11439       (inputs
11440        `(("enchant" ,enchant)
11441          ("cffi" ,sbcl-cffi)))
11442       (arguments
11443        `(#:phases
11444          (modify-phases %standard-phases
11445            (add-after 'unpack 'fix-paths
11446              (lambda* (#:key inputs #:allow-other-keys)
11447                (substitute* "load-enchant.lisp"
11448                  (("libenchant")
11449                   (string-append
11450                    (assoc-ref inputs "enchant") "/lib/libenchant-2"))))))))
11451       (synopsis "Common Lisp interface for the Enchant spell-checker library")
11452       (description
11453        "Enchant is a Common Lisp interface for the Enchant spell-checker
11454 library.  The Enchant library is a generic spell-checker library which uses
11455 other spell-checkers transparently as back-end.  The library supports the
11456 multiple checkers, including Aspell and Hunspell.")
11457       (license license:public-domain))))
11458
11459 (define-public cl-enchant
11460   (sbcl-package->cl-source-package sbcl-enchant))
11461
11462 (define-public sbcl-cl-change-case
11463   (let ((commit "5ceff2a5f8bd845b6cb510c6364176b27a238fd3"))
11464     (package
11465       (name "sbcl-cl-change-case")
11466       (version (git-version "0.1.0" "1" commit))
11467       (home-page "https://github.com/rudolfochrist/cl-change-case")
11468       (source
11469        (origin
11470          (method git-fetch)
11471          (uri (git-reference
11472                (url home-page)
11473                (commit commit)))
11474          (file-name (git-file-name name version))
11475          (sha256
11476           (base32 "1afyglglk9z3yg8gylcl301bl2r8vq3sllyznzj9s5xi5gs6qyf2"))))
11477       (build-system asdf-build-system/sbcl)
11478       (inputs
11479        `(("cl-ppcre" ,sbcl-cl-ppcre)
11480          ("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)))
11481       (native-inputs
11482        `(("fiveam" ,sbcl-fiveam)))
11483       (arguments
11484        '(;; FIXME: Test pass but phase fails with 'Component
11485          ;; "cl-change-case-test" not found, required by'.
11486          #:tests? #f
11487          #:test-asd-file "cl-change-case-test.asd"))
11488       (synopsis "Convert Common Lisp strings between camelCase, PascalCase and more")
11489       (description
11490        "@code{cl-change-case} is library to convert strings between camelCase,
11491 PascalCase, snake_case, param-case, CONSTANT_CASE and more.")
11492       (license license:llgpl))))
11493
11494 (define-public cl-change-case
11495   (sbcl-package->cl-source-package sbcl-cl-change-case))
11496
11497 (define-public sbcl-moptilities
11498   (let ((commit "a436f16b357c96b82397ec018ea469574c10dd41"))
11499     (package
11500       (name "sbcl-moptilities")
11501       (version (git-version "0.3.13" "1" commit))
11502       (home-page "https://github.com/gwkkwg/moptilities/")
11503       (source
11504        (origin
11505          (method git-fetch)
11506          (uri (git-reference
11507                (url home-page)
11508                (commit commit)))
11509          (file-name (git-file-name name version))
11510          (sha256
11511           (base32 "1q12bqjbj47lx98yim1kfnnhgfhkl80102fkgp9pdqxg0fp6g5fc"))))
11512       (build-system asdf-build-system/sbcl)
11513       (inputs
11514        `(("closer-mop" ,sbcl-closer-mop)))
11515       (native-inputs
11516        `(("lift" ,sbcl-lift)))
11517       (synopsis "Compatibility layer for Common Lisp MOP implementation differences")
11518       (description
11519        "MOP utilities provide a common interface between Lisps and make the
11520 MOP easier to use.")
11521       (license license:expat))))
11522
11523 (define-public cl-moptilities
11524   (sbcl-package->cl-source-package sbcl-moptilities))
11525
11526 (define-public sbcl-osicat
11527   (let ((commit "de0c18a367eedc857e1902a7319828af072a0d97"))
11528     (package
11529       (name "sbcl-osicat")
11530       (version (git-version "0.7.0" "1" commit))
11531       (home-page "http://www.common-lisp.net/project/osicat/")
11532       (source
11533        (origin
11534          (method git-fetch)
11535          (uri (git-reference
11536                (url "https://github.com/osicat/osicat")
11537                (commit commit)))
11538          (file-name (git-file-name name version))
11539          (sha256
11540           (base32 "15viw5pi5sa7qq9b4n2rr3dj2jkqr180rh9z1lh8w3rgl42i2adc"))))
11541       (build-system asdf-build-system/sbcl)
11542       (arguments
11543        `(#:phases
11544          (modify-phases %standard-phases
11545            ;; The cleanup phase moves files around but we need to keep the
11546            ;; directory structure for the grovel-generated library.
11547            (replace 'cleanup
11548              (lambda* (#:key outputs #:allow-other-keys)
11549                (let* ((out (assoc-ref outputs "out"))
11550                       (lib (string-append out "/lib/sbcl/")))
11551                  (delete-file-recursively (string-append lib "src"))
11552                  (delete-file-recursively (string-append lib "tests"))
11553                  (for-each delete-file
11554                            (filter (lambda (file)
11555                                      (not (member (basename file) '("libosicat.so"))))
11556                                    (find-files (string-append lib "posix") ".*"))))
11557                #t)))))
11558       (inputs
11559        `(("alexandria" ,sbcl-alexandria)
11560          ("cffi" ,sbcl-cffi)
11561          ("trivial-features" ,sbcl-trivial-features)))
11562       (native-inputs
11563        `(("cffi-grovel" ,sbcl-cffi-grovel)
11564          ("rt" ,sbcl-rt)))
11565       (synopsis "Operating system interface for Common Lisp")
11566       (description
11567        "Osicat is a lightweight operating system interface for Common Lisp on
11568 Unix-platforms.  It is not a POSIX-style API, but rather a simple lispy
11569 accompaniment to the standard ANSI facilities.")
11570       (license license:expat))))
11571
11572 (define-public cl-osicat
11573   (sbcl-package->cl-source-package sbcl-osicat))