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 Nikita <nikita@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   ;; No release since 2014.
1161   (let ((commit "870d03de0ed44067963350936856e17ee725153e"))
1162     (package
1163       (name "sbcl-trivial-features")
1164       (version (git-version "0.8" "1" commit))
1165       (source
1166        (origin
1167          (method git-fetch)
1168          (uri (git-reference
1169                (url "https://github.com/trivial-features/trivial-features.git")
1170                (commit commit)))
1171          (file-name (git-file-name "trivial-features" version))
1172          (sha256
1173           (base32 "14pcahr8r2j3idhyy216zyw8jnj1dnrx0qbkkbdqkvwzign1ah4j"))))
1174       (build-system asdf-build-system/sbcl)
1175       (arguments '(#:tests? #f))
1176       (home-page "https://cliki.net/trivial-features")
1177       (synopsis "Ensures consistency of @code{*FEATURES*} in Common Lisp")
1178       (description "Trivial-features ensures that @code{*FEATURES*} is
1179 consistent across multiple Common Lisp implementations.")
1180       (license license:expat))))
1181
1182 (define-public cl-trivial-features
1183   (sbcl-package->cl-source-package sbcl-trivial-features))
1184
1185 (define-public ecl-trivial-features
1186   (sbcl-package->ecl-package sbcl-trivial-features))
1187
1188 (define-public sbcl-hu.dwim.asdf
1189   (package
1190     (name "sbcl-hu.dwim.asdf")
1191     (version "20190521")
1192     (source
1193      (origin
1194        (method url-fetch)
1195        (uri (string-append "http://beta.quicklisp.org/archive/hu.dwim.asdf/"
1196                            "2019-05-21/hu.dwim.asdf-" version "-darcs.tgz"))
1197        (sha256
1198         (base32
1199          "0rsbv71vyszy8w35yjwb5h6zcmknjq223hkzir79y72qdsc6sabn"))))
1200     (build-system asdf-build-system/sbcl)
1201     (home-page "https://hub.darcs.net/hu.dwim/hu.dwim.asdf")
1202     (synopsis "Extensions to ASDF")
1203     (description "Various ASDF extensions such as attached test and
1204 documentation system, explicit development support, etc.")
1205     (license license:public-domain)))
1206
1207 (define-public cl-hu.dwim.asdf
1208   (sbcl-package->cl-source-package sbcl-hu.dwim.asdf))
1209
1210 (define-public ecl-hu.dwim.asdf
1211   (sbcl-package->ecl-package sbcl-hu.dwim.asdf))
1212
1213 (define-public sbcl-hu.dwim.stefil
1214   (let ((commit "ab6d1aa8995878a1b66d745dfd0ba021090bbcf9"))
1215     (package
1216       (name "sbcl-hu.dwim.stefil")
1217       (version (git-version "0.0.0" "1" commit))
1218       (source
1219        (origin
1220          (method git-fetch)
1221          (uri
1222           (git-reference
1223            (url "https://gitlab.common-lisp.net/xcvb/hu.dwim.stefil.git")
1224            (commit commit)))
1225          (sha256
1226           (base32 "1d8yccw65zj3zh46cbi3x6nmn1dwdb76s9d0av035077mvyirqqp"))
1227          (file-name (git-file-name "hu.dwim.stefil" version))))
1228       (build-system asdf-build-system/sbcl)
1229       (native-inputs
1230        `(("asdf:cl-hu.dwim.asdf" ,sbcl-hu.dwim.asdf)))
1231       (inputs
1232        `(("sbcl-alexandria" ,sbcl-alexandria)))
1233       (home-page "https://hub.darcs.net/hu.dwim/hu.dwim.stefil")
1234       (synopsis "Simple test framework")
1235       (description "Stefil is a simple test framework for Common Lisp,
1236 with a focus on interactive development.")
1237       (license license:public-domain))))
1238
1239 (define-public cl-hu.dwim.stefil
1240   (sbcl-package->cl-source-package sbcl-hu.dwim.stefil))
1241
1242 (define-public ecl-hu.dwim.stefil
1243   (sbcl-package->ecl-package sbcl-hu.dwim.stefil))
1244
1245 (define-public sbcl-babel
1246   ;; No release since 2014.
1247   (let ((commit "aeed2d1b76358db48e6b70a64399c05678a6b9ea"))
1248     (package
1249       (name "sbcl-babel")
1250       (version (git-version "0.5.0" "1" commit))
1251       (source
1252        (origin
1253          (method git-fetch)
1254          (uri (git-reference
1255                (url "https://github.com/cl-babel/babel.git")
1256                (commit commit)))
1257          (file-name (git-file-name "babel" version))
1258          (sha256
1259           (base32 "0lkvv4xdpv4cv1y2bqillmabx8sdb2y4l6pbinq6mjh33w2brpvb"))))
1260       (build-system asdf-build-system/sbcl)
1261       (native-inputs
1262        `(("tests:cl-hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
1263       (inputs
1264        `(("sbcl-alexandria" ,sbcl-alexandria)
1265          ("sbcl-trivial-features" ,sbcl-trivial-features)))
1266       (home-page "https://common-lisp.net/project/babel/")
1267       (synopsis "Charset encoding and decoding library")
1268       (description "Babel is a charset encoding and decoding library, not unlike
1269 GNU libiconv, but completely written in Common Lisp.")
1270       (license license:expat))))
1271
1272 (define-public cl-babel
1273   (sbcl-package->cl-source-package sbcl-babel))
1274
1275 (define-public ecl-babel
1276   (sbcl-package->ecl-package sbcl-babel))
1277
1278 (define-public sbcl-cl-yacc
1279   (package
1280     (name "sbcl-cl-yacc")
1281     (version "0.3")
1282     (source
1283      (origin
1284        (method git-fetch)
1285        (uri (git-reference
1286              (url "https://github.com/jech/cl-yacc")
1287              (commit (string-append "cl-yacc-" version))))
1288        (sha256
1289         (base32
1290          "16946pzf8vvadnyfayvj8rbh4zjzw90h0azz2qk1mxrvhh5wklib"))
1291        (file-name (string-append "cl-yacc-" version "-checkout"))))
1292     (build-system asdf-build-system/sbcl)
1293     (arguments
1294      `(#:asd-file "yacc.asd"
1295        #:asd-system-name "yacc"))
1296     (synopsis "LALR(1) parser generator for Common Lisp, similar in spirit to Yacc")
1297     (description
1298      "CL-Yacc is a LALR(1) parser generator for Common Lisp, similar in spirit
1299 to AT&T Yacc, Berkeley Yacc, GNU Bison, Zebu, lalr.cl or lalr.scm.
1300
1301 CL-Yacc uses the algorithm due to Aho and Ullman, which is the one also used
1302 by AT&T Yacc, Berkeley Yacc and Zebu.  It does not use the faster algorithm due
1303 to DeRemer and Pennello, which is used by Bison and lalr.scm (not lalr.cl).")
1304     (home-page "https://www.irif.fr/~jch//software/cl-yacc/")
1305     (license license:expat)))
1306
1307 (define-public cl-yacc
1308   (sbcl-package->cl-source-package sbcl-cl-yacc))
1309
1310 (define-public ecl-cl-yacc
1311   (sbcl-package->ecl-package sbcl-cl-yacc))
1312
1313 (define-public sbcl-jpl-util
1314   (let ((commit "0311ed374e19a49d43318064d729fe3abd9a3b62"))
1315     (package
1316       (name "sbcl-jpl-util")
1317       (version "20151005")
1318       (source
1319        (origin
1320          (method git-fetch)
1321          (uri (git-reference
1322                ;; Quicklisp uses this fork.
1323                (url "https://github.com/hawkir/cl-jpl-util")
1324                (commit commit)))
1325          (file-name
1326           (git-file-name "jpl-util" version))
1327          (sha256
1328           (base32
1329            "0nc0rk9n8grkg3045xsw34whmcmddn2sfrxki4268g7kpgz0d2yz"))))
1330       (build-system asdf-build-system/sbcl)
1331       (synopsis "Collection of Common Lisp utility functions and macros")
1332       (description
1333        "@command{cl-jpl-util} is a collection of Common Lisp utility functions
1334 and macros, primarily for software projects written in CL by the author.")
1335       (home-page "https://www.thoughtcrime.us/software/cl-jpl-util/")
1336       (license license:isc))))
1337
1338 (define-public cl-jpl-util
1339   (sbcl-package->cl-source-package sbcl-jpl-util))
1340
1341 (define-public ecl-jpl-util
1342   (sbcl-package->ecl-package sbcl-jpl-util))
1343
1344 (define-public sbcl-jpl-queues
1345   (package
1346     (name "sbcl-jpl-queues")
1347     (version "0.1")
1348     (source
1349      (origin
1350        (method url-fetch)
1351        (uri (string-append
1352              "http://www.thoughtcrime.us/software/jpl-queues/jpl-queues-"
1353              version
1354              ".tar.gz"))
1355        (sha256
1356         (base32
1357          "1wvvv7j117h9a42qaj1g4fh4mji28xqs7s60rn6d11gk9jl76h96"))))
1358     (build-system asdf-build-system/sbcl)
1359     (inputs
1360      `(("jpl-util" ,sbcl-jpl-util)
1361        ("bordeaux-threads" ,sbcl-bordeaux-threads)))
1362     (arguments
1363      ;; Tests seem to be broken.
1364      `(#:tests? #f))
1365     (synopsis "Common Lisp library implementing a few different kinds of queues")
1366     (description
1367      "A Common Lisp library implementing a few different kinds of queues:
1368
1369 @itemize
1370 @item Bounded and unbounded FIFO queues.
1371 @item Lossy bounded FIFO queues that drop elements when full.
1372 @item Unbounded random-order queues that use less memory than unbounded FIFO queues.
1373 @end itemize
1374
1375 Additionally, a synchronization wrapper is provided to make any queue
1376 conforming to the @command{jpl-queues} API thread-safe for lightweight
1377 multithreading applications.  (See Calispel for a more sophisticated CL
1378 multithreaded message-passing library with timeouts and alternation among
1379 several blockable channels.)")
1380     (home-page "https://www.thoughtcrime.us/software/jpl-queues/")
1381     (license license:isc)))
1382
1383 (define-public cl-jpl-queues
1384   (sbcl-package->cl-source-package sbcl-jpl-queues))
1385
1386 (define-public ecl-jpl-queues
1387   (sbcl-package->ecl-package sbcl-jpl-queues))
1388
1389 (define-public sbcl-eos
1390   (let ((commit "b0faca83781ead9a588661e37bd47f90362ccd94"))
1391     (package
1392       (name "sbcl-eos")
1393       (version (git-version "0.0.0" "1" commit))
1394       (source
1395        (origin
1396          (method git-fetch)
1397          (uri (git-reference
1398                (url "https://github.com/adlai/Eos")
1399                (commit commit)))
1400          (sha256
1401           (base32
1402            "1bq8cfg087iyxmxi1mwgx5cfgy3b8ydrf81xljcis8qbgb2vszph"))
1403          (file-name (git-file-name "eos" version))))
1404       (build-system asdf-build-system/sbcl)
1405       (synopsis "Unit Testing for Common Lisp")
1406       (description
1407        "Eos was a unit testing library for Common Lisp.
1408 It began as a fork of FiveAM; however, FiveAM development has continued, while
1409 that of Eos has not.  Thus, Eos is now deprecated in favor of FiveAM.")
1410       (home-page "https://github.com/adlai/Eos")
1411       (license license:expat))))
1412
1413 (define-public cl-eos
1414   (sbcl-package->cl-source-package sbcl-eos))
1415
1416 (define-public ecl-eos
1417   (sbcl-package->ecl-package sbcl-eos))
1418
1419 (define-public sbcl-esrap
1420   (let ((commit "133be8b05c2aae48696fe5b739eea2fa573fa48d"))
1421     (package
1422       (name "sbcl-esrap")
1423       (version (git-version "0.0.0" "1" commit))
1424       (source
1425        (origin
1426          (method git-fetch)
1427          (uri (git-reference
1428                (url "https://github.com/nikodemus/esrap")
1429                (commit commit)))
1430          (sha256
1431           (base32
1432            "02d5clihsdryhf7pix8c5di2571fdsffh75d40fkzhws90r5mksl"))
1433          (file-name (git-file-name "esrap" version))))
1434       (build-system asdf-build-system/sbcl)
1435       (native-inputs
1436        `(("eos" ,sbcl-eos)))            ;For testing only.
1437       (inputs
1438        `(("alexandria" ,sbcl-alexandria)))
1439       (synopsis "Common Lisp packrat parser")
1440       (description
1441        "A packrat parser for Common Lisp.
1442 In addition to regular Packrat / Parsing Grammar / TDPL features ESRAP supports:
1443
1444 @itemize
1445 @item dynamic redefinition of nonterminals
1446 @item inline grammars
1447 @item semantic predicates
1448 @item introspective facilities (describing grammars, tracing, setting breaks)
1449 @end itemize\n")
1450       (home-page "https://nikodemus.github.io/esrap/")
1451       (license license:expat))))
1452
1453 (define-public cl-esrap
1454   (sbcl-package->cl-source-package sbcl-esrap))
1455
1456 (define-public ecl-esrap
1457   (sbcl-package->ecl-package sbcl-esrap))
1458
1459 (define-public sbcl-split-sequence
1460   (package
1461     (name "sbcl-split-sequence")
1462     (version "2.0.0")
1463     (source
1464      (origin
1465        (method git-fetch)
1466        (uri (git-reference
1467              (url "https://github.com/sharplispers/split-sequence")
1468              (commit (string-append "v" version))))
1469        (sha256
1470         (base32
1471          "0jcpnx21hkfwqj5fvp7kc6pn1qcz9hk7g2s5x8h0349x1j2irln0"))
1472        (file-name (git-file-name "split-sequence" version))))
1473     (build-system asdf-build-system/sbcl)
1474     (native-inputs
1475      `(("fiveam" ,sbcl-fiveam)))
1476     (synopsis "Member of the Common Lisp Utilities family of programs")
1477     (description
1478      "Splits sequence into a list of subsequences delimited by objects
1479 satisfying the test.")
1480     (home-page "https://cliki.net/split-sequence")
1481     (license license:expat)))
1482
1483 (define-public cl-split-sequence
1484   (sbcl-package->cl-source-package sbcl-split-sequence))
1485
1486 (define-public ecl-split-sequence
1487   (sbcl-package->ecl-package sbcl-split-sequence))
1488
1489 (define-public sbcl-html-encode
1490   (package
1491     (name "sbcl-html-encode")
1492     (version "1.2")
1493     (source
1494      (origin
1495        (method url-fetch)
1496        (uri (string-append
1497              "http://beta.quicklisp.org/archive/html-encode/2010-10-06/html-encode-"
1498              version ".tgz"))
1499        (sha256
1500         (base32
1501          "06mf8wn95yf5swhmzk4vp0xr4ylfl33dgfknkabbkd8n6jns8gcf"))
1502        (file-name (string-append "colorize" version "-checkout"))))
1503     (build-system asdf-build-system/sbcl)
1504     (synopsis "Common Lisp library for encoding text in various web-savvy encodings")
1505     (description
1506      "A library for encoding text in various web-savvy encodings.")
1507     (home-page "http://quickdocs.org/html-encode/")
1508     (license license:expat)))
1509
1510 (define-public cl-html-encode
1511   (sbcl-package->cl-source-package sbcl-html-encode))
1512
1513 (define-public ecl-html-encode
1514   (sbcl-package->ecl-package sbcl-html-encode))
1515
1516 (define-public sbcl-colorize
1517   (let ((commit "ea676b584e0899cec82f21a9e6871172fe3c0eb5"))
1518     (package
1519       (name "sbcl-colorize")
1520       (version (git-version "0.0.0" "1" commit))
1521       (source
1522        (origin
1523          (method git-fetch)
1524          (uri (git-reference
1525                (url "https://github.com/kingcons/colorize")
1526                (commit commit)))
1527          (sha256
1528           (base32
1529            "1pdg4kiaczmr3ivffhirp7m3lbr1q27rn7dhaay0vwghmi31zcw9"))
1530          (file-name (git-file-name "colorize" version))))
1531       (build-system asdf-build-system/sbcl)
1532       (inputs
1533        `(("alexandria" ,sbcl-alexandria)
1534          ("split-sequence" ,sbcl-split-sequence)
1535          ("html-encode" ,sbcl-html-encode)))
1536       (synopsis "Common Lisp for syntax highlighting")
1537       (description
1538        "@command{colorize} is a Lisp library for syntax highlighting
1539 supporting the following languages: Common Lisp, Emacs Lisp, Scheme, Clojure,
1540 C, C++, Java, Python, Erlang, Haskell, Objective-C, Diff, Webkit.")
1541       (home-page "https://github.com/kingcons/colorize")
1542       ;; TODO: Missing license?
1543       (license license:expat))))
1544
1545 (define-public cl-colorize
1546   (sbcl-package->cl-source-package sbcl-colorize))
1547
1548 (define-public ecl-colorize
1549   (sbcl-package->ecl-package sbcl-colorize))
1550
1551 (define-public sbcl-3bmd
1552   (let ((commit "192ea13435b605a96ef607df51317056914cabbd"))
1553     (package
1554       (name "sbcl-3bmd")
1555       (version (git-version "0.0.0" "1" commit))
1556       (source
1557        (origin
1558          (method git-fetch)
1559          (uri (git-reference
1560                (url "https://github.com/3b/3bmd")
1561                (commit commit)))
1562          (sha256
1563           (base32
1564            "1rgv3gi7wf963ikmmpk132wgn0icddf226gq3bmcnk1fr3v9gf2f"))
1565          (file-name (git-file-name "3bmd" version))))
1566       (build-system asdf-build-system/sbcl)
1567       (arguments
1568        ;; FIXME: We need to specify the name because the build-system thinks
1569        ;; "3" is a version marker.
1570        `(#:asd-system-name "3bmd"))
1571       (inputs
1572        `(("esrap" ,sbcl-esrap)
1573          ("split-sequence" ,sbcl-split-sequence)))
1574       (synopsis "Markdown processor in Command Lisp using esrap parser")
1575       (description
1576        "Common Lisp Markdown -> HTML converter, using @command{esrap} for
1577 parsing, and grammar based on @command{peg-markdown}.")
1578       (home-page "https://github.com/3b/3bmd")
1579       (license license:expat))))
1580
1581 (define-public cl-3bmd
1582   (sbcl-package->cl-source-package sbcl-3bmd))
1583
1584 (define-public ecl-3bmd
1585   (sbcl-package->ecl-package sbcl-3bmd))
1586
1587 (define-public sbcl-3bmd-ext-code-blocks
1588   (let ((commit "192ea13435b605a96ef607df51317056914cabbd"))
1589     (package
1590       (inherit sbcl-3bmd)
1591       (name "sbcl-3bmd-ext-code-blocks")
1592       (arguments
1593        `(#:asd-system-name "3bmd-ext-code-blocks"
1594          #:asd-file "3bmd-ext-code-blocks.asd"))
1595       (inputs
1596        `(("3bmd" ,sbcl-3bmd)
1597          ("colorize" ,sbcl-colorize)))
1598       (synopsis "3bmd extension which adds support for GitHub-style fenced
1599 code blocks")
1600       (description
1601        "3bmd extension which adds support for GitHub-style fenced code blocks,
1602 with @command{colorize} support."))))
1603
1604 (define-public cl-3bmd-ext-code-blocks
1605   (sbcl-package->cl-source-package sbcl-3bmd-ext-code-blocks))
1606
1607 (define-public ecl-3bmd-ext-code-blocks
1608   (sbcl-package->ecl-package sbcl-3bmd-ext-code-blocks))
1609
1610 (define-public sbcl-cl-fad
1611   (package
1612     (name "sbcl-cl-fad")
1613     (version "0.7.6")
1614     (source
1615      (origin
1616        (method git-fetch)
1617        (uri (git-reference
1618              (url "https://github.com/edicl/cl-fad/")
1619              (commit (string-append "v" version))))
1620        (sha256
1621         (base32
1622          "1gc8i82v6gks7g0lnm54r4prk2mklidv2flm5fvbr0a7rsys0vpa"))
1623        (file-name (string-append "cl-fad" version "-checkout"))))
1624     (build-system asdf-build-system/sbcl)
1625     (inputs
1626      `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
1627     (synopsis "Portable pathname library for Common Lisp")
1628     (description
1629      "CL-FAD (for \"Files and Directories\") is a thin layer atop Common
1630 Lisp's standard pathname functions.  It is intended to provide some
1631 unification between current CL implementations on Windows, OS X, Linux, and
1632 Unix.  Most of the code was written by Peter Seibel for his book Practical
1633 Common Lisp.")
1634     (home-page "https://edicl.github.io/cl-fad/")
1635     (license license:bsd-2)))
1636
1637 (define-public cl-fad
1638   (sbcl-package->cl-source-package sbcl-cl-fad))
1639
1640 (define-public ecl-cl-fad
1641   (sbcl-package->ecl-package sbcl-cl-fad))
1642
1643 (define-public sbcl-rt
1644   (let ((commit "a6a7503a0b47953bc7579c90f02a6dba1f6e4c5a")
1645         (revision "1"))
1646     (package
1647       (name "sbcl-rt")
1648       (version (git-version "1990.12.19" revision commit))
1649       (source
1650        (origin
1651          (method git-fetch)
1652          (uri (git-reference
1653                (url "http://git.kpe.io/rt.git")
1654                (commit commit)))
1655          (file-name (git-file-name name version))
1656          (sha256
1657           (base32 "13si2rrxaagbr0bkvg6sqicxxpyshabx6ad6byc9n2ik5ysna69b"))))
1658       (build-system asdf-build-system/sbcl)
1659       (synopsis "MIT Regression Tester")
1660       (description
1661        "RT provides a framework for writing regression test suites.")
1662       (home-page "https://www.cliki.net/rt")
1663       (license license:expat))))
1664
1665 (define-public cl-rt
1666   (sbcl-package->cl-source-package sbcl-rt))
1667
1668 (define-public ecl-rt
1669   (sbcl-package->ecl-package sbcl-rt))
1670
1671 (define-public sbcl-nibbles
1672   (package
1673     (name "sbcl-nibbles")
1674     (version "0.14")
1675     (source
1676      (origin
1677        (method git-fetch)
1678        (uri (git-reference
1679              (url "https://github.com/sharplispers/nibbles/")
1680              (commit (string-append "v" version))))
1681        (sha256
1682         (base32
1683          "1v7qfgpvdr6nz7v63dj69d26dis0kff3rd8xamr1llfdvza2pm8f"))
1684        (file-name (git-file-name "nibbles" version))))
1685     (build-system asdf-build-system/sbcl)
1686     (native-inputs
1687      ;; Tests only.
1688      `(("rt" ,sbcl-rt)))
1689     (synopsis "Common Lisp library for accessing octet-addressed blocks of data")
1690     (description
1691      "When dealing with network protocols and file formats, it's common to
1692 have to read or write 16-, 32-, or 64-bit datatypes in signed or unsigned
1693 flavors.  Common Lisp sort of supports this by specifying :element-type for
1694 streams, but that facility is underspecified and there's nothing similar for
1695 read/write from octet vectors.  What most people wind up doing is rolling their
1696 own small facility for their particular needs and calling it a day.
1697
1698 This library attempts to be comprehensive and centralize such
1699 facilities.  Functions to read 16-, 32-, and 64-bit quantities from octet
1700 vectors in signed or unsigned flavors are provided; these functions are also
1701 SETFable.  Since it's sometimes desirable to read/write directly from streams,
1702 functions for doing so are also provided.  On some implementations,
1703 reading/writing IEEE singles/doubles (i.e. single-float and double-float) will
1704 also be supported.")
1705     (home-page "https://github.com/sharplispers/nibbles")
1706     (license license:bsd-3)))
1707
1708 (define-public cl-nibbles
1709   (sbcl-package->cl-source-package sbcl-nibbles))
1710
1711 (define-public ecl-nibbles
1712   (sbcl-package->ecl-package sbcl-nibbles))
1713
1714 (define-public sbcl-ironclad
1715   (package
1716     (name "sbcl-ironclad")
1717     (version "0.49")
1718     (source
1719      (origin
1720        (method git-fetch)
1721        (uri (git-reference
1722              (url "https://github.com/sharplispers/ironclad/")
1723              (commit (string-append "v" version))))
1724        (sha256
1725         (base32 "0kbzqg2aasrhjwy3nrzy2ddy809n1j045w4qkyc3r2syqd203d4q"))
1726        (file-name (git-file-name name version))))
1727     (build-system asdf-build-system/sbcl)
1728     (native-inputs
1729      ;; Tests only.
1730      `(("rt" ,sbcl-rt)))
1731     (inputs
1732      `(("bordeaux-threads" ,sbcl-bordeaux-threads)
1733        ("flexi-streams" ,sbcl-flexi-streams)
1734        ("trivial-garbage" ,sbcl-trivial-garbage)))
1735     (synopsis "Cryptographic toolkit written in Common Lisp")
1736     (description
1737      "Ironclad is a cryptography library written entirely in Common Lisp.
1738 It includes support for several popular ciphers, digests, MACs and public key
1739 cryptography algorithms.  For several implementations that support Gray
1740 streams, support is included for convenient stream wrappers.")
1741     (home-page "https://github.com/sharplispers/ironclad")
1742     (license license:bsd-3)))
1743
1744 (define-public cl-ironclad
1745   (sbcl-package->cl-source-package sbcl-ironclad))
1746
1747 (define-public ecl-ironclad
1748   (sbcl-package->ecl-package sbcl-ironclad))
1749
1750 (define-public sbcl-named-readtables
1751   (let ((commit "64bd53f37a1694cfde48fc38b8f03901f6f0c05b")
1752         (revision "2"))
1753     (package
1754       (name "sbcl-named-readtables")
1755       (version (git-version "0.9" revision commit))
1756       (source
1757        (origin
1758          (method git-fetch)
1759          (uri (git-reference
1760                (url "https://github.com/melisgl/named-readtables.git")
1761                (commit commit)))
1762          (sha256
1763           (base32 "01l4831m7k84qvhzyx0qgdl50isr4zmp40qf6dfq2iqcaj8y4h3n"))
1764          (file-name (git-file-name "named-readtables" version))))
1765       (build-system asdf-build-system/sbcl)
1766       (arguments
1767        ;; Tests seem to be broken.
1768        `(#:tests? #f))
1769       (home-page "https://github.com/melisgl/named-readtables/")
1770       (synopsis "Library that creates a namespace for named readtables")
1771       (description "Named readtables is a library that creates a namespace for
1772 named readtables, which is akin to package namespacing in Common Lisp.")
1773       (license license:bsd-3))))
1774
1775 (define-public cl-named-readtables
1776   (sbcl-package->cl-source-package sbcl-named-readtables))
1777
1778 (define-public ecl-named-readtables
1779   (sbcl-package->ecl-package sbcl-named-readtables))
1780
1781 (define-public sbcl-pythonic-string-reader
1782   (let ((commit "47a70ba1e32362e03dad6ef8e6f36180b560f86a"))
1783     (package
1784       (name "sbcl-pythonic-string-reader")
1785       (version (git-version "0.0.0" "1" commit))
1786       (source
1787        (origin
1788          (method git-fetch)
1789          (uri (git-reference
1790                (url "https://github.com/smithzvk/pythonic-string-reader/")
1791                (commit commit)))
1792          (sha256
1793           (base32 "1b5iryqw8xsh36swckmz8rrngmc39k92si33fgy5pml3n9l5rq3j"))
1794          (file-name (git-file-name "pythonic-string-reader" version))))
1795       (build-system asdf-build-system/sbcl)
1796       (inputs
1797        `(("named-readtables" ,sbcl-named-readtables)))
1798       (home-page "https://github.com/smithzvk/pythonic-string-reader")
1799       (synopsis "Read table modification inspired by Python's three quote strings")
1800       (description "This piece of code sets up some reader macros that make it
1801 simpler to input string literals which contain backslashes and double quotes
1802 This is very useful for writing complicated docstrings and, as it turns out,
1803 writing code that contains string literals that contain code themselves.")
1804       (license license:bsd-3))))
1805
1806 (define-public cl-pythonic-string-reader
1807   (sbcl-package->cl-source-package sbcl-pythonic-string-reader))
1808
1809 (define-public ecl-pythonic-string-reader
1810   (sbcl-package->ecl-package sbcl-pythonic-string-reader))
1811
1812 ;; SLIME does not have a ASDF system definition to build all of Swank.  As a
1813 ;; result, the asdf-build-system/sbcl will produce an almost empty package.
1814 ;; Some work was done to fix this at
1815 ;; https://github.com/sionescu/slime/tree/swank-asdf but it was never merged
1816 ;; and is now lagging behind.  Building SBCL fasls might not be worth the
1817 ;; hassle, so let's just ship the source then.
1818 (define-public cl-slime-swank
1819   (package
1820     (name "cl-slime-swank")
1821     (version "2.24")
1822     (source
1823      (origin
1824        (file-name (string-append name "-" version ".tar.gz"))
1825        (method git-fetch)
1826        (uri (git-reference
1827              (url "https://github.com/slime/slime/")
1828              (commit (string-append "v" version))))
1829        (sha256
1830         (base32
1831          "0js24x42m7b5iymb4rxz501dff19vav5pywnzv50b673rbkaaqvh"))))
1832     (build-system asdf-build-system/source)
1833     (home-page "https://github.com/slime/slime")
1834     (synopsis "Common Lisp Swank server")
1835     (description
1836      "This is only useful if you want to start a Swank server in a Lisp
1837 processes that doesn't run under Emacs.  Lisp processes created by
1838 @command{M-x slime} automatically start the server.")
1839     (license (list license:gpl2+ license:public-domain))))
1840
1841 (define-public sbcl-slime-swank
1842   (deprecated-package "sbcl-slime-swank" cl-slime-swank))
1843
1844 (define-public sbcl-mgl-pax
1845   (let ((commit "818448418d6b9de74620f606f5b23033c6082769"))
1846     (package
1847       (name "sbcl-mgl-pax")
1848       (version (git-version "0.0.0" "1" commit))
1849       (source
1850        (origin
1851          (method git-fetch)
1852          (uri (git-reference
1853                (url "https://github.com/melisgl/mgl-pax")
1854                (commit commit)))
1855          (sha256
1856           (base32
1857            "1p97zfkh130bdxqqxwaw2j9psv58751wakx7czbfpq410lg7dd7i"))
1858          (file-name (git-file-name "mgl-pax" version))))
1859       (build-system asdf-build-system/sbcl)
1860       (inputs
1861        `(("3bmd" ,sbcl-3bmd)
1862          ("3bmd-ext-code-blocks" ,sbcl-3bmd-ext-code-blocks)
1863          ("babel" ,sbcl-babel)
1864          ("cl-fad" ,sbcl-cl-fad)
1865          ("ironclad" ,sbcl-ironclad)
1866          ("named-readtables" ,sbcl-named-readtables)
1867          ("pythonic-string-reader" ,sbcl-pythonic-string-reader)))
1868       (propagated-inputs
1869        ;; Packages having mgl-pax as input complain that it can't find
1870        ;; swank if we put it in inputs, so let's put it in propageted-inputs.
1871        `(("swank" ,cl-slime-swank)))
1872       (synopsis "Exploratory programming environment and documentation generator")
1873       (description
1874        "PAX provides an extremely poor man's Explorable Programming
1875 environment.  Narrative primarily lives in so called sections that mix markdown
1876 docstrings with references to functions, variables, etc, all of which should
1877 probably have their own docstrings.
1878
1879 The primary focus is on making code easily explorable by using SLIME's
1880 @command{M-.} (@command{slime-edit-definition}).  See how to enable some
1881 fanciness in Emacs Integration.  Generating documentation from sections and all
1882 the referenced items in Markdown or HTML format is also implemented.
1883
1884 With the simplistic tools provided, one may accomplish similar effects as with
1885 Literate Programming, but documentation is generated from code, not vice versa
1886 and there is no support for chunking yet.  Code is first, code must look
1887 pretty, documentation is code.")
1888       (home-page "http://quotenil.com/")
1889       (license license:expat))))
1890
1891 (define-public cl-mgl-pax
1892   (sbcl-package->cl-source-package sbcl-mgl-pax))
1893
1894 (define-public ecl-mgl-pax
1895   (sbcl-package->ecl-package sbcl-mgl-pax))
1896
1897 (define-public sbcl-lisp-unit
1898   (let ((commit "89653a232626b67400bf9a941f9b367da38d3815"))
1899     (package
1900       (name "sbcl-lisp-unit")
1901       (version (git-version "0.0.0" "1" commit))
1902       (source
1903        (origin
1904          (method git-fetch)
1905          (uri (git-reference
1906                (url "https://github.com/OdonataResearchLLC/lisp-unit")
1907                (commit commit)))
1908          (sha256
1909           (base32
1910            "0p6gdmgr7p383nvd66c9y9fp2bjk4jx1lpa5p09g43hr9y9pp9ry"))
1911          (file-name (git-file-name "lisp-unit" version))))
1912       (build-system asdf-build-system/sbcl)
1913       (synopsis "Common Lisp Test framework inspired by JUnit to be simple of use")
1914       (description
1915        "@command{lisp-unit} is a Common Lisp library that supports unit
1916 testing.  It is an extension of the library written by Chris Riesbeck.")
1917       (home-page "https://github.com/OdonataResearchLLC/lisp-unit")
1918       (license license:expat))))
1919
1920 (define-public cl-lisp-unit
1921   (sbcl-package->cl-source-package sbcl-lisp-unit))
1922
1923 (define-public ecl-lisp-unit
1924   (sbcl-package->ecl-package sbcl-lisp-unit))
1925
1926 (define-public sbcl-anaphora
1927   (package
1928     (name "sbcl-anaphora")
1929     (version "0.9.6")
1930     (source
1931      (origin
1932        (method git-fetch)
1933        (uri (git-reference
1934              (url "https://github.com/tokenrove/anaphora")
1935              (commit version)))
1936        (sha256
1937         (base32
1938          "19wfrk3asimznkli0x2rfy637hwpdgqyvwj3vhq9x7vjvyf5vv6x"))
1939        (file-name (git-file-name "anaphora" version))))
1940     (build-system asdf-build-system/sbcl)
1941     (native-inputs
1942      `(("rt" ,sbcl-rt)))
1943     (synopsis "The anaphoric macro collection from Hell")
1944     (description
1945      "Anaphora is the anaphoric macro collection from Hell: it includes many
1946 new fiends in addition to old friends like @command{aif} and
1947 @command{awhen}.")
1948     (home-page "https://github.com/tokenrove/anaphora")
1949     (license license:public-domain)))
1950
1951 (define-public cl-anaphora
1952   (sbcl-package->cl-source-package sbcl-anaphora))
1953
1954 (define-public ecl-anaphora
1955   (sbcl-package->ecl-package sbcl-anaphora))
1956
1957 (define-public sbcl-lift
1958   (let ((commit "7d49a66c62759535624037826891152223d4206c"))
1959     (package
1960       (name "sbcl-lift")
1961       (version (git-version "1.7.1" "1" commit))
1962       (source
1963        (origin
1964          (method git-fetch)
1965          (uri (git-reference
1966                (url "https://github.com/gwkkwg/lift")
1967                (commit commit)))
1968          (sha256
1969           (base32
1970            "127v5avpz1i4m0lkaxqrq8hrl69rdazqaxf6s8awf0nd7wj2g4dp"))
1971          (file-name (git-file-name "lift" version))
1972          (modules '((guix build utils)))
1973          (snippet
1974           ;; Don't keep the bundled website
1975           `(begin
1976              (delete-file-recursively "website")
1977              #t))))
1978       (build-system asdf-build-system/sbcl)
1979       (arguments
1980        ;; The tests require a debugger, but we run with the debugger disabled.
1981        '(#:tests? #f))
1982       (synopsis "LIsp Framework for Testing")
1983       (description
1984        "The LIsp Framework for Testing (LIFT) is a unit and system test tool for LISP.
1985 Though inspired by SUnit and JUnit, it's built with Lisp in mind.  In LIFT,
1986 testcases are organized into hierarchical testsuites each of which can have
1987 its own fixture.  When run, a testcase can succeed, fail, or error.  LIFT
1988 supports randomized testing, benchmarking, profiling, and reporting.")
1989       (home-page "https://github.com/gwkkwg/lift")
1990       (license license:expat))))
1991
1992 (define-public cl-lift
1993   (sbcl-package->cl-source-package sbcl-lift))
1994
1995 (define-public ecl-lift
1996   (sbcl-package->ecl-package sbcl-lift))
1997
1998 (define-public sbcl-let-plus
1999   (let ((commit "5f14af61d501ecead02ec6b5a5c810efc0c9fdbb"))
2000     (package
2001       (name "sbcl-let-plus")
2002       (version (git-version "0.0.0" "1" commit))
2003       (source
2004        (origin
2005          (method git-fetch)
2006          (uri (git-reference
2007                (url "https://github.com/sharplispers/let-plus")
2008                (commit commit)))
2009          (sha256
2010           (base32
2011            "0i050ca2iys9f5mb7dgqgqdxfnc3b0rnjdwv95sqd490vkiwrsaj"))
2012          (file-name (git-file-name "let-plus" version))))
2013       (build-system asdf-build-system/sbcl)
2014       (inputs
2015        `(("alexandria" ,sbcl-alexandria)
2016          ("anaphora" ,sbcl-anaphora)))
2017       (native-inputs
2018        `(("lift" ,sbcl-lift)))
2019       (synopsis "Destructuring extension of let*")
2020       (description
2021        "This library implements the let+ macro, which is a dectructuring
2022 extension of let*.  It features:
2023
2024 @itemize
2025 @item Clean, consistent syntax and small implementation (less than 300 LOC,
2026 not counting tests)
2027 @item Placeholder macros allow editor hints and syntax highlighting
2028 @item @command{&ign} for ignored values (in forms where that makes sense)
2029 @item Very easy to extend
2030 @end itemize\n")
2031       (home-page "https://github.com/sharplispers/let-plus")
2032       (license license:boost1.0))))
2033
2034 (define-public cl-let-plus
2035   (sbcl-package->cl-source-package sbcl-let-plus))
2036
2037 (define-public ecl-let-plus
2038   (sbcl-package->ecl-package sbcl-let-plus))
2039
2040 (define-public sbcl-cl-colors
2041   (let ((commit "827410584553f5c717eec6182343b7605f707f75"))
2042     (package
2043       (name "sbcl-cl-colors")
2044       (version (git-version "0.0.0" "1" commit))
2045       (source
2046        (origin
2047          (method git-fetch)
2048          (uri (git-reference
2049                (url "https://github.com/tpapp/cl-colors")
2050                (commit commit)))
2051          (sha256
2052           (base32
2053            "0l446lday4hybsm9bq3jli97fvv8jb1d33abg79vbylpwjmf3y9a"))
2054          (file-name (git-file-name "cl-colors" version))))
2055       (build-system asdf-build-system/sbcl)
2056       (inputs
2057        `(("alexandria" ,sbcl-alexandria)
2058          ("let-plus" ,sbcl-let-plus)))
2059       (synopsis "Simple color library for Common Lisp")
2060       (description
2061        "This is a very simple color library for Common Lisp, providing
2062
2063 @itemize
2064 @item Types for representing colors in HSV and RGB spaces.
2065 @item Simple conversion functions between the above types (and also
2066 hexadecimal representation for RGB).
2067 @item Some predefined colors (currently X11 color names – of course the
2068 library does not depend on X11).Because color in your terminal is nice.
2069 @end itemize
2070
2071 This library is no longer supported by its author.")
2072       (home-page "https://github.com/tpapp/cl-colors")
2073       (license license:boost1.0))))
2074
2075 (define-public cl-colors
2076   (sbcl-package->cl-source-package sbcl-cl-colors))
2077
2078 (define-public ecl-cl-colors
2079   (sbcl-package->ecl-package sbcl-cl-colors))
2080
2081 (define-public sbcl-cl-ansi-text
2082   (let ((commit "53badf7878f27f22f2d4a2a43e6df458e43acbe9"))
2083     (package
2084       (name "sbcl-cl-ansi-text")
2085       (version (git-version "1.0.0" "1" commit))
2086       (source
2087        (origin
2088          (method git-fetch)
2089          (uri (git-reference
2090                (url "https://github.com/pnathan/cl-ansi-text")
2091                (commit commit)))
2092          (sha256
2093           (base32
2094            "11i27n0dbz5lmygiw65zzr8lx0rac6b6yysqranphn31wls6ja3v"))
2095          (file-name (git-file-name "cl-ansi-text" version))))
2096       (build-system asdf-build-system/sbcl)
2097       (inputs
2098        `(("alexandria" ,sbcl-alexandria)
2099          ("cl-colors" ,sbcl-cl-colors)))
2100       (native-inputs
2101        `(("fiveam" ,sbcl-fiveam)))
2102       (synopsis "ANSI terminal color implementation for Common Lisp")
2103       (description
2104        "@command{cl-ansi-text} provides utilities which enable printing to an
2105 ANSI terminal with colored text.  It provides the macro @command{with-color}
2106 which causes everything printed in the body to be displayed with the provided
2107 color.  It further provides functions which will print the argument with the
2108 named color.")
2109       (home-page "https://github.com/pnathan/cl-ansi-text")
2110       (license license:llgpl))))
2111
2112 (define-public cl-ansi-text
2113   (sbcl-package->cl-source-package sbcl-cl-ansi-text))
2114
2115 (define-public ecl-cl-ansi-text
2116   (sbcl-package->ecl-package sbcl-cl-ansi-text))
2117
2118 (define-public sbcl-prove-asdf
2119   (let ((commit "4f9122bd393e63c5c70c1fba23070622317cfaa0"))
2120     (package
2121       (name "sbcl-prove-asdf")
2122       (version (git-version "1.0.0" "1" commit))
2123       (source
2124        (origin
2125          (method git-fetch)
2126          (uri (git-reference
2127                (url "https://github.com/fukamachi/prove")
2128                (commit commit)))
2129          (sha256
2130           (base32
2131            "07sbfw459z8bbjvx1qlmfa8qk2mvbjnnzi2mi0x72blaj8bkl4vc"))
2132          (file-name (git-file-name "prove" version))))
2133       (build-system asdf-build-system/sbcl)
2134       (arguments
2135        `(#:asd-file "prove-asdf.asd"))
2136       (synopsis "Test requirement for the Common Lisp 'prove' library")
2137       (description
2138        "Test requirement for the Common Lisp @command{prove} library.")
2139       (home-page "https://github.com/fukamachi/prove")
2140       (license license:expat))))
2141
2142 (define-public cl-prove-asdf
2143   (sbcl-package->cl-source-package sbcl-prove-asdf))
2144
2145 (define-public ecl-prove-asdf
2146   (sbcl-package->ecl-package sbcl-prove-asdf))
2147
2148 (define-public sbcl-prove
2149   (package
2150     (inherit sbcl-prove-asdf)
2151     (name "sbcl-prove")
2152     (inputs
2153      `(("alexandria" ,sbcl-alexandria)
2154        ("cl-ppcre" ,sbcl-cl-ppcre)
2155        ("cl-ansi-text" ,sbcl-cl-ansi-text)))
2156     (native-inputs
2157      `(("prove-asdf" ,sbcl-prove-asdf)))
2158     (arguments
2159      `(#:asd-file "prove.asd"))
2160     (synopsis "Yet another unit testing framework for Common Lisp")
2161     (description
2162      "This project was originally called @command{cl-test-more}.
2163 @command{prove} is yet another unit testing framework for Common Lisp.  The
2164 advantages of @command{prove} are:
2165
2166 @itemize
2167 @item Various simple functions for testing and informative error messages
2168 @item ASDF integration
2169 @item Extensible test reporters
2170 @item Colorizes the report if it's available (note for SLIME)
2171 @item Reports test durations
2172 @end itemize\n")))
2173
2174 (define-public cl-prove
2175   (sbcl-package->cl-source-package sbcl-prove))
2176
2177 (define-public ecl-prove
2178   (sbcl-package->ecl-package sbcl-prove))
2179
2180 (define-public sbcl-proc-parse
2181   (let ((commit "ac3636834d561bdc2686c956dbd82494537285fd"))
2182     (package
2183       (name "sbcl-proc-parse")
2184       (version (git-version "0.0.0" "1" commit))
2185       (source
2186        (origin
2187          (method git-fetch)
2188          (uri (git-reference
2189                (url "https://github.com/fukamachi/proc-parse")
2190                (commit commit)))
2191          (sha256
2192           (base32
2193            "06rnl0h4cx6xv2wj3jczmmcxqn2703inmmvg1s4npbghmijsybfh"))
2194          (file-name (git-file-name "proc-parse" version))))
2195       (build-system asdf-build-system/sbcl)
2196       (inputs
2197        `(("alexandria" ,sbcl-alexandria)
2198          ("babel" ,sbcl-babel)))
2199       (native-inputs
2200        `(("prove" ,sbcl-prove)
2201          ("prove-asdf" ,sbcl-prove-asdf)))
2202       (arguments
2203        ;; TODO: Tests don't find "proc-parse-test", why?
2204        `(#:tests? #f))
2205       (synopsis "Procedural vector parser")
2206       (description
2207        "This is a string/octets parser library for Common Lisp with speed and
2208 readability in mind.  Unlike other libraries, the code is not a
2209 pattern-matching-like, but a char-by-char procedural parser.")
2210       (home-page "https://github.com/fukamachi/proc-parse")
2211       (license license:bsd-2))))
2212
2213 (define-public cl-proc-parse
2214   (sbcl-package->cl-source-package sbcl-proc-parse))
2215
2216 (define-public ecl-proc-parse
2217   (sbcl-package->ecl-package sbcl-proc-parse))
2218
2219 (define-public sbcl-parse-float
2220   (let ((commit "2aae569f2a4b2eb3bfb5401a959425dcf151b09c"))
2221     (package
2222       (name "sbcl-parse-float")
2223       (version (git-version "0.0.0" "1" commit))
2224       (source
2225        (origin
2226          (method git-fetch)
2227          (uri (git-reference
2228                (url "https://github.com/soemraws/parse-float")
2229                (commit commit)))
2230          (sha256
2231           (base32
2232            "08xw8cchhmqcc0byng69m3f5a2izc9y2290jzz2k0qrbibp1fdk7"))
2233          (file-name (git-file-name "proc-parse" version))))
2234       (build-system asdf-build-system/sbcl)
2235       (inputs
2236        `(("alexandria" ,sbcl-alexandria)
2237          ("babel" ,sbcl-babel)))
2238       (native-inputs
2239        `(("prove" ,sbcl-prove)
2240          ("prove-asdf" ,sbcl-prove-asdf)))
2241       (arguments
2242        ;; TODO: Tests don't find "proc-parse-test", why?
2243        `(#:tests? #f))
2244       (synopsis "Parse a floating point value from a string in Common Lisp")
2245       (description
2246        "This package exports the following function to parse floating-point
2247 values from a string in Common Lisp.")
2248       (home-page "https://github.com/soemraws/parse-float")
2249       (license license:public-domain))))
2250
2251 (define-public cl-parse-float
2252   (sbcl-package->cl-source-package sbcl-parse-float))
2253
2254 (define-public ecl-parse-float
2255   (sbcl-package->ecl-package sbcl-parse-float))
2256
2257 (define-public sbcl-ascii-strings
2258   (let ((revision "1")
2259         (changeset "5048480a61243e6f1b02884012c8f25cdbee6d97"))
2260     (package
2261       (name "sbcl-ascii-strings")
2262       (version (string-append "0-" revision "." (string-take changeset 7)))
2263       (source
2264        (origin
2265          (method hg-fetch)
2266          (uri (hg-reference
2267                (url "https://bitbucket.org/vityok/cl-string-match/")
2268                (changeset changeset)))
2269          (sha256
2270           (base32
2271            "01wn5qx562w43ssy92xlfgv79w7p0nv0wbl76mpmba131n9ziq2y"))
2272          (file-name (git-file-name "cl-string-match" version))))
2273       (build-system asdf-build-system/sbcl)
2274       (inputs
2275        `(("alexandria" ,sbcl-alexandria)
2276          ("babel" ,sbcl-babel)))
2277       (arguments
2278        `(#:asd-file "ascii-strings.asd"))
2279       (synopsis "Operations on ASCII strings")
2280       (description
2281        "Operations on ASCII strings.  Essentially this can be any kind of
2282 single-byte encoded strings.")
2283       (home-page "https://bitbucket.org/vityok/cl-string-match/")
2284       (license license:bsd-3))))
2285
2286 (define-public cl-ascii-strings
2287   (sbcl-package->cl-source-package sbcl-ascii-strings))
2288
2289 (define-public ecl-ascii-strings
2290   (sbcl-package->ecl-package sbcl-ascii-strings))
2291
2292 (define-public sbcl-simple-scanf
2293   (package
2294     (inherit sbcl-ascii-strings)
2295     (name "sbcl-simple-scanf")
2296     (inputs
2297      `(("alexandria" ,sbcl-alexandria)
2298        ("iterate" ,sbcl-iterate)
2299        ("proc-parse" ,sbcl-proc-parse)
2300        ("parse-float" ,sbcl-parse-float)))
2301     (arguments
2302      `(#:asd-file "simple-scanf.asd"))
2303     (synopsis "Simple scanf-like functionality implementation")
2304     (description
2305      "A simple scanf-like functionality implementation.")))
2306
2307 (define-public cl-simple-scanf
2308   (sbcl-package->cl-source-package sbcl-simple-scanf))
2309
2310 (define-public ecl-simple-scanf
2311   (sbcl-package->ecl-package sbcl-simple-scanf))
2312
2313 (define-public sbcl-cl-string-match
2314   (package
2315     (inherit sbcl-ascii-strings)
2316     (name "sbcl-cl-string-match")
2317     (inputs
2318      `(("alexandria" ,sbcl-alexandria)
2319        ("ascii-strings" ,sbcl-ascii-strings)
2320        ("yacc" ,sbcl-cl-yacc)
2321        ("jpl-util" ,sbcl-jpl-util)
2322        ("jpl-queues" ,sbcl-jpl-queues)
2323        ("mgl-pax" ,sbcl-mgl-pax)
2324        ("iterate" ,sbcl-iterate)))
2325     ;; TODO: Tests are not evaluated properly.
2326     (native-inputs
2327      ;; For testing:
2328      `(("lisp-unit" ,sbcl-lisp-unit)
2329        ("simple-scanf" ,sbcl-simple-scanf)))
2330     (arguments
2331      `(#:tests? #f
2332        #:asd-file "cl-string-match.asd"))
2333     (synopsis "Portable, dependency-free set of utilities to manipulate strings in Common Lisp")
2334     (description
2335      "@command{cl-strings} is a small, portable, dependency-free set of
2336 utilities that make it even easier to manipulate text in Common Lisp.  It has
2337 100% test coverage and works at least on sbcl, ecl, ccl, abcl and clisp.")))
2338
2339 (define-public cl-string-match
2340   (sbcl-package->cl-source-package sbcl-cl-string-match))
2341
2342 (define-public ecl-cl-string-match
2343   (sbcl-package->ecl-package sbcl-cl-string-match))
2344
2345 (define-public sbcl-ptester
2346   (let ((commit "fe69fde54f4bce00ce577feb918796c293fc7253")
2347         (revision "1"))
2348     (package
2349       (name "sbcl-ptester")
2350       (version (git-version "2.1.3" revision commit))
2351       (source
2352        (origin
2353          (method git-fetch)
2354          (uri (git-reference
2355                (url "http://git.kpe.io/ptester.git")
2356                (commit commit)))
2357          (file-name (git-file-name name version))
2358          (sha256
2359           (base32 "1l0lfl7cdnr2qf4zh38hi4llxg22c49zkm639bdkmvlkzwj3ndwf"))))
2360       (build-system asdf-build-system/sbcl)
2361       (home-page "http://quickdocs.org/ptester/")
2362       (synopsis "Portable test harness package")
2363       (description
2364        "@command{ptester} is a portable testing framework based on Franz's
2365 tester module.")
2366       (license license:llgpl))))
2367
2368 (define-public cl-ptester
2369   (sbcl-package->cl-source-package sbcl-ptester))
2370
2371 (define-public ecl-ptester
2372   (sbcl-package->ecl-package sbcl-ptester))
2373
2374 (define-public sbcl-puri
2375   (let ((commit "ef5afb9e5286c8e952d4344f019c1a636a717b97")
2376         (revision "1"))
2377     (package
2378       (name "sbcl-puri")
2379       (version (git-version "1.5.7" revision commit))
2380       (source
2381        (origin
2382          (method git-fetch)
2383          (uri (git-reference
2384                (url "http://git.kpe.io/puri.git")
2385                (commit commit)))
2386          (file-name (git-file-name name version))
2387          (sha256
2388           (base32 "1vm25pdl92laj72p5vyd538kf3cjy2655z6bdc99h20ana2p231s"))))
2389       (build-system asdf-build-system/sbcl)
2390       (native-inputs
2391        `(("ptester" ,sbcl-ptester)))
2392       (home-page "http://quickdocs.org/puri/")
2393       (synopsis "Portable URI Library")
2394       (description
2395        "This is a portable Universal Resource Identifier library for Common
2396 Lisp programs.  It parses URI according to the RFC 2396 specification.")
2397       (license license:llgpl))))
2398
2399 (define-public cl-puri
2400   (sbcl-package->cl-source-package sbcl-puri))
2401
2402 (define-public ecl-puri
2403   (sbcl-package->ecl-package sbcl-puri))
2404
2405 (define-public sbcl-queues
2406   (let ((commit "47d4da65e9ea20953b74aeeab7e89a831b66bc94"))
2407     (package
2408       (name "sbcl-queues")
2409       (version (git-version "0.0.0" "1" commit))
2410       (source
2411        (origin
2412          (method git-fetch)
2413          (uri (git-reference
2414                (url "https://github.com/oconnore/queues")
2415                (commit commit)))
2416          (file-name (git-file-name "queues" version))
2417          (sha256
2418           (base32
2419            "0wdhfnzi4v6d97pggzj2aw55si94w4327br94jrmyvwf351wqjvv"))))
2420       (build-system asdf-build-system/sbcl)
2421       (home-page "https://github.com/oconnore/queues")
2422       (synopsis "Common Lisp queue library")
2423       (description
2424        "This is a simple queue library for Common Lisp with features such as
2425 non-consing thread safe queues and fibonacci priority queues.")
2426       (license license:expat))))
2427
2428 (define-public cl-queues
2429   (sbcl-package->cl-source-package sbcl-queues))
2430
2431 (define-public ecl-queues
2432   (sbcl-package->ecl-package sbcl-queues))
2433
2434 (define-public sbcl-queues.simple-queue
2435   (package
2436     (inherit sbcl-queues)
2437     (name "sbcl-queues.simple-queue")
2438     (inputs
2439      `(("sbcl-queues" ,sbcl-queues)))
2440     (arguments
2441      `(#:asd-file "queues.simple-queue.asd"))
2442     (synopsis "Simple queue implementation")
2443     (description
2444      "This is a simple queue library for Common Lisp with features such as
2445 non-consing thread safe queues and fibonacci priority queues.")
2446     (license license:expat)))
2447
2448 (define-public cl-queues.simple-queue
2449   (sbcl-package->cl-source-package sbcl-queues.simple-queue))
2450
2451 (define-public ecl-queues.simple-queue
2452   (sbcl-package->ecl-package sbcl-queues.simple-queue))
2453
2454 (define-public sbcl-queues.simple-cqueue
2455   (package
2456     (inherit sbcl-queues)
2457     (name "sbcl-queues.simple-cqueue")
2458     (inputs
2459      `(("sbcl-queues" ,sbcl-queues)
2460        ("sbcl-queues.simple-queue" ,sbcl-queues.simple-queue)
2461        ("bordeaux-threads" ,sbcl-bordeaux-threads)))
2462     (arguments
2463      `(#:asd-file "queues.simple-cqueue.asd"))
2464     (synopsis "Thread safe queue implementation")
2465     (description
2466      "This is a simple queue library for Common Lisp with features such as
2467 non-consing thread safe queues and fibonacci priority queues.")
2468     (license license:expat)))
2469
2470 (define-public cl-queues.simple-cqueue
2471   (sbcl-package->cl-source-package sbcl-queues.simple-cqueue))
2472
2473 (define-public ecl-queues.simple-cqueue
2474   (sbcl-package->ecl-package sbcl-queues.simple-cqueue))
2475
2476 (define-public sbcl-queues.priority-queue
2477   (package
2478     (inherit sbcl-queues)
2479     (name "sbcl-queues.priority-queue")
2480     (inputs
2481      `(("sbcl-queues" ,sbcl-queues)))
2482     (arguments
2483      `(#:asd-file "queues.priority-queue.asd"))
2484     (synopsis "Priority queue (Fibonacci) implementation")
2485     (description
2486      "This is a simple queue library for Common Lisp with features such as
2487 non-consing thread safe queues and fibonacci priority queues.")
2488     (license license:expat)))
2489
2490 (define-public cl-queues.priority-queue
2491   (sbcl-package->cl-source-package sbcl-queues.priority-queue))
2492
2493 (define-public ecl-queues.priority-queue
2494   (sbcl-package->ecl-package sbcl-queues.priority-queue))
2495
2496 (define-public sbcl-queues.priority-cqueue
2497   (package
2498     (inherit sbcl-queues)
2499     (name "sbcl-queues.priority-cqueue")
2500     (inputs
2501      `(("sbcl-queues" ,sbcl-queues)
2502        ("sbcl-queues.priority-queue" ,sbcl-queues.priority-queue)
2503        ("bordeaux-threads" ,sbcl-bordeaux-threads)))
2504     (arguments
2505      `(#:asd-file "queues.priority-cqueue.asd"))
2506     (synopsis "Thread safe fibonacci priority queue implementation")
2507     (description
2508      "This is a simple queue library for Common Lisp with features such as
2509 non-consing thread safe queues and fibonacci priority queues.")
2510     (license license:expat)))
2511
2512 (define-public cl-queues.priority-cqueue
2513   (sbcl-package->cl-source-package sbcl-queues.priority-cqueue))
2514
2515 (define-public ecl-queues.priority-cqueue
2516   (sbcl-package->ecl-package sbcl-queues.priority-cqueue))
2517
2518 (define sbcl-cffi-bootstrap
2519   (package
2520     (name "sbcl-cffi-bootstrap")
2521     (version "0.21.0")
2522     (source
2523      (origin
2524        (method git-fetch)
2525        (uri (git-reference
2526              (url "https://github.com/cffi/cffi.git")
2527              (commit (string-append "v" version))))
2528        (file-name (git-file-name "cffi-bootstrap" version))
2529        (sha256
2530         (base32 "1qalargz9bhp850qv60ffwpdqi4xirzar4l3g6qcg8yc6xqf2cjk"))))
2531     (build-system asdf-build-system/sbcl)
2532     (inputs
2533      `(("libffi" ,libffi)
2534        ("alexandria" ,sbcl-alexandria)
2535        ("babel" ,sbcl-babel)
2536        ("trivial-features" ,sbcl-trivial-features)))
2537     (native-inputs
2538      `(("pkg-config" ,pkg-config)))
2539     (arguments
2540      '(#:phases
2541        (modify-phases %standard-phases
2542          (add-after 'unpack 'fix-paths
2543            (lambda* (#:key inputs #:allow-other-keys)
2544              (substitute* "libffi/libffi.lisp"
2545                (("libffi.so.7" all) (string-append
2546                                      (assoc-ref inputs "libffi")
2547                                      "/lib/" all)))
2548              (substitute* "toolchain/c-toolchain.lisp"
2549                (("\"cc\"") (format #f "~S" (which "gcc")))))))
2550        #:asd-system-name "cffi"
2551        #:tests? #f))
2552     (home-page "https://common-lisp.net/project/cffi/")
2553     (synopsis "Common Foreign Function Interface for Common Lisp")
2554     (description "The Common Foreign Function Interface (CFFI)
2555 purports to be a portable foreign function interface for Common Lisp.
2556 The CFFI library is composed of a Lisp-implementation-specific backend
2557 in the CFFI-SYS package, and a portable frontend in the CFFI
2558 package.")
2559     (license license:expat)))
2560
2561 (define-public sbcl-cffi-toolchain
2562   (package
2563     (inherit sbcl-cffi-bootstrap)
2564     (name "sbcl-cffi-toolchain")
2565     (inputs
2566      `(("libffi" ,libffi)
2567        ("sbcl-cffi" ,sbcl-cffi-bootstrap)))
2568     (arguments
2569      (substitute-keyword-arguments (package-arguments sbcl-cffi-bootstrap)
2570        ((#:asd-system-name _) #f)
2571        ((#:tests? _) #t)))))
2572
2573 (define-public sbcl-cffi-libffi
2574   (package
2575     (inherit sbcl-cffi-toolchain)
2576     (name "sbcl-cffi-libffi")
2577     (inputs
2578      `(("cffi" ,sbcl-cffi-bootstrap)
2579        ("cffi-grovel" ,sbcl-cffi-grovel)
2580        ("trivial-features" ,sbcl-trivial-features)
2581        ("libffi" ,libffi)))))
2582
2583 (define-public sbcl-cffi-grovel
2584   (package
2585     (inherit sbcl-cffi-toolchain)
2586     (name "sbcl-cffi-grovel")
2587     (inputs
2588      `(("libffi" ,libffi)
2589        ("cffi" ,sbcl-cffi-bootstrap)
2590        ("cffi-toolchain" ,sbcl-cffi-toolchain)
2591        ("alexandria" ,sbcl-alexandria)))
2592     (arguments
2593      (substitute-keyword-arguments (package-arguments sbcl-cffi-toolchain)
2594        ((#:phases phases)
2595         `(modify-phases ,phases
2596            (add-after 'build 'install-headers
2597              (lambda* (#:key outputs #:allow-other-keys)
2598                (install-file "grovel/common.h"
2599                              (string-append
2600                               (assoc-ref outputs "out")
2601                               "/include/grovel"))))))))))
2602
2603 (define-public sbcl-cffi
2604   (package
2605     (inherit sbcl-cffi-toolchain)
2606     (name "sbcl-cffi")
2607     (inputs (package-inputs sbcl-cffi-bootstrap))
2608     (native-inputs
2609      `(("cffi-grovel" ,sbcl-cffi-grovel)
2610        ("cffi-libffi" ,sbcl-cffi-libffi)
2611        ("rt" ,sbcl-rt)
2612        ("bordeaux-threads" ,sbcl-bordeaux-threads)
2613        ,@(package-native-inputs sbcl-cffi-bootstrap)))))
2614
2615 (define-public cl-cffi
2616   (sbcl-package->cl-source-package sbcl-cffi))
2617
2618 (define-public sbcl-cffi-uffi-compat
2619   (package
2620     (inherit sbcl-cffi-toolchain)
2621     (name "sbcl-cffi-uffi-compat")
2622     (native-inputs
2623      `(,@(package-inputs sbcl-cffi-bootstrap))) ; For fix-paths phase
2624     (inputs
2625      `(("cffi" ,sbcl-cffi)))
2626     (synopsis "UFFI Compatibility Layer for CFFI")))
2627
2628 (define-public cl-cffi-uffi-compat
2629   (sbcl-package->cl-source-package sbcl-cffi-uffi-compat))
2630
2631 (define-public sbcl-cl-sqlite
2632   (let ((commit "c738e66d4266ef63a1debc4ef4a1b871a068c112"))
2633     (package
2634       (name "sbcl-cl-sqlite")
2635       (version (git-version "0.2" "1" commit))
2636       (source
2637        (origin
2638          (method git-fetch)
2639          (uri (git-reference
2640                (url "https://github.com/dmitryvk/cl-sqlite")
2641                (commit commit)))
2642          (file-name (git-file-name "cl-sqlite" version))
2643          (sha256
2644           (base32
2645            "1ng45k1hdb84sqjryrfx93g66bsbybmpy301wd0fdybnc5jzr36q"))))
2646       (build-system asdf-build-system/sbcl)
2647       (inputs
2648        `(("iterate" ,sbcl-iterate)
2649          ("cffi" ,sbcl-cffi)
2650          ("sqlite" ,sqlite)))
2651       (native-inputs
2652        `(("fiveam" ,sbcl-fiveam)
2653          ("bordeaux-threads" ,sbcl-bordeaux-threads)))
2654       (arguments
2655        `(#:tests? #f                    ; Upstream seems to have issues with tests: https://github.com/dmitryvk/cl-sqlite/issues/7
2656          #:asd-file "sqlite.asd"
2657          #:asd-system-name "sqlite"
2658          #:phases
2659          (modify-phases %standard-phases
2660            (add-after 'unpack 'fix-paths
2661              (lambda* (#:key inputs #:allow-other-keys)
2662                (substitute* "sqlite-ffi.lisp"
2663                  (("libsqlite3" all) (string-append
2664                                       (assoc-ref inputs "sqlite")"/lib/" all))))))))
2665       (home-page "https://common-lisp.net/project/cl-sqlite/")
2666       (synopsis "Common Lisp binding for SQLite")
2667       (description
2668        "The @command{cl-sqlite} package is an interface to the SQLite embedded
2669 relational database engine.")
2670       (license license:public-domain))))
2671
2672 (define-public cl-sqlite
2673   (sbcl-package->cl-source-package sbcl-cl-sqlite))
2674
2675 (define-public sbcl-parenscript
2676   ;; Source archives are overwritten on every release, we use the Git repo instead.
2677   (let ((commit "7a1ac46353cecd144fc91915ba9f122aafcf4766"))
2678     (package
2679       (name "sbcl-parenscript")
2680       (version (git-version "2.7.1" "1" commit))
2681       (source
2682        (origin
2683          (method git-fetch)
2684          (uri (git-reference
2685                (url "https://gitlab.common-lisp.net/parenscript/parenscript")
2686                (commit commit)))
2687          (file-name (git-file-name "parenscript" version))
2688          (sha256
2689           (base32
2690            "0c22lqarrpbq82dg1sb3y6mp6w2faczp34ymzhnmff88yfq1xzsf"))))
2691       (build-system asdf-build-system/sbcl)
2692       (inputs
2693        `(("cl-ppcre" ,sbcl-cl-ppcre)
2694          ("anaphora" ,sbcl-anaphora)
2695          ("named-readtables" ,sbcl-named-readtables)))
2696       (home-page "https://common-lisp.net/project/parenscript/")
2697       (synopsis "Translator from a subset of Common Lisp to JavaScript")
2698       (description
2699        "Parenscript is a translator from an extended subset of Common Lisp to
2700 JavaScript.  Parenscript code can run almost identically on both the
2701 browser (as JavaScript) and server (as Common Lisp).
2702
2703 Parenscript code is treated the same way as Common Lisp code, making the full
2704 power of Lisp macros available for JavaScript.  This provides a web
2705 development environment that is unmatched in its ability to reduce code
2706 duplication and provide advanced meta-programming facilities to web
2707 developers.
2708
2709 At the same time, Parenscript is different from almost all other \"language
2710 X\" to JavaScript translators in that it imposes almost no overhead:
2711
2712 @itemize
2713 @item No run-time dependencies: Any piece of Parenscript code is runnable
2714 as-is.  There are no JavaScript files to include.
2715 @item Native types: Parenscript works entirely with native JavaScript data
2716 types.  There are no new types introduced, and object prototypes are not
2717 touched.
2718 @item Native calling convention: Any JavaScript code can be called without the
2719 need for bindings.  Likewise, Parenscript can be used to make efficient,
2720 self-contained JavaScript libraries.
2721 @item Readable code: Parenscript generates concise, formatted, idiomatic
2722 JavaScript code.  Identifier names are preserved.  This enables seamless
2723 debugging in tools like Firebug.
2724 @item Efficiency: Parenscript introduces minimal overhead for advanced Common
2725 Lisp features.  The generated code is almost as fast as hand-written
2726 JavaScript.
2727 @end itemize\n")
2728       (license license:bsd-3))))
2729
2730 (define-public cl-parenscript
2731   (sbcl-package->cl-source-package sbcl-parenscript))
2732
2733 (define-public ecl-parenscript
2734   (sbcl-package->ecl-package sbcl-parenscript))
2735
2736 (define-public sbcl-cl-json
2737   (let ((commit "6dfebb9540bfc3cc33582d0c03c9ec27cb913e79"))
2738     (package
2739       (name "sbcl-cl-json")
2740       (version (git-version "0.5" "1" commit))
2741       (source
2742        (origin
2743          (method git-fetch)
2744          (uri (git-reference
2745                (url "https://github.com/hankhero/cl-json")
2746                (commit commit)))
2747          (file-name (git-file-name "cl-json" version))
2748          (sha256
2749           (base32
2750            "0fx3m3x3s5ji950yzpazz4s0img3l6b3d6l3jrfjv0lr702496lh"))))
2751       (build-system asdf-build-system/sbcl)
2752       (native-inputs
2753        `(("fiveam" ,sbcl-fiveam)))
2754       (home-page "https://github.com/hankhero/cl-json")
2755       (synopsis "JSON encoder and decoder for Common-Lisp")
2756       (description
2757        "@command{cl-json} provides an encoder of Lisp objects to JSON format
2758 and a corresponding decoder of JSON data to Lisp objects.  Both the encoder
2759 and the decoder are highly customizable; at the same time, the default
2760 settings ensure a very simple mode of operation, similar to that provided by
2761 @command{yason} or @command{st-json}.")
2762       (license license:expat))))
2763
2764 (define-public cl-json
2765   (sbcl-package->cl-source-package sbcl-cl-json))
2766
2767 (define-public ecl-cl-json
2768   (sbcl-package->ecl-package sbcl-cl-json))
2769
2770 (define-public sbcl-unix-opts
2771   (package
2772     (name "sbcl-unix-opts")
2773     (version "0.1.7")
2774     (source
2775      (origin
2776        (method git-fetch)
2777        (uri (git-reference
2778              (url "https://github.com/libre-man/unix-opts")
2779              (commit version)))
2780        (file-name (git-file-name "unix-opts" version))
2781        (sha256
2782         (base32
2783          "08djdi1ard09fijb7w9bdmhmwd98b1hzmcnjw9fqjiqa0g3b44rr"))))
2784     (build-system asdf-build-system/sbcl)
2785     (home-page "https://github.com/hankhero/cl-json")
2786     (synopsis "Unix-style command line options parser")
2787     (description
2788      "This is a minimalistic parser of command line options.  The main
2789 advantage of the library is the ability to concisely define command line
2790 options once and then use this definition for parsing and extraction of
2791 command line arguments, as well as printing description of command line
2792 options (you get --help for free).  This way you don't need to repeat
2793 yourself.  Also, @command{unix-opts} doesn't depend on anything and
2794 precisely controls the behavior of the parser via Common Lisp restarts.")
2795     (license license:expat)))
2796
2797 (define-public cl-unix-opts
2798   (sbcl-package->cl-source-package sbcl-unix-opts))
2799
2800 (define-public ecl-unix-opts
2801   (sbcl-package->ecl-package sbcl-unix-opts))
2802
2803 (define-public sbcl-trivial-garbage
2804   (package
2805     (name "sbcl-trivial-garbage")
2806     (version "0.21")
2807     (source
2808      (origin
2809        (method git-fetch)
2810        (uri (git-reference
2811              (url "https://github.com/trivial-garbage/trivial-garbage.git")
2812              (commit (string-append "v" version))))
2813        (file-name (git-file-name "trivial-garbage" version))
2814        (sha256
2815         (base32 "0122jicfg7pca1wxw8zak1n92h5friqy60988ns0ysksj3fphw9n"))))
2816     (build-system asdf-build-system/sbcl)
2817     (native-inputs
2818      `(("rt" ,sbcl-rt)))
2819     (home-page "https://common-lisp.net/project/trivial-garbage/")
2820     (synopsis "Portable GC-related APIs for Common Lisp")
2821     (description "@command{trivial-garbage} provides a portable API to
2822 finalizers, weak hash-tables and weak pointers on all major implementations of
2823 the Common Lisp programming language.")
2824     (license license:public-domain)))
2825
2826 (define-public cl-trivial-garbage
2827   (sbcl-package->cl-source-package sbcl-trivial-garbage))
2828
2829 (define-public ecl-trivial-garbage
2830   (sbcl-package->ecl-package sbcl-trivial-garbage))
2831
2832 (define-public sbcl-closer-mop
2833   (let ((commit "19c9d33f576e10715fd79cc1d4f688dab0f241d6"))
2834     (package
2835       (name "sbcl-closer-mop")
2836       (version (git-version  "1.0.0" "2" commit))
2837       (source
2838        (origin
2839          (method git-fetch)
2840          (uri (git-reference
2841                (url "https://github.com/pcostanza/closer-mop")
2842                (commit commit)))
2843          (sha256
2844           (base32 "1w3x087wvlwkd6swfdgbvjfs6kazf0la8ax4pjfzikwjch4snn2c"))
2845          (file-name (git-file-name "closer-mop" version ))))
2846       (build-system asdf-build-system/sbcl)
2847       (home-page "https://github.com/pcostanza/closer-mop")
2848       (synopsis "Rectifies absent or incorrect CLOS MOP features")
2849       (description "Closer to MOP is a compatibility layer that rectifies many
2850 of the absent or incorrect CLOS MOP features across a broad range of Common
2851 Lisp implementations.")
2852       (license license:expat))))
2853
2854 (define-public cl-closer-mop
2855   (sbcl-package->cl-source-package sbcl-closer-mop))
2856
2857 (define-public ecl-closer-mop
2858   (sbcl-package->ecl-package sbcl-closer-mop))
2859
2860 (define sbcl-cl-cffi-gtk-boot0
2861   (let ((commit "412d17214e092220c65a5660f5cbbd9cb69b8fe4"))
2862     (package
2863       (name "sbcl-cl-cffi-gtk-boot0")
2864       (version (git-version "0.11.2" "1" commit))
2865       (source
2866        (origin
2867          (method git-fetch)
2868          (uri (git-reference
2869                (url "https://github.com/Ferada/cl-cffi-gtk/")
2870                (commit commit)))
2871          (file-name (git-file-name "cl-cffi-gtk" version))
2872          (sha256
2873           (base32
2874            "0n997yhcnzk048nalx8ys62ja2ac8iv4mbn3mb55iapl0321hghn"))))
2875       (build-system asdf-build-system/sbcl)
2876       (inputs
2877        `(("iterate" ,sbcl-iterate)
2878          ("cffi" ,sbcl-cffi)
2879          ("trivial-features" ,sbcl-trivial-features)
2880          ("glib" ,glib)
2881          ("cairo" ,cairo)
2882          ("pango" ,pango)
2883          ("gdk-pixbuf" ,gdk-pixbuf)
2884          ("gtk" ,gtk+)))
2885       (arguments
2886        `(#:phases
2887          (modify-phases %standard-phases
2888            (add-after 'unpack 'fix-paths
2889              (lambda* (#:key inputs #:allow-other-keys)
2890                (substitute* "glib/glib.init.lisp"
2891                  (("libglib|libgthread" all)
2892                   (string-append (assoc-ref inputs "glib") "/lib/" all)))
2893                (substitute* "gobject/gobject.init.lisp"
2894                  (("libgobject" all)
2895                   (string-append (assoc-ref inputs "glib") "/lib/" all)))
2896                (substitute* "gio/gio.init.lisp"
2897                  (("libgio" all)
2898                   (string-append (assoc-ref inputs "glib") "/lib/" all)))
2899                (substitute* "cairo/cairo.init.lisp"
2900                  (("libcairo" all)
2901                   (string-append (assoc-ref inputs "cairo") "/lib/" all)))
2902                (substitute* "pango/pango.init.lisp"
2903                  (("libpango" all)
2904                   (string-append (assoc-ref inputs "pango") "/lib/" all)))
2905                (substitute* "gdk-pixbuf/gdk-pixbuf.init.lisp"
2906                  (("libgdk_pixbuf" all)
2907                   (string-append (assoc-ref inputs "gdk-pixbuf") "/lib/" all)))
2908                (substitute* "gdk/gdk.init.lisp"
2909                  (("libgdk" all)
2910                   (string-append (assoc-ref inputs "gtk") "/lib/" all)))
2911                (substitute* "gdk/gdk.package.lisp"
2912                  (("libgtk" all)
2913                   (string-append (assoc-ref inputs "gtk") "/lib/" all))))))))
2914       (home-page "https://github.com/Ferada/cl-cffi-gtk/")
2915       (synopsis "Common Lisp binding for GTK+3")
2916       (description
2917        "@command{cl-cffi-gtk} is a Lisp binding to GTK+ 3 (GIMP Toolkit) which
2918 is a library for creating graphical user interfaces.")
2919       (license license:lgpl3))))
2920
2921 (define-public sbcl-cl-cffi-gtk-glib
2922   (package
2923     (inherit sbcl-cl-cffi-gtk-boot0)
2924     (name "sbcl-cl-cffi-gtk-glib")
2925     (inputs
2926      `(("bordeaux-threads" ,sbcl-bordeaux-threads)
2927        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2928     (arguments
2929      (substitute-keyword-arguments (package-arguments sbcl-cl-cffi-gtk-boot0)
2930        ((#:asd-file _ "") "glib/cl-cffi-gtk-glib.asd")))))
2931
2932 (define-public sbcl-cl-cffi-gtk-gobject
2933   (package
2934     (inherit sbcl-cl-cffi-gtk-boot0)
2935     (name "sbcl-cl-cffi-gtk-gobject")
2936     (inputs
2937      `(("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
2938        ("trivial-garbage" ,sbcl-trivial-garbage)
2939        ("bordeaux-threads" ,sbcl-bordeaux-threads)
2940        ("closer-mop" ,sbcl-closer-mop)
2941        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2942     (arguments
2943      (substitute-keyword-arguments (package-arguments sbcl-cl-cffi-gtk-boot0)
2944        ((#:asd-file _ "") "gobject/cl-cffi-gtk-gobject.asd")
2945        ((#:phases phases)
2946         `(modify-phases ,phases
2947            (add-after 'install 'link-source
2948              ;; Since source is particularly heavy (16MiB+), let's reuse it
2949              ;; across the different components of cl-ffi-gtk.
2950              (lambda* (#:key inputs outputs #:allow-other-keys)
2951                (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
2952                                                  "/share/common-lisp/sbcl-source/"
2953                                                  "cl-cffi-gtk-glib"))
2954                      (out-source (string-append (assoc-ref outputs "out")
2955                                                 "/share/common-lisp/sbcl-source/"
2956                                                 "cl-cffi-gtk-gobject")))
2957                  (delete-file-recursively out-source)
2958                  (symlink glib-source out-source)
2959                  #t)))))))))
2960
2961 (define-public sbcl-cl-cffi-gtk-gio
2962   (package
2963     (inherit sbcl-cl-cffi-gtk-boot0)
2964     (name "sbcl-cl-cffi-gtk-gio")
2965     (inputs
2966      `(("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
2967        ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
2968        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2969     (arguments
2970      (substitute-keyword-arguments (package-arguments sbcl-cl-cffi-gtk-boot0)
2971        ((#:asd-file _ "") "gio/cl-cffi-gtk-gio.asd")
2972        ((#:phases phases)
2973         `(modify-phases ,phases
2974            (add-after 'install 'link-source
2975              ;; Since source is particularly heavy (16MiB+), let's reuse it
2976              ;; across the different components of cl-ffi-gtk.
2977              (lambda* (#:key inputs outputs #:allow-other-keys)
2978                (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
2979                                                  "/share/common-lisp/sbcl-source/"
2980                                                  "cl-cffi-gtk-glib"))
2981                      (out-source (string-append (assoc-ref outputs "out")
2982                                                 "/share/common-lisp/sbcl-source/"
2983                                                 "cl-cffi-gtk-gio")))
2984                  (delete-file-recursively out-source)
2985                  (symlink glib-source out-source)
2986                  #t)))))))))
2987
2988 (define-public sbcl-cl-cffi-gtk-cairo
2989   (package
2990     (inherit sbcl-cl-cffi-gtk-boot0)
2991     (name "sbcl-cl-cffi-gtk-cairo")
2992     (inputs
2993      `(("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
2994        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
2995     (arguments
2996      (substitute-keyword-arguments (package-arguments sbcl-cl-cffi-gtk-boot0)
2997        ((#:asd-file _ "") "cairo/cl-cffi-gtk-cairo.asd")
2998        ((#:phases phases)
2999         `(modify-phases ,phases
3000            (add-after 'install 'link-source
3001              ;; Since source is particularly heavy (16MiB+), let's reuse it
3002              ;; across the different components of cl-ffi-gtk.
3003              (lambda* (#:key inputs outputs #:allow-other-keys)
3004                (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
3005                                                  "/share/common-lisp/sbcl-source/"
3006                                                  "cl-cffi-gtk-glib"))
3007                      (out-source (string-append (assoc-ref outputs "out")
3008                                                 "/share/common-lisp/sbcl-source/"
3009                                                 "cl-cffi-gtk-cairo")))
3010                  (delete-file-recursively out-source)
3011                  (symlink glib-source out-source)
3012                  #t)))))))))
3013
3014 (define-public sbcl-cl-cffi-gtk-pango
3015   (package
3016     (inherit sbcl-cl-cffi-gtk-boot0)
3017     (name "sbcl-cl-cffi-gtk-pango")
3018     (inputs
3019      `(("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
3020        ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
3021        ("cl-cffi-gtk-cairo" ,sbcl-cl-cffi-gtk-cairo)
3022        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
3023     (arguments
3024      (substitute-keyword-arguments (package-arguments sbcl-cl-cffi-gtk-boot0)
3025        ((#:asd-file _ "") "pango/cl-cffi-gtk-pango.asd")
3026        ((#:phases phases)
3027         `(modify-phases ,phases
3028            (add-after 'install 'link-source
3029              ;; Since source is particularly heavy (16MiB+), let's reuse it
3030              ;; across the different components of cl-ffi-gtk.
3031              (lambda* (#:key inputs outputs #:allow-other-keys)
3032                (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
3033                                                  "/share/common-lisp/sbcl-source/"
3034                                                  "cl-cffi-gtk-glib"))
3035                      (out-source (string-append (assoc-ref outputs "out")
3036                                                 "/share/common-lisp/sbcl-source/"
3037                                                 "cl-cffi-gtk-pango")))
3038                  (delete-file-recursively out-source)
3039                  (symlink glib-source out-source)
3040                  #t)))))))))
3041
3042 (define-public sbcl-cl-cffi-gtk-gdk-pixbuf
3043   (package
3044     (inherit sbcl-cl-cffi-gtk-boot0)
3045     (name "sbcl-cl-cffi-gtk-gdk-pixbuf")
3046     (inputs
3047      `(("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
3048        ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
3049        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
3050     (arguments
3051      (substitute-keyword-arguments (package-arguments sbcl-cl-cffi-gtk-boot0)
3052        ((#:asd-file _ "") "gdk-pixbuf/cl-cffi-gtk-gdk-pixbuf.asd")
3053        ((#:phases phases)
3054         `(modify-phases ,phases
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      `(("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
3075        ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
3076        ("cl-cffi-gtk-gio" ,sbcl-cl-cffi-gtk-gio)
3077        ("cl-cffi-gtk-gdk-pixbuf" ,sbcl-cl-cffi-gtk-gdk-pixbuf)
3078        ("cl-cffi-gtk-cairo" ,sbcl-cl-cffi-gtk-cairo)
3079        ("cl-cffi-gtk-pango" ,sbcl-cl-cffi-gtk-pango)
3080        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
3081     (arguments
3082      (substitute-keyword-arguments (package-arguments sbcl-cl-cffi-gtk-boot0)
3083        ((#:asd-file _ "") "gdk/cl-cffi-gtk-gdk.asd")
3084        ((#:phases phases)
3085         `(modify-phases ,phases
3086            (add-after 'install 'link-source
3087              ;; Since source is particularly heavy (16MiB+), let's reuse it
3088              ;; across the different components of cl-ffi-gtk.
3089              (lambda* (#:key inputs outputs #:allow-other-keys)
3090                (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
3091                                                  "/share/common-lisp/sbcl-source/"
3092                                                  "cl-cffi-gtk-glib"))
3093                      (out-source (string-append (assoc-ref outputs "out")
3094                                                 "/share/common-lisp/sbcl-source/"
3095                                                 "cl-cffi-gtk-gdk")))
3096                  (delete-file-recursively out-source)
3097                  (symlink glib-source out-source)
3098                  #t)))))))))
3099
3100 (define-public sbcl-cl-cffi-gtk
3101   (package
3102     (inherit sbcl-cl-cffi-gtk-boot0)
3103     (name "sbcl-cl-cffi-gtk")
3104     (inputs
3105      `(("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
3106        ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
3107        ("cl-cffi-gtk-gio" ,sbcl-cl-cffi-gtk-gio)
3108        ("cl-cffi-gtk-gdk" ,sbcl-cl-cffi-gtk-gdk)
3109        ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
3110     (native-inputs
3111      `(("fiveam" ,sbcl-fiveam)))
3112     (arguments
3113      (substitute-keyword-arguments (package-arguments sbcl-cl-cffi-gtk-boot0)
3114        ((#:asd-file _ "") "gtk/cl-cffi-gtk.asd")
3115        ((#:test-asd-file _ "") "test/cl-cffi-gtk-test.asd")
3116        ;; TODO: Tests fail with memory fault.
3117        ;; See https://github.com/Ferada/cl-cffi-gtk/issues/24.
3118        ((#:tests? _ #f) #f)
3119        ((#:phases phases)
3120         `(modify-phases ,phases
3121            (add-after 'install 'link-source
3122              ;; Since source is particularly heavy (16MiB+), let's reuse it
3123              ;; across the different components of cl-ffi-gtk.
3124              (lambda* (#:key inputs outputs #:allow-other-keys)
3125                (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
3126                                                  "/share/common-lisp/sbcl-source/"
3127                                                  "cl-cffi-gtk-glib"))
3128                      (out-source (string-append (assoc-ref outputs "out")
3129                                                 "/share/common-lisp/sbcl-source/"
3130                                                 "cl-cffi-gtk")))
3131                  (delete-file-recursively out-source)
3132                  (symlink glib-source out-source)
3133                  #t)))))))))
3134
3135 (define-public cl-cffi-gtk
3136   (sbcl-package->cl-source-package sbcl-cl-cffi-gtk))
3137
3138 (define-public sbcl-cl-webkit
3139   (let ((commit "f93cb9697e8813068795fe4dc39ac950d814102d"))
3140     (package
3141       (name "sbcl-cl-webkit")
3142       (version (git-version "2.4" "3" commit))
3143       (source
3144        (origin
3145          (method git-fetch)
3146          (uri (git-reference
3147                (url "https://github.com/joachifm/cl-webkit")
3148                (commit commit)))
3149          (file-name (git-file-name "cl-webkit" version))
3150          (sha256
3151           (base32
3152            "1sjcw08kjpd5h83sms7zcq2nymddjygk9hm2rpgzrl524an9ziwc"))))
3153       (build-system asdf-build-system/sbcl)
3154       (inputs
3155        `(("cffi" ,sbcl-cffi)
3156          ("cl-cffi-gtk" ,sbcl-cl-cffi-gtk)
3157          ("webkitgtk" ,webkitgtk)))
3158       (arguments
3159        `(#:asd-file "webkit2/cl-webkit2.asd"
3160          #:asd-system-name "cl-webkit2"
3161          #:phases
3162          (modify-phases %standard-phases
3163            (add-after 'unpack 'fix-paths
3164              (lambda* (#:key inputs #:allow-other-keys)
3165                (substitute* "webkit2/webkit2.init.lisp"
3166                  (("libwebkit2gtk" all)
3167                   (string-append
3168                    (assoc-ref inputs "webkitgtk") "/lib/" all))))))))
3169       (home-page "https://github.com/joachifm/cl-webkit")
3170       (synopsis "Binding to WebKitGTK+ for Common Lisp")
3171       (description
3172        "@command{cl-webkit} is a binding to WebKitGTK+ for Common Lisp,
3173 currently targeting WebKit version 2.  The WebKitGTK+ library adds web
3174 browsing capabilities to an application, leveraging the full power of the
3175 WebKit browsing engine.")
3176       (license license:expat))))
3177
3178 (define-public cl-webkit
3179   (sbcl-package->cl-source-package sbcl-cl-webkit))
3180
3181 (define-public sbcl-lparallel
3182   (package
3183     (name "sbcl-lparallel")
3184     (version "2.8.4")
3185     (source
3186      (origin
3187        (method git-fetch)
3188        (uri (git-reference
3189              (url "https://github.com/lmj/lparallel/")
3190              (commit (string-append "lparallel-" version))))
3191        (file-name (git-file-name "lparallel" version))
3192        (sha256
3193         (base32
3194          "0g0aylrbbrqsz0ahmwhvnk4cmc2931fllbpcfgzsprwnqqd7vwq9"))))
3195     (build-system asdf-build-system/sbcl)
3196     (inputs
3197      `(("alexandria" ,sbcl-alexandria)
3198        ("bordeaux-threads" ,sbcl-bordeaux-threads)
3199        ("trivial-garbage" ,sbcl-trivial-garbage)))
3200     (home-page "https://lparallel.org/")
3201     (synopsis "Parallelism for Common Lisp")
3202     (description
3203      "@command{lparallel} is a library for parallel programming in Common
3204 Lisp, featuring:
3205
3206 @itemize
3207 @item a simple model of task submission with receiving queue,
3208 @item constructs for expressing fine-grained parallelism,
3209 @item asynchronous condition handling across thread boundaries,
3210 @item parallel versions of map, reduce, sort, remove, and many others,
3211 @item promises, futures, and delayed evaluation constructs,
3212 @item computation trees for parallelizing interconnected tasks,
3213 @item bounded and unbounded FIFO queues,
3214 @item high and low priority tasks,
3215 @item task killing by category,
3216 @item integrated timeouts.
3217 @end itemize\n")
3218     (license license:expat)))
3219
3220 (define-public cl-lparallel
3221   (sbcl-package->cl-source-package sbcl-lparallel))
3222
3223 (define-public ecl-lparallel
3224   (sbcl-package->ecl-package sbcl-lparallel))
3225
3226 (define-public sbcl-cl-markup
3227   (let ((commit "e0eb7debf4bdff98d1f49d0f811321a6a637b390"))
3228     (package
3229       (name "sbcl-cl-markup")
3230       (version (git-version "0.1" "1" commit))
3231       (source
3232        (origin
3233          (method git-fetch)
3234          (uri (git-reference
3235                (url "https://github.com/arielnetworks/cl-markup/")
3236                (commit commit)))
3237          (file-name (git-file-name "cl-markup" version))
3238          (sha256
3239           (base32
3240            "10l6k45971dl13fkdmva7zc6i453lmq9j4xax2ci6pjzlc6xjhp7"))))
3241       (build-system asdf-build-system/sbcl)
3242       (home-page "https://github.com/arielnetworks/cl-markup/")
3243       (synopsis "Markup generation library for Common Lisp")
3244       (description
3245        "A modern markup generation library for Common Lisp that features:
3246
3247 @itemize
3248 @item Fast (even faster through compiling the code)
3249 @item Safety
3250 @item Support for multiple document types (markup, xml, html, html5, xhtml)
3251 @item Output with doctype
3252 @item Direct output to stream
3253 @end itemize\n")
3254       (license license:lgpl3+))))
3255
3256 (define-public cl-markup
3257   (sbcl-package->cl-source-package sbcl-cl-markup))
3258
3259 (define-public ecl-cl-markup
3260   (sbcl-package->ecl-package sbcl-cl-markup))
3261
3262 (define-public sbcl-cl-css
3263   (let ((commit "8fe654c8f0cf95b300718101cce4feb517f78e2f"))
3264     (package
3265       (name "sbcl-cl-css")
3266       (version (git-version "0.1" "1" commit))
3267       (source
3268        (origin
3269          (method git-fetch)
3270          (uri (git-reference
3271                (url "https://github.com/inaimathi/cl-css/")
3272                (commit commit)))
3273          (file-name (git-file-name "cl-css" version))
3274          (sha256
3275           (base32
3276            "1lc42zi2sw11fl2589sc19nr5sd2p0wy7wgvgwaggxa5f3ajhsmd"))))
3277       (build-system asdf-build-system/sbcl)
3278       (home-page "https://github.com/inaimathi/cl-css/")
3279       (synopsis "Non-validating, inline CSS generator for Common Lisp")
3280       (description
3281        "This is a dead-simple, non validating, inline CSS generator for Common
3282 Lisp.  Its goals are axiomatic syntax, simple implementation to support
3283 portability, and boilerplate reduction in CSS.")
3284       (license license:expat))))
3285
3286 (define-public cl-css
3287   (sbcl-package->cl-source-package sbcl-cl-css))
3288
3289 (define-public ecl-cl-css
3290   (sbcl-package->ecl-package sbcl-cl-css))
3291
3292 (define-public sbcl-portable-threads
3293   (let ((commit "c0e61a1faeb0583c80fd3f20b16cc4c555226920"))
3294     (package
3295       (name "sbcl-portable-threads")
3296       (version (git-version "2.3" "1" commit))
3297       (source
3298        (origin
3299          (method git-fetch)
3300          (uri (git-reference
3301                (url "https://github.com/binghe/portable-threads/")
3302                (commit commit)))
3303          (file-name (git-file-name "portable-threads" version))
3304          (sha256
3305           (base32
3306            "03fmxyarc0xf4kavwkfa0a2spkyfrz6hbgbi9y4q7ny5aykdyfaq"))))
3307       (build-system asdf-build-system/sbcl)
3308       (arguments
3309        `(;; Tests seem broken.
3310          #:tests? #f))
3311       (home-page "https://github.com/binghe/portable-threads")
3312       (synopsis "Portable threads (and scheduled and periodic functions) API for Common Lisp")
3313       (description
3314        "Portable Threads (and Scheduled and Periodic Functions) API for Common
3315 Lisp (from GBBopen project).")
3316       (license license:asl2.0))))
3317
3318 (define-public cl-portable-threads
3319   (sbcl-package->cl-source-package sbcl-portable-threads))
3320
3321 (define-public ecl-portable-threada
3322   (sbcl-package->ecl-package sbcl-portable-threads))
3323
3324 (define sbcl-usocket-boot0
3325   ;; usocket's test rely on usocket-server which depends on usocket itself.
3326   ;; We break this cyclic dependency with -boot0 that packages usocket.
3327   (package
3328     (name "sbcl-usocket-boot0")
3329     (version "0.8.3")
3330     (source
3331      (origin
3332        (method git-fetch)
3333        (uri (git-reference
3334              (url "https://github.com/usocket/usocket/")
3335              (commit (string-append "v" version))))
3336        (file-name (git-file-name "usocket" version))
3337        (sha256
3338         (base32
3339          "0x746wr2324l6bn7skqzgkzcbj5kd0zp2ck0c8rldrw0rzabg826"))))
3340     (build-system asdf-build-system/sbcl)
3341     (inputs
3342      `(("split-sequence" ,sbcl-split-sequence)))
3343     (arguments
3344      `(#:tests? #f
3345        #:asd-system-name "usocket"))
3346     (home-page "https://common-lisp.net/project/usocket/")
3347     (synopsis "Universal socket library for Common Lisp (server side)")
3348     (description
3349      "This library strives to provide a portable TCP/IP and UDP/IP socket
3350 interface for as many Common Lisp implementations as possible, while keeping
3351 the abstraction and portability layer as thin as possible.")
3352     (license license:expat)))
3353
3354 (define-public sbcl-usocket-server
3355   (package
3356     (inherit sbcl-usocket-boot0)
3357     (name "sbcl-usocket-server")
3358     (inputs
3359      `(("bordeaux-threads" ,sbcl-bordeaux-threads)
3360        ("usocket" ,sbcl-usocket-boot0)))
3361     (arguments
3362      '(#:asd-system-name "usocket-server"))
3363     (synopsis "Universal socket library for Common Lisp (server side)")))
3364
3365 (define-public cl-usocket-server
3366   (sbcl-package->cl-source-package sbcl-usocket-server))
3367
3368 (define-public ecl-socket-server
3369   (sbcl-package->ecl-package sbcl-usocket-server))
3370
3371 (define-public sbcl-usocket
3372   (package
3373     (inherit sbcl-usocket-boot0)
3374     (name "sbcl-usocket")
3375     (arguments
3376      ;; FIXME: Tests need network access?
3377      `(#:tests? #f))
3378     (native-inputs
3379      ;; Testing only.
3380      `(("usocket-server" ,sbcl-usocket-server)
3381        ("rt" ,sbcl-rt)))))
3382
3383 (define-public cl-usocket
3384   (sbcl-package->cl-source-package sbcl-usocket))
3385
3386 (define-public ecl-usocket
3387   (sbcl-package->ecl-package sbcl-usocket))
3388
3389 (define-public sbcl-s-xml
3390   (package
3391     (name "sbcl-s-xml")
3392     (version "3")
3393     (source
3394      (origin
3395        (method url-fetch)
3396        (uri "https://common-lisp.net/project/s-xml/s-xml.tgz")
3397        (sha256
3398         (base32
3399          "061qcr0dzshsa38s5ma4ay924cwak2nq9gy59dw6v9p0qb58nzjf"))))
3400     (build-system asdf-build-system/sbcl)
3401     (home-page "https://common-lisp.net/project/s-xml/")
3402     (synopsis "Simple XML parser implemented in Common Lisp")
3403     (description
3404      "S-XML is a simple XML parser implemented in Common Lisp.  This XML
3405 parser implementation has the following features:
3406
3407 @itemize
3408 @item It works (handling many common XML usages).
3409 @item It is very small (the core is about 700 lines of code, including
3410 comments and whitespace).
3411 @item It has a core API that is simple, efficient and pure functional, much
3412 like that from SSAX (see also http://ssax.sourceforge.net).
3413 @item It supports different DOM models: an XSML-based one, an LXML-based one
3414 and a classic xml-element struct based one.
3415 @item It is reasonably time and space efficient (internally avoiding garbage
3416 generatation as much as possible).
3417 @item It does support CDATA.
3418 @item It should support the same character sets as your Common Lisp
3419 implementation.
3420 @item It does support XML name spaces.
3421 @end itemize
3422
3423 This XML parser implementation has the following limitations:
3424
3425 @itemize
3426 @item It does not support any special tags (like processing instructions).
3427 @item It is not validating, even skips DTD's all together.
3428 @end itemize\n")
3429     (license license:lgpl3+)))
3430
3431 (define-public cl-s-xml
3432   (sbcl-package->cl-source-package sbcl-s-xml))
3433
3434 (define-public ecl-s-xml
3435   (sbcl-package->ecl-package sbcl-s-xml))
3436
3437 (define-public sbcl-s-xml-rpc
3438   (package
3439     (name "sbcl-s-xml-rpc")
3440     (version "7")
3441     (source
3442      (origin
3443        (method url-fetch)
3444        (uri "https://common-lisp.net/project/s-xml-rpc/s-xml-rpc.tgz")
3445        (sha256
3446         (base32
3447          "02z7k163d51v0pzk8mn1xb6h5s6x64gjqkslhwm3a5x26k2gfs11"))))
3448     (build-system asdf-build-system/sbcl)
3449     (inputs
3450      `(("s-xml" ,sbcl-s-xml)))
3451     (home-page "https://common-lisp.net/project/s-xml-rpc/")
3452     (synopsis "Implementation of XML-RPC in Common Lisp for both client and server")
3453     (description
3454      "S-XML-RPC is an implementation of XML-RPC in Common Lisp for both
3455 client and server.")
3456     (license license:lgpl3+)))
3457
3458 (define-public cl-s-xml-rpc
3459   (sbcl-package->cl-source-package sbcl-s-xml-rpc))
3460
3461 (define-public ecl-s-xml-rpc
3462   (sbcl-package->ecl-package sbcl-s-xml-rpc))
3463
3464 (define-public sbcl-trivial-clipboard
3465   (let ((commit "5af3415d1484e6d69a1b5c178f24680d9fd01796"))
3466     (package
3467       (name "sbcl-trivial-clipboard")
3468       (version (git-version "0.0.0.0" "2" commit))
3469       (source
3470        (origin
3471          (method git-fetch)
3472          (uri (git-reference
3473                (url "https://github.com/snmsts/trivial-clipboard")
3474                (commit commit)))
3475          (file-name (git-file-name "trivial-clipboard" version))
3476          (sha256
3477           (base32
3478            "1gb515z5yq6h5548pb1fwhmb0hhq1ssyb78pvxh4alq799xipxs9"))))
3479       (build-system asdf-build-system/sbcl)
3480       (inputs
3481        `(("xclip" ,xclip)))
3482       (native-inputs
3483        `(("fiveam" ,sbcl-fiveam)))
3484       (arguments
3485        `(#:phases
3486          (modify-phases %standard-phases
3487            (add-after 'unpack 'fix-paths
3488              (lambda* (#:key inputs #:allow-other-keys)
3489                (substitute* "src/text.lisp"
3490                  (("\\(executable-find \"xclip\"\\)")
3491                   (string-append "(executable-find \""
3492                                  (assoc-ref inputs "xclip")
3493                                  "/bin/xclip\")"))))))))
3494       (home-page "https://github.com/snmsts/trivial-clipboard")
3495       (synopsis "Access system clipboard in Common Lisp")
3496       (description
3497        "@command{trivial-clipboard} gives access to the system clipboard.")
3498       (license license:expat))))
3499
3500 (define-public cl-trivial-clipboard
3501   (sbcl-package->cl-source-package sbcl-trivial-clipboard))
3502
3503 (define-public ecl-trivial-clipboard
3504   (sbcl-package->ecl-package sbcl-trivial-clipboard))
3505
3506 (define-public sbcl-trivial-backtrace
3507   (let ((commit "ca81c011b86424a381a7563cea3b924f24e6fbeb")
3508         (revision "1"))
3509     (package
3510      (name "sbcl-trivial-backtrace")
3511      (version (git-version "0.0.0" revision commit))
3512      (source
3513       (origin
3514        (method git-fetch)
3515        (uri (git-reference
3516              (url "https://github.com/gwkkwg/trivial-backtrace.git")
3517              (commit commit)))
3518        (file-name (git-file-name "trivial-backtrace" version))
3519        (sha256
3520         (base32 "10p41p43skj6cimdg8skjy7372s8v2xpkg8djjy0l8rm45i654k1"))))
3521      (build-system asdf-build-system/sbcl)
3522      (inputs
3523       `(("sbcl-lift" ,sbcl-lift)))
3524      (arguments
3525       `(#:phases
3526         (modify-phases %standard-phases
3527           (add-after 'check 'delete-test-results
3528             (lambda* (#:key outputs #:allow-other-keys)
3529               (let ((test-results (string-append (assoc-ref outputs "out")
3530                                                  "/share/common-lisp/"
3531                                                  (%lisp-type) "-source"
3532                                                  "/trivial-backtrace"
3533                                                  "/test-results")))
3534                 (when (file-exists? test-results)
3535                   (delete-file-recursively test-results)))
3536               #t)))))
3537      (home-page "https://common-lisp.net/project/trivial-backtrace/")
3538      (synopsis "Portable simple API to work with backtraces in Common Lisp")
3539      (description
3540       "One of the many things that didn't quite get into the Common Lisp
3541 standard was how to get a Lisp to output its call stack when something has
3542 gone wrong.  As such, each Lisp has developed its own notion of what to
3543 display, how to display it, and what sort of arguments can be used to
3544 customize it.  @code{trivial-backtrace} is a simple solution to generating a
3545 backtrace portably.")
3546      (license license:expat))))
3547
3548 (define-public cl-trivial-backtrace
3549   (sbcl-package->cl-source-package sbcl-trivial-backtrace))
3550
3551 (define-public sbcl-rfc2388
3552   (let ((commit "591bcf7e77f2c222c43953a80f8c297751dc0c4e")
3553         (revision "1"))
3554     (package
3555      (name "sbcl-rfc2388")
3556      (version (git-version "0.0.0" revision commit))
3557      (source
3558       (origin
3559        (method git-fetch)
3560        (uri (git-reference
3561              (url "https://github.com/jdz/rfc2388.git")
3562              (commit commit)))
3563        (file-name (git-file-name "rfc2388" version))
3564        (sha256
3565         (base32 "0phh5n3clhl9ji8jaxrajidn22d3f0aq87mlbfkkxlnx2pnw694k"))))
3566      (build-system asdf-build-system/sbcl)
3567      (home-page "https://github.com/jdz/rfc2388/")
3568      (synopsis "An implementation of RFC 2388 in Common Lisp")
3569      (description
3570       "This package contains an implementation of RFC 2388, which is used to
3571 process form data posted with HTTP POST method using enctype
3572 \"multipart/form-data\".")
3573      (license license:bsd-2))))
3574
3575 (define-public cl-rfc2388
3576   (sbcl-package->cl-source-package sbcl-rfc2388))
3577
3578 (define-public sbcl-md5
3579   (package
3580     (name "sbcl-md5")
3581     (version "2.0.4")
3582     (source
3583      (origin
3584        (method url-fetch)
3585        (uri (string-append
3586              "https://github.com/pmai/md5/archive/release-" version ".tar.gz"))
3587        (sha256
3588         (base32 "19yl9n0pjdz5gw4qi711lka97xcd9f81ylg434hk7jwn9f2s6w11"))))
3589     (build-system asdf-build-system/sbcl)
3590     (home-page "https://github.com/pmai/md5")
3591     (synopsis
3592      "Common Lisp implementation of the MD5 Message-Digest Algorithm (RFC 1321)")
3593     (description
3594      "This package implements The MD5 Message-Digest Algorithm, as defined in
3595 RFC 1321 by R. Rivest, published April 1992.")
3596     (license license:public-domain)))
3597
3598 (define-public cl-md5
3599   (sbcl-package->cl-source-package sbcl-md5))
3600
3601 (define-public sbcl-cl+ssl
3602   (let ((commit "701e645081e6533a3f0f0b3ac86389d6f506c4b5")
3603         (revision "1"))
3604     (package
3605       (name "sbcl-cl+ssl")
3606       (version (git-version "0.0.0" revision commit))
3607       (source
3608        (origin
3609          (method git-fetch)
3610          (uri (git-reference
3611                (url "https://github.com/cl-plus-ssl/cl-plus-ssl.git")
3612                (commit commit)))
3613          (file-name (git-file-name "cl+ssl" version))
3614          (sha256
3615           (base32 "0nfl275nwhff3m25872y388cydz14kqb6zbwywa6nj85r9k8bgs0"))))
3616       (build-system asdf-build-system/sbcl)
3617       (arguments
3618        '(#:phases
3619          (modify-phases %standard-phases
3620            (add-after 'unpack 'fix-paths
3621              (lambda* (#:key inputs #:allow-other-keys)
3622                (substitute* "src/reload.lisp"
3623                  (("libssl.so" all)
3624                   (string-append
3625                    (assoc-ref inputs "openssl") "/lib/" all))))))))
3626       (inputs
3627        `(("openssl" ,openssl)
3628          ("sbcl-cffi" ,sbcl-cffi)
3629          ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)
3630          ("sbcl-flexi-streams" ,sbcl-flexi-streams)
3631          ("sbcl-bordeaux-threads" ,sbcl-bordeaux-threads)
3632          ("sbcl-trivial-garbage" ,sbcl-trivial-garbage)
3633          ("sbcl-alexandria" ,sbcl-alexandria)
3634          ("sbcl-trivial-features" ,sbcl-trivial-features)))
3635       (home-page "https://common-lisp.net/project/cl-plus-ssl/")
3636       (synopsis "Common Lisp bindings to OpenSSL")
3637       (description
3638        "This library is a fork of SSL-CMUCL.  The original SSL-CMUCL source
3639 code was written by Eric Marsden and includes contributions by Jochen Schmidt.
3640 Development into CL+SSL was done by David Lichteblau.")
3641       (license license:expat))))
3642
3643 (define-public cl-cl+ssl
3644   (sbcl-package->cl-source-package sbcl-cl+ssl))
3645
3646 (define-public sbcl-kmrcl
3647   (let ((version "1.109.0")
3648         (commit "5260068b2eb735af6796740c2db4955afac21636")
3649         (revision "1"))
3650     (package
3651       (name "sbcl-kmrcl")
3652       (version (git-version version revision commit))
3653       (source
3654        (origin
3655          (method git-fetch)
3656          (uri (git-reference
3657                (url "http://git.kpe.io/kmrcl.git/")
3658                (commit commit)))
3659          (file-name (git-file-name name version))
3660          (sha256
3661           (base32 "1va7xjgzfv674bpsli674i7zj3f7wg5kxic41kz18r6hh4n52dfv"))))
3662       (build-system asdf-build-system/sbcl)
3663       (arguments
3664        ;; Tests fail with: :FORCE and :FORCE-NOT arguments not allowed in a
3665        ;; nested call to ASDF/OPERATE:OPERATE unless identically to toplevel
3666        '(#:tests? #f))
3667       (inputs
3668        `(("sbcl-rt" ,sbcl-rt)))
3669       (home-page "http://files.kpe.io/kmrcl/")
3670       (synopsis "General utilities for Common Lisp programs")
3671       (description
3672        "KMRCL is a collection of utilities used by a number of Kevin
3673 Rosenberg's CL packages.")
3674       (license license:llgpl))))
3675
3676 (define-public cl-kmrcl
3677   (sbcl-package->cl-source-package sbcl-kmrcl))
3678
3679 (define-public sbcl-cl-base64
3680   (package
3681     (name "sbcl-cl-base64")
3682     (version "3.3.4")
3683     (source
3684      (origin
3685        (method url-fetch)
3686        (uri (string-append "http://files.kpe.io/cl-base64/cl-base64-"
3687                            version ".tar.gz"))
3688        (sha256
3689         (base32 "0pl4zwn5bf18dm8fh1kn1yshaa6kpmfrjyb33z9mq4raqmj3xpv2"))))
3690     (build-system asdf-build-system/sbcl)
3691     (arguments
3692      ;; Tests fail with: :FORCE and :FORCE-NOT arguments not allowed
3693      ;; in a nested call to ASDF/OPERATE:OPERATE unless identically
3694      ;; to toplevel
3695      '(#:tests? #f))
3696     (inputs
3697      `(("sbcl-ptester" ,sbcl-ptester)
3698        ("sbcl-kmrcl" ,sbcl-kmrcl)))
3699     (home-page "http://files.kpe.io/cl-base64/")
3700     (synopsis
3701      "Common Lisp package to encode and decode base64 with URI support")
3702     (description
3703      "This package provides highly optimized base64 encoding and decoding.
3704 Besides conversion to and from strings, integer conversions are supported.
3705 Encoding with Uniform Resource Identifiers is supported by using a modified
3706 encoding table that uses only URI-compatible characters.")
3707     (license license:bsd-3)))
3708
3709 (define-public cl-base64
3710   (sbcl-package->cl-source-package sbcl-cl-base64))
3711
3712 (define-public sbcl-chunga
3713   (package
3714     (name "sbcl-chunga")
3715     (version "1.1.7")
3716     (source
3717      (origin
3718        (method git-fetch)
3719        (uri (git-reference
3720               (url "https://github.com/edicl/chunga.git")
3721               (commit (string-append "v" version))))
3722        (file-name (git-file-name name version))
3723        (sha256
3724         (base32 "0jzn3nyb3f22gm983rfk99smqs3mhb9ivjmasvhq9qla5cl9pyhd"))))
3725     (build-system asdf-build-system/sbcl)
3726     (inputs
3727      `(("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)))
3728     (home-page "https://edicl.github.io/chunga/")
3729     (synopsis "Portable chunked streams for Common Lisp")
3730     (description
3731      "Chunga implements streams capable of chunked encoding on demand as
3732 defined in RFC 2616.")
3733     (license license:bsd-2)))
3734
3735 (define-public cl-chunga
3736   (sbcl-package->cl-source-package sbcl-chunga))
3737
3738 (define-public sbcl-cl-who
3739   (let ((version "1.1.4")
3740         (commit "2c08caa4bafba720409af9171feeba3f32e86d32")
3741         (revision "1"))
3742     (package
3743       (name "sbcl-cl-who")
3744       (version (git-version version revision commit))
3745       (source
3746        (origin
3747          (method git-fetch)
3748          (uri (git-reference
3749                (url "https://github.com/edicl/cl-who.git")
3750                (commit commit)))
3751          (file-name (git-file-name name version))
3752          (sha256
3753           (base32
3754            "0yjb6sr3yazm288m318kqvj9xk8rm9n1lpimgf65ymqv0i5agxsb"))))
3755       (build-system asdf-build-system/sbcl)
3756       (native-inputs
3757        `(("sbcl-flexi-streams" ,sbcl-flexi-streams)))
3758       (home-page "https://edicl.github.io/cl-who/")
3759       (synopsis "Yet another Lisp markup language")
3760       (description
3761        "There are plenty of Lisp Markup Languages out there - every Lisp
3762 programmer seems to write at least one during his career - and CL-WHO (where
3763 WHO means \"with-html-output\" for want of a better acronym) is probably just
3764 as good or bad as the next one.")
3765       (license license:bsd-2))))
3766
3767 (define-public cl-cl-who
3768   (sbcl-package->cl-source-package sbcl-cl-who))
3769
3770 (define-public sbcl-chipz
3771   (let ((version "0.8")
3772         (commit "75dfbc660a5a28161c57f115adf74c8a926bfc4d")
3773         (revision "1"))
3774     (package
3775       (name "sbcl-chipz")
3776       (version (git-version version revision commit))
3777       (source
3778        (origin
3779          (method git-fetch)
3780          (uri (git-reference
3781                (url "https://github.com/froydnj/chipz.git")
3782                (commit commit)))
3783          (file-name (git-file-name name version))
3784          (sha256
3785           (base32
3786            "0plx4rs39zbs4gjk77h4a2q11zpy75fh9v8hnxrvsf8fnakajhwg"))))
3787       (build-system asdf-build-system/sbcl)
3788       (native-inputs
3789        `(("sbcl-flexi-streams" ,sbcl-flexi-streams)))
3790       (home-page "http://method-combination.net/lisp/chipz/")
3791       (synopsis
3792        "Common Lisp library for decompressing deflate, zlib, gzip, and bzip2
3793 data")
3794       (description
3795        "DEFLATE data, defined in RFC1951, forms the core of popular
3796 compression formats such as zlib (RFC 1950) and gzip (RFC 1952).  As such,
3797 Chipz also provides for decompressing data in those formats as well.  BZIP2 is
3798 the format used by the popular compression tool bzip2.")
3799       ;; The author describes it as "MIT-like"
3800       (license license:expat))))
3801
3802 (define-public cl-chipz
3803   (sbcl-package->cl-source-package sbcl-chipz))
3804
3805 (define-public sbcl-drakma
3806   (package
3807     (name "sbcl-drakma")
3808     (version "2.0.7")
3809     (source
3810      (origin
3811        (method git-fetch)
3812        (uri (git-reference
3813              (url "https://github.com/edicl/drakma.git")
3814              (commit (string-append "v" version))))
3815        (file-name (git-file-name name version))
3816        (sha256
3817         (base32
3818          "1441idnyif9xzx3ln1p3fg36k2v9h4wasjqrzc8y52j61420qpci"))))
3819     (build-system asdf-build-system/sbcl)
3820     (inputs
3821      `(("sbcl-puri" ,sbcl-puri)
3822        ("sbcl-cl-base64" ,sbcl-cl-base64)
3823        ("sbcl-chunga" ,sbcl-chunga)
3824        ("sbcl-flexi-streams" ,sbcl-flexi-streams)
3825        ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
3826        ("sbcl-chipz" ,sbcl-chipz)
3827        ("sbcl-usocket" ,sbcl-usocket)
3828        ("sbcl-cl+ssl" ,sbcl-cl+ssl)))
3829     (native-inputs
3830      `(("sbcl-fiveam" ,sbcl-fiveam)))
3831     (home-page "https://edicl.github.io/drakma/")
3832     (synopsis "HTTP client written in Common Lisp")
3833     (description
3834      "Drakma is a full-featured HTTP client implemented in Common Lisp.  It
3835 knows how to handle HTTP/1.1 chunking, persistent connections, re-usable
3836 sockets, SSL, continuable uploads, file uploads, cookies, and more.")
3837     (license license:bsd-2)))
3838
3839 (define-public cl-drakma
3840   (sbcl-package->cl-source-package sbcl-drakma))
3841
3842 (define-public ecl-drakma
3843   (sbcl-package->ecl-package sbcl-drakma))
3844
3845 (define-public sbcl-hunchentoot
3846   (package
3847     (name "sbcl-hunchentoot")
3848     (version "1.2.38")
3849     (source
3850      (origin
3851        (method git-fetch)
3852        (uri (git-reference
3853              (url "https://github.com/edicl/hunchentoot.git")
3854              (commit (string-append "v" version))))
3855        (file-name (git-file-name "hunchentoot" version))
3856        (sha256
3857         (base32 "1anpcad7w045m4rsjs1f3xdhjwx5cppq1h0vlb3q7dz81fi3i6yq"))))
3858     (build-system asdf-build-system/sbcl)
3859     (native-inputs
3860      `(("sbcl-cl-who" ,sbcl-cl-who)
3861        ("sbcl-drakma" ,sbcl-drakma)))
3862     (inputs
3863      `(("sbcl-chunga" ,sbcl-chunga)
3864        ("sbcl-cl-base64" ,sbcl-cl-base64)
3865        ("sbcl-cl-fad" ,sbcl-cl-fad)
3866        ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
3867        ("sbcl-flexi-streams" ,sbcl-flexi-streams)
3868        ("sbcl-cl+ssl" ,sbcl-cl+ssl)
3869        ("sbcl-md5" ,sbcl-md5)
3870        ("sbcl-rfc2388" ,sbcl-rfc2388)
3871        ("sbcl-trivial-backtrace" ,sbcl-trivial-backtrace)
3872        ("sbcl-usocket" ,sbcl-usocket)))
3873     (home-page "https://edicl.github.io/hunchentoot/")
3874     (synopsis "Web server written in Common Lisp")
3875     (description
3876      "Hunchentoot is a web server written in Common Lisp and at the same
3877 time a toolkit for building dynamic websites.  As a stand-alone web server,
3878 Hunchentoot is capable of HTTP/1.1 chunking (both directions), persistent
3879 connections (keep-alive), and SSL.")
3880     (license license:bsd-2)))
3881
3882 (define-public cl-hunchentoot
3883   (sbcl-package->cl-source-package sbcl-hunchentoot))
3884
3885 (define-public sbcl-trivial-types
3886   (package
3887     (name "sbcl-trivial-types")
3888     (version "0.0.1")
3889     (source
3890      (origin
3891        (method git-fetch)
3892        (uri (git-reference
3893              (url "https://github.com/m2ym/trivial-types.git")
3894              (commit "ee869f2b7504d8aa9a74403641a5b42b16f47d88")))
3895        (file-name (git-file-name name version))
3896        (sha256
3897         (base32 "1s4cp9bdlbn8447q7w7f1wkgwrbvfzp20mgs307l5pxvdslin341"))))
3898     (build-system asdf-build-system/sbcl)
3899     (home-page "https://github.com/m2ym/trivial-types")
3900     (synopsis "Trivial type definitions for Common Lisp")
3901     (description
3902      "TRIVIAL-TYPES provides missing but important type definitions such as
3903 PROPER-LIST, ASSOCIATION-LIST, PROPERTY-LIST and TUPLE.")
3904     (license license:llgpl)))
3905
3906 (define-public cl-trivial-types
3907   (sbcl-package->cl-source-package sbcl-trivial-types))
3908
3909 (define-public sbcl-cl-syntax
3910   (package
3911     (name "sbcl-cl-syntax")
3912     (version "0.0.3")
3913     (source
3914      (origin
3915        (method git-fetch)
3916        (uri (git-reference
3917              (url "https://github.com/m2ym/cl-syntax.git")
3918              (commit "03f0c329bbd55b8622c37161e6278366525e2ccc")))
3919        (file-name (git-file-name "cl-syntax" version))
3920        (sha256
3921         (base32 "17ran8xp77asagl31xv8w819wafh6whwfc9p6dgx22ca537gyl4y"))))
3922     (build-system asdf-build-system/sbcl)
3923     (arguments
3924      '(#:asd-file "cl-syntax.asd"
3925        #:asd-system-name "cl-syntax"))
3926     (inputs `(("sbcl-trivial-types" ,sbcl-trivial-types)
3927               ("sbcl-named-readtables" ,sbcl-named-readtables)))
3928     (home-page "https://github.com/m2ym/cl-syntax")
3929     (synopsis "Reader Syntax Coventions for Common Lisp and SLIME")
3930     (description
3931      "CL-SYNTAX provides Reader Syntax Coventions for Common Lisp and SLIME.")
3932     (license license:llgpl)))
3933
3934 (define-public cl-syntax
3935   (sbcl-package->cl-source-package sbcl-cl-syntax))
3936
3937 (define-public sbcl-cl-annot
3938   (let ((commit "c99e69c15d935eabc671b483349a406e0da9518d")
3939         (revision "1"))
3940     (package
3941       (name "sbcl-cl-annot")
3942       (version (git-version "0.0.0" revision commit))
3943       (source
3944        (origin
3945          (method git-fetch)
3946          (uri (git-reference
3947                (url "https://github.com/m2ym/cl-annot.git")
3948                (commit commit)))
3949          (file-name (git-file-name name version))
3950          (sha256
3951           (base32 "1wq1gs9jjd5m6iwrv06c2d7i5dvqsfjcljgbspfbc93cg5xahk4n"))))
3952       (build-system asdf-build-system/sbcl)
3953     (arguments
3954      '(#:asd-file "cl-annot.asd"
3955        #:asd-system-name "cl-annot"))
3956       (inputs
3957        `(("sbcl-alexandria" ,sbcl-alexandria)))
3958       (home-page "https://github.com/m2ym/cl-annot")
3959       (synopsis "Python-like Annotation Syntax for Common Lisp.")
3960       (description
3961        "@code{cl-annot} is an general annotation library for Common Lisp.")
3962       (license license:llgpl))))
3963
3964 (define-public cl-annot
3965   (sbcl-package->cl-source-package sbcl-cl-annot))
3966
3967 (define-public sbcl-cl-syntax-annot
3968   (package
3969     (inherit sbcl-cl-syntax)
3970     (name "sbcl-cl-syntax-annot")
3971     (arguments
3972      '(#:asd-file "cl-syntax-annot.asd"
3973        #:asd-system-name "cl-syntax-annot"))
3974     (inputs
3975      `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
3976        ("sbcl-cl-annot" ,sbcl-cl-annot)))
3977     (synopsis "Common Lisp reader Syntax for cl-annot")
3978     (description
3979      "CL-SYNTAX provides reader syntax coventions for Common Lisp and
3980 @code{cl-annot}.")))
3981
3982 (define-public cl-syntax-annot
3983   (sbcl-package->cl-source-package sbcl-cl-syntax-annot))
3984
3985 (define-public sbcl-cl-syntax-interpol
3986   (package
3987     (inherit sbcl-cl-syntax)
3988     (name "sbcl-cl-syntax-interpol")
3989     (arguments
3990      '(#:asd-file "cl-syntax-interpol.asd"
3991        #:asd-system-name "cl-syntax-interpol"))
3992     (inputs
3993      `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
3994        ("sbcl-cl-interpol" ,sbcl-cl-interpol)))
3995     (synopsis "Common Lisp reader Syntax for cl-interpol")
3996     (description
3997      "CL-SYNTAX provides reader syntax coventions for Common Lisp and
3998 @code{cl-interpol}.")))
3999
4000 (define-public cl-syntax-interpol
4001   (sbcl-package->cl-source-package sbcl-cl-syntax-interpol))
4002
4003 (define-public sbcl-cl-utilities
4004   (let ((commit "dce2d2f6387091ea90357a130fa6d13a6776884b")
4005         (revision "1"))
4006     (package
4007       (name "sbcl-cl-utilities")
4008       (version (git-version "0.0.0" revision commit))
4009       (source
4010        (origin
4011          (method url-fetch)
4012          (uri
4013           (string-append
4014            "https://gitlab.common-lisp.net/cl-utilities/cl-utilities/-/"
4015            "archive/" commit "/cl-utilities-" commit ".tar.gz"))
4016          (sha256
4017           (base32 "1r46v730yf96nk2vb24qmagv9x96xvd08abqwhf02ghgydv1a7z2"))))
4018       (build-system asdf-build-system/sbcl)
4019       (arguments
4020        '(#:asd-file "cl-utilities.asd"
4021          #:asd-system-name "cl-utilities"
4022          #:phases
4023          (modify-phases %standard-phases
4024            (add-after 'unpack 'fix-paths
4025              (lambda* (#:key inputs #:allow-other-keys)
4026                (substitute* "rotate-byte.lisp"
4027                  (("in-package :cl-utilities)" all)
4028                   "in-package :cl-utilities)\n\n#+sbcl\n(require :sb-rotate-byte)")))))))
4029       (home-page "http://common-lisp.net/project/cl-utilities")
4030       (synopsis "A collection of semi-standard utilities")
4031       (description
4032        "On Cliki.net <http://www.cliki.net/Common%20Lisp%20Utilities>, there
4033 is a collection of Common Lisp Utilities, things that everybody writes since
4034 they're not part of the official standard.  There are some very useful things
4035 there; the only problems are that they aren't implemented as well as you'd
4036 like (some aren't implemented at all) and they aren't conveniently packaged
4037 and maintained.  It takes quite a bit of work to carefully implement utilities
4038 for common use, commented and documented, with error checking placed
4039 everywhere some dumb user might make a mistake.")
4040       (license license:public-domain))))
4041
4042 (define-public cl-utilities
4043   (sbcl-package->cl-source-package sbcl-cl-utilities))
4044
4045 (define-public sbcl-map-set
4046   (let ((commit "7b4b545b68b8")
4047         (revision "1"))
4048     (package
4049       (name "sbcl-map-set")
4050       (version (git-version "0.0.0" revision commit))
4051       (source
4052        (origin
4053          (method url-fetch)
4054          (uri (string-append
4055                "https://bitbucket.org/tarballs_are_good/map-set/get/"
4056                commit ".tar.gz"))
4057          (sha256
4058           (base32 "1sx5j5qdsy5fklspfammwb16kjrhkggdavm922a9q86jm5l0b239"))))
4059       (build-system asdf-build-system/sbcl)
4060       (home-page "https://bitbucket.org/tarballs_are_good/map-set")
4061       (synopsis "Set-like data structure")
4062       (description
4063        "Implementation of a set-like data structure with constant time
4064 addition, removal, and random selection.")
4065       (license license:bsd-3))))
4066
4067 (define-public cl-map-set
4068   (sbcl-package->cl-source-package sbcl-map-set))
4069
4070 (define-public sbcl-quri
4071   (let ((commit "b53231c5f19446dd7c24b15a249fefa45ae94f9a")
4072         (revision "2"))
4073     (package
4074       (name "sbcl-quri")
4075       (version (git-version "0.1.0" revision commit))
4076       (source
4077        (origin
4078          (method git-fetch)
4079          (uri (git-reference
4080                (url "https://github.com/fukamachi/quri.git")
4081                (commit commit)))
4082          (file-name (git-file-name name version))
4083          (sha256
4084           (base32 "0cansr63m690ymvhway419178mq2sqnmxm4rdxclbsrnjwwbi36m"))))
4085       (build-system asdf-build-system/sbcl)
4086       (arguments
4087        ;; Tests fail with: Component QURI-ASD::QURI-TEST not found,
4088        ;; required by #<SYSTEM "quri">. Why?
4089        '(#:tests? #f))
4090       (native-inputs `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4091                        ("sbcl-prove" ,sbcl-prove)))
4092       (inputs `(("sbcl-babel" ,sbcl-babel)
4093                 ("sbcl-split-sequence" ,sbcl-split-sequence)
4094                 ("sbcl-cl-utilities" ,sbcl-cl-utilities)
4095                 ("sbcl-alexandria" ,sbcl-alexandria)))
4096       (home-page "https://github.com/fukamachi/quri")
4097       (synopsis "Yet another URI library for Common Lisp")
4098       (description
4099        "QURI (pronounced \"Q-ree\") is yet another URI library for Common
4100 Lisp. It is intended to be a replacement of PURI.")
4101       (license license:bsd-3))))
4102
4103 (define-public cl-quri
4104   (sbcl-package->cl-source-package sbcl-quri))
4105
4106 (define-public sbcl-myway
4107   (let ((commit "286230082a11f879c18b93f17ca571c5f676bfb7")
4108         (revision "1"))
4109     (package
4110      (name "sbcl-myway")
4111      (version (git-version "0.1.0" revision commit))
4112      (source
4113       (origin
4114        (method git-fetch)
4115        (uri (git-reference
4116              (url "https://github.com/fukamachi/myway.git")
4117              (commit commit)))
4118        (file-name (git-file-name "myway" version))
4119        (sha256
4120         (base32 "0briia9bk3lbr0frnx39d1qg6i38dm4j6z9w3yga3d40k6df4a90"))))
4121      (build-system asdf-build-system/sbcl)
4122      (arguments
4123       ;; Tests fail with: Component MYWAY-ASD::MYWAY-TEST not found, required
4124       ;; by #<SYSTEM "myway">. Why?
4125       '(#:tests? #f))
4126      (native-inputs
4127       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4128         ("sbcl-prove" ,sbcl-prove)))
4129      (inputs
4130       `(("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
4131         ("sbcl-quri" ,sbcl-quri)
4132         ("sbcl-map-set" ,sbcl-map-set)))
4133      (home-page "https://github.com/fukamachi/myway")
4134      (synopsis "Sinatra-compatible URL routing library for Common Lisp")
4135      (description "My Way is a Sinatra-compatible URL routing library.")
4136      (license license:llgpl))))
4137
4138 (define-public cl-myway
4139   (sbcl-package->cl-source-package sbcl-myway))
4140
4141 (define-public sbcl-xsubseq
4142   (let ((commit "5ce430b3da5cda3a73b9cf5cee4df2843034422b")
4143         (revision "1"))
4144     (package
4145      (name "sbcl-xsubseq")
4146      (version (git-version "0.0.1" revision commit))
4147      (source
4148       (origin
4149        (method git-fetch)
4150        (uri (git-reference
4151              (url "https://github.com/fukamachi/xsubseq")
4152              (commit commit)))
4153        (file-name (git-file-name name version))
4154        (sha256
4155         (base32 "1xz79q0p2mclf3sqjiwf6izdpb6xrsr350bv4mlmdlm6rg5r99px"))))
4156      (build-system asdf-build-system/sbcl)
4157      (arguments
4158       ;; Tests fail with: Component XSUBSEQ-ASD::XSUBSEQ-TEST not found,
4159       ;; required by #<SYSTEM "xsubseq">. Why?
4160       '(#:tests? #f))
4161      (native-inputs
4162       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4163         ("sbcl-prove" ,sbcl-prove)))
4164      (home-page "https://github.com/fukamachi/xsubseq")
4165      (synopsis "Efficient way to use \"subseq\"s in Common Lisp")
4166      (description
4167       "XSubseq provides functions to be able to handle \"subseq\"s more
4168 effieiently.")
4169      (license license:bsd-2))))
4170
4171 (define-public cl-xsubseq
4172   (sbcl-package->cl-source-package sbcl-xsubseq))
4173
4174 (define-public sbcl-smart-buffer
4175   (let ((commit "09b9a9a0b3abaa37abe9a730f5aac2643dca4e62")
4176         (revision "1"))
4177     (package
4178       (name "sbcl-smart-buffer")
4179       (version (git-version "0.0.1" revision commit))
4180       (source
4181        (origin
4182          (method git-fetch)
4183          (uri (git-reference
4184                (url "https://github.com/fukamachi/smart-buffer")
4185                (commit commit)))
4186          (file-name (git-file-name name version))
4187          (sha256
4188           (base32 "0qz1zzxx0wm5ff7gpgsq550a59p0qj594zfmm2rglj97dahj54l7"))))
4189       (build-system asdf-build-system/sbcl)
4190       (arguments
4191        ;; Tests fail with: Component SMART-BUFFER-ASD::SMART-BUFFER-TEST not
4192        ;; found, required by #<SYSTEM "smart-buffer">. Why?
4193        `(#:tests? #f))
4194       (native-inputs
4195        `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4196          ("sbcl-prove" ,sbcl-prove)))
4197       (inputs
4198        `(("sbcl-xsubseq" ,sbcl-xsubseq)
4199          ("sbcl-flexi-streams" ,sbcl-flexi-streams)))
4200       (home-page "https://github.com/fukamachi/smart-buffer")
4201       (synopsis "Smart octets buffer")
4202       (description
4203        "Smart-buffer provides an output buffer which changes the destination
4204 depending on content size.")
4205       (license license:bsd-3))))
4206
4207 (define-public cl-smart-buffer
4208   (sbcl-package->cl-source-package sbcl-smart-buffer))
4209
4210 (define-public sbcl-fast-http
4211   (let ((commit "502a37715dcb8544cc8528b78143a942de662c5a")
4212         (revision "2"))
4213     (package
4214       (name "sbcl-fast-http")
4215       (version (git-version "0.2.0" revision commit))
4216       (source
4217        (origin
4218          (method git-fetch)
4219          (uri (git-reference
4220                (url "https://github.com/fukamachi/fast-http")
4221                (commit commit)))
4222          (file-name (git-file-name name version))
4223          (sha256
4224           (base32 "0al2g7g219jjljsf7b23pbilpgacxy5as5gs2nqf76b5qni396mi"))))
4225       (build-system asdf-build-system/sbcl)
4226       (arguments
4227        ;; Tests fail with: Component FAST-HTTP-ASD::FAST-HTTP-TEST not found,
4228        ;; required by #<SYSTEM "fast-http">. Why?
4229        `(#:tests? #f))
4230       (native-inputs
4231        `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4232          ("sbcl-prove" ,sbcl-prove)
4233          ("cl-syntax-interpol" ,sbcl-cl-syntax-interpol)))
4234       (inputs
4235        `(("sbcl-alexandria" ,sbcl-alexandria)
4236          ("sbcl-proc-parse" ,sbcl-proc-parse)
4237          ("sbcl-xsubseq" ,sbcl-xsubseq)
4238          ("sbcl-smart-buffer" ,sbcl-smart-buffer)
4239          ("sbcl-cl-utilities" ,sbcl-cl-utilities)))
4240       (home-page "https://github.com/fukamachi/fast-http")
4241       (synopsis "HTTP request/response parser for Common Lisp")
4242       (description
4243        "@code{fast-http} is a HTTP request/response protocol parser for Common
4244 Lisp.")
4245       ;; Author specified the MIT license
4246       (license license:expat))))
4247
4248 (define-public cl-fast-http
4249   (sbcl-package->cl-source-package sbcl-fast-http))
4250
4251 (define-public sbcl-static-vectors
4252   (package
4253     (name "sbcl-static-vectors")
4254     (version "1.8.4")
4255     (source
4256      (origin
4257        (method git-fetch)
4258        (uri (git-reference
4259              (url "https://github.com/sionescu/static-vectors.git")
4260              (commit (string-append "v" version))))
4261        (file-name (git-file-name name version))
4262        (sha256
4263         (base32 "0qvf9z6bhwhm8n45fjwkm7j8dcb58szfvndky65cyn4lpdval7m1"))))
4264     (native-inputs
4265      `(("sbcl-fiveam" ,sbcl-fiveam)))
4266     (inputs
4267      `(("sbcl-cffi-grovel" ,sbcl-cffi-grovel)
4268        ("sbcl-cffi" ,sbcl-cffi)))
4269     (build-system asdf-build-system/sbcl)
4270     (home-page "https://github.com/sionescu/static-vectors")
4271     (synopsis "Allocate SIMPLE-ARRAYs in static memory")
4272     (description
4273      "With @code{static-vectors}, you can create vectors allocated in static
4274 memory.")
4275     (license license:expat)))
4276
4277 (define-public cl-static-vectors
4278   (sbcl-package->cl-source-package sbcl-static-vectors))
4279
4280 (define-public ecl-static-vectors
4281   (sbcl-package->ecl-package sbcl-static-vectors))
4282
4283 (define-public sbcl-marshal
4284   (let ((commit "eff1b15f2b0af2f26f71ad6a4dd5c4beab9299ec")
4285         (revision "1"))
4286     (package
4287      (name "sbcl-marshal")
4288      (version (git-version "1.3.0" revision commit))
4289      (source
4290       (origin
4291        (method git-fetch)
4292        (uri (git-reference
4293              (url "https://github.com/wlbr/cl-marshal.git")
4294              (commit commit)))
4295        (file-name (git-file-name name version))
4296        (sha256
4297         (base32 "08qs6fhk38xpkkjkpcj92mxx0lgy4ygrbbzrmnivdx281syr0gwh"))))
4298      (build-system asdf-build-system/sbcl)
4299      (home-page "https://github.com/wlbr/cl-marshal")
4300      (synopsis "Simple (de)serialization of Lisp datastructures")
4301      (description
4302       "Simple and fast marshalling of Lisp datastructures.  Convert any object
4303 into a string representation, put it on a stream an revive it from there.
4304 Only minimal changes required to make your CLOS objects serializable.")
4305      (license license:expat))))
4306
4307 (define-public cl-marshal
4308   (sbcl-package->cl-source-package sbcl-marshal))
4309
4310 (define-public sbcl-checkl
4311   (let ((commit "80328800d047fef9b6e32dfe6bdc98396aee3cc9")
4312         (revision "1"))
4313     (package
4314       (name "sbcl-checkl")
4315       (version (git-version "0.0.0" revision commit))
4316       (source
4317        (origin
4318          (method git-fetch)
4319          (uri (git-reference
4320                (url "https://github.com/rpav/CheckL.git")
4321                (commit commit)))
4322          (file-name (git-file-name name version))
4323          (sha256
4324           (base32 "0bpisihx1gay44xmyr1dmhlwh00j0zzi04rp9fy35i95l2r4xdlx"))))
4325       (build-system asdf-build-system/sbcl)
4326       (arguments
4327        ;; Error while trying to load definition for system checkl-test from
4328        ;; pathname [...]/checkl-test.asd: The function CHECKL:DEFINE-TEST-OP
4329        ;; is undefined.
4330        '(#:tests? #f))
4331       (native-inputs
4332        `(("sbcl-fiveam" ,sbcl-fiveam)))
4333       (inputs
4334        `(("sbcl-marshal" ,sbcl-marshal)))
4335       (home-page "https://github.com/rpav/CheckL/")
4336       (synopsis "Dynamic testing for Common Lisp")
4337       (description
4338        "CheckL lets you write tests dynamically, it checks resulting values
4339 against the last run.")
4340       ;; The author specifies both LLGPL and "BSD", but the "BSD" license
4341       ;; isn't specified anywhere, so I don't know which kind.  LLGPL is the
4342       ;; stronger of the two and so I think only listing this should suffice.
4343       (license license:llgpl))))
4344
4345 (define-public cl-checkl
4346   (sbcl-package->cl-source-package sbcl-checkl))
4347
4348 (define-public sbcl-fast-io
4349   (let ((commit "603f4903dd74fb221859da7058ae6ca3853fe64b")
4350         (revision "2"))
4351     (package
4352      (name "sbcl-fast-io")
4353      (version (git-version "1.0.0" revision commit))
4354      (source
4355       (origin
4356        (method git-fetch)
4357        (uri (git-reference
4358              (url "https://github.com/rpav/fast-io.git")
4359              (commit commit)))
4360        (file-name (git-file-name name version))
4361        (sha256
4362         (base32 "00agvc0xx4w715i6ach05p995zpcpghn04xc06zyci06q677vw3n"))))
4363      (build-system asdf-build-system/sbcl)
4364      (arguments
4365       ;; Error while trying to load definition for system fast-io-test from
4366       ;; pathname [...]/fast-io-test.asd: The function CHECKL:DEFINE-TEST-OP
4367       ;; is undefined.
4368       '(#:tests? #f))
4369      (native-inputs
4370       `(("sbcl-fiveam" ,sbcl-fiveam)
4371         ("sbcl-checkl" ,sbcl-checkl)))
4372      (inputs
4373       `(("sbcl-alexandria" ,sbcl-alexandria)
4374         ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)
4375         ("sbcl-static-vectors" ,sbcl-static-vectors)))
4376      (home-page "https://github.com/rpav/fast-io")
4377      (synopsis "Fast octet-vector/stream I/O for Common Lisp")
4378      (description
4379       "Fast-io is about improving performance to octet-vectors and octet
4380 streams (though primarily the former, while wrapping the latter).")
4381      ;; Author specifies this as NewBSD which is an alias
4382      (license license:bsd-3))))
4383
4384 (define-public cl-fast-io
4385   (sbcl-package->cl-source-package sbcl-fast-io))
4386
4387 (define-public sbcl-jonathan
4388   (let ((commit "1f448b4f7ac8265e56e1c02b32ce383e65316300")
4389         (revision "1"))
4390     (package
4391      (name "sbcl-jonathan")
4392      (version (git-version "0.1.0" revision commit))
4393      (source
4394       (origin
4395        (method git-fetch)
4396        (uri (git-reference
4397              (url "https://github.com/Rudolph-Miller/jonathan.git")
4398              (commit commit)))
4399        (file-name (git-file-name name version))
4400        (sha256
4401         (base32 "14x4iwz3mbag5jzzzr4sb6ai0m9r4q4kyypbq32jmsk2dx1hi807"))))
4402      (build-system asdf-build-system/sbcl)
4403      (arguments
4404       ;; Tests fail with: Component JONATHAN-ASD::JONATHAN-TEST not found,
4405       ;; required by #<SYSTEM "jonathan">. Why?
4406       `(#:tests? #f))
4407      (native-inputs
4408       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4409         ("sbcl-prove" ,sbcl-prove)))
4410      (inputs
4411       `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
4412         ("sbcl-cl-syntax-annot" ,sbcl-cl-syntax-annot)
4413         ("sbcl-fast-io" ,sbcl-fast-io)
4414         ("sbcl-proc-parse" ,sbcl-proc-parse)
4415         ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)))
4416      (home-page "https://rudolph-miller.github.io/jonathan/overview.html")
4417      (synopsis "JSON encoder and decoder")
4418      (description
4419       "High performance JSON encoder and decoder.  Currently support: SBCL,
4420 CCL.")
4421      ;; Author specifies the MIT license
4422      (license license:expat))))
4423
4424 (define-public cl-jonathan
4425   (sbcl-package->cl-source-package sbcl-jonathan))
4426
4427 (define-public sbcl-http-body
4428   (let ((commit "dd01dc4f5842e3d29728552e5163acce8386eb73")
4429         (revision "1"))
4430     (package
4431      (name "sbcl-http-body")
4432      (version (git-version "0.1.0" revision commit))
4433      (source
4434       (origin
4435        (method git-fetch)
4436        (uri (git-reference
4437              (url "https://github.com/fukamachi/http-body")
4438              (commit commit)))
4439        (file-name (git-file-name name version))
4440        (sha256
4441         (base32 "1jd06snjvxcprhapgfq8sx0y5lrldkvhf206ix6d5a23dd6zcmr0"))))
4442      (build-system asdf-build-system/sbcl)
4443      (arguments
4444       ;; Tests fail with: Component HTTP-BODY-ASD::HTTP-BODY-TEST not
4445       ;; found, required by #<SYSTEM "http-body">. Why?
4446       `(#:tests? #f))
4447      (native-inputs
4448       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4449         ("sbcl-prove" ,sbcl-prove)))
4450      (inputs
4451       `(("sbcl-fast-http" ,sbcl-fast-http)
4452         ("sbcl-jonathan" ,sbcl-jonathan)
4453         ("sbcl-quri" ,sbcl-quri)))
4454      (home-page "https://github.com/fukamachi/http-body")
4455      (synopsis "HTTP POST data parser")
4456      (description
4457       "HTTP-Body parses HTTP POST data and returns POST parameters.  It
4458 supports application/x-www-form-urlencoded, application/json, and
4459 multipart/form-data.")
4460      (license license:bsd-2))))
4461
4462 (define-public cl-http-body
4463   (sbcl-package->cl-source-package sbcl-http-body))
4464
4465 (define-public sbcl-circular-streams
4466   (let ((commit "e770bade1919c5e8533dd2078c93c3d3bbeb38df")
4467         (revision "1"))
4468     (package
4469      (name "sbcl-circular-streams")
4470      (version (git-version "0.1.0" revision commit))
4471      (source
4472       (origin
4473        (method git-fetch)
4474        (uri (git-reference
4475              (url "https://github.com/fukamachi/circular-streams")
4476              (commit commit)))
4477        (file-name (git-file-name name version))
4478        (sha256
4479         (base32 "1wpw6d5cciyqcf92f7mvihak52pd5s47kk4qq6f0r2z2as68p5rs"))))
4480      (build-system asdf-build-system/sbcl)
4481      (arguments
4482       ;; The tests depend on cl-test-more which is now prove. Prove
4483       ;; tests aren't working for some reason.
4484       `(#:tests? #f))
4485      (inputs
4486       `(("sbcl-fast-io" ,sbcl-fast-io)
4487         ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)))
4488      (home-page "https://github.com/fukamachi/circular-streams")
4489      (synopsis "Circularly readable streams for Common Lisp")
4490      (description
4491       "Circular-Streams allows you to read streams circularly by wrapping real
4492 streams. Once you reach end-of-file of a stream, it's file position will be
4493 reset to 0 and you're able to read it again.")
4494      (license license:llgpl))))
4495
4496 (define-public cl-circular-streams
4497   (sbcl-package->cl-source-package sbcl-circular-streams))
4498
4499 (define-public sbcl-lack-request
4500   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4501         (revision "1"))
4502     (package
4503      (name "sbcl-lack-request")
4504      (version (git-version "0.1.0" revision commit))
4505      (source
4506       (origin
4507        (method git-fetch)
4508        (uri (git-reference
4509              (url "https://github.com/fukamachi/lack.git")
4510              (commit commit)))
4511        (file-name (git-file-name "lack-request" version))
4512        (sha256
4513         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4514      (build-system asdf-build-system/sbcl)
4515      (arguments
4516       '(#:asd-file "lack-request.asd"
4517         #:asd-system-name "lack-request"
4518         #:test-asd-file "t-lack-request.asd"
4519         ;; XXX: Component :CLACK-TEST not found
4520         #:tests? #f))
4521      (native-inputs
4522       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4523         ("sbcl-prove" ,sbcl-prove)))
4524      (inputs
4525       `(("sbcl-quri" ,sbcl-quri)
4526         ("sbcl-http-body" ,sbcl-http-body)
4527         ("sbcl-circular-streams" ,sbcl-circular-streams)))
4528      (home-page "https://github.com/fukamachi/lack")
4529      (synopsis "Lack, the core of Clack")
4530      (description
4531       "Lack is a Common Lisp library which allows web applications to be
4532 constructed of modular components.  It was originally a part of Clack, however
4533 it's going to be rewritten as an individual project since Clack v2 with
4534 performance and simplicity in mind.")
4535      (license license:llgpl))))
4536
4537 (define-public cl-lack-request
4538   (sbcl-package->cl-source-package sbcl-lack-request))
4539
4540 (define-public sbcl-local-time
4541   (let ((commit "62792705245168d3fc2e04164b9a143477284142")
4542         (revision "1"))
4543     (package
4544      (name "sbcl-local-time")
4545      (version (git-version "1.0.6" revision commit))
4546      (source
4547       (origin
4548        (method git-fetch)
4549        (uri (git-reference
4550              (url "https://github.com/dlowe-net/local-time.git")
4551              (commit commit)))
4552        (file-name (git-file-name name version))
4553        (sha256
4554         (base32 "1r5zq4l1lrgprdr2pw7wwry194yknnllyjf6lx7snypb3k4r3yir"))))
4555      (build-system asdf-build-system/sbcl)
4556      (arguments
4557       ;; TODO: Component :STEFIL not found, required by #<SYSTEM
4558       ;; "local-time/test">
4559       '(#:tests? #f))
4560      (native-inputs
4561       `(("stefil" ,sbcl-hu.dwim.stefil)))
4562      (inputs
4563       `(("sbcl-cl-fad" ,sbcl-cl-fad)))
4564      (home-page "https://common-lisp.net/project/local-time/")
4565      (synopsis "Time manipulation library for Common Lisp")
4566      (description
4567       "The LOCAL-TIME library is a Common Lisp library for the manipulation of
4568 dates and times.  It is based almost entirely upon Erik Naggum's paper \"The
4569 Long Painful History of Time\".")
4570      (license license:expat))))
4571
4572 (define-public cl-local-time
4573   (sbcl-package->cl-source-package sbcl-local-time))
4574
4575 (define-public sbcl-lack-response
4576   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4577         (revision "1"))
4578     (package
4579      (name "sbcl-lack-response")
4580      (version (git-version "0.1.0" revision commit))
4581      (source
4582       (origin
4583        (method git-fetch)
4584        (uri (git-reference
4585              (url "https://github.com/fukamachi/lack.git")
4586              (commit commit)))
4587        (file-name (git-file-name name version))
4588        (sha256
4589         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4590      (build-system asdf-build-system/sbcl)
4591      (arguments
4592       '(#:asd-file "lack-response.asd"
4593         #:asd-system-name "lack-response"
4594         ;; XXX: no tests for lack-response.
4595         #:tests? #f))
4596      (native-inputs
4597       `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4598         ("sbcl-prove" ,sbcl-prove)))
4599      (inputs
4600       `(("sbcl-quri" ,sbcl-quri)
4601         ("sbcl-http-body" ,sbcl-http-body)
4602         ("sbcl-circular-streams" ,sbcl-circular-streams)
4603         ("sbcl-local-time" ,sbcl-local-time)))
4604      (home-page "https://github.com/fukamachi/lack")
4605      (synopsis "Lack, the core of Clack")
4606      (description
4607       "Lack is a Common Lisp library which allows web applications to be
4608 constructed of modular components.  It was originally a part of Clack, however
4609 it's going to be rewritten as an individual project since Clack v2 with
4610 performance and simplicity in mind.")
4611      (license license:llgpl))))
4612
4613 (define-public cl-lack-response
4614   (sbcl-package->cl-source-package sbcl-lack-response))
4615
4616 (define-public sbcl-lack-component
4617   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4618         (revision "1"))
4619     (package
4620      (name "sbcl-lack-component")
4621      (version (git-version "0.0.0" revision commit))
4622      (source
4623       (origin
4624        (method git-fetch)
4625        (uri (git-reference
4626              (url "https://github.com/fukamachi/lack.git")
4627              (commit commit)))
4628        (file-name (git-file-name "lack-component" version))
4629        (sha256
4630         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4631      (build-system asdf-build-system/sbcl)
4632      (arguments
4633       '(#:asd-file "lack-component.asd"
4634         #:asd-system-name "lack-component"
4635         #:test-asd-file "t-lack-component.asd"
4636         ;; XXX: Component :LACK-TEST not found
4637         #:tests? #f))
4638      (native-inputs
4639       `(("prove-asdf" ,sbcl-prove-asdf)))
4640      (home-page "https://github.com/fukamachi/lack")
4641      (synopsis "Lack, the core of Clack")
4642      (description
4643       "Lack is a Common Lisp library which allows web applications to be
4644 constructed of modular components.  It was originally a part of Clack, however
4645 it's going to be rewritten as an individual project since Clack v2 with
4646 performance and simplicity in mind.")
4647      (license license:llgpl))))
4648
4649 (define-public cl-lack-component
4650   (sbcl-package->cl-source-package sbcl-lack-component))
4651
4652 (define-public sbcl-lack-util
4653   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4654         (revision "1"))
4655     (package
4656      (name "sbcl-lack-util")
4657      (version (git-version "0.1.0" revision commit))
4658      (source
4659       (origin
4660        (method git-fetch)
4661        (uri (git-reference
4662              (url "https://github.com/fukamachi/lack.git")
4663              (commit commit)))
4664        (file-name (git-file-name "lack-util" version))
4665        (sha256
4666         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4667      (build-system asdf-build-system/sbcl)
4668      (arguments
4669       '(#:asd-file "lack-util.asd"
4670         #:asd-system-name "lack-util"
4671         #:test-asd-file "t-lack-util.asd"
4672         ;; XXX: Component :LACK-TEST not found
4673         #:tests? #f))
4674      (native-inputs
4675       `(("prove-asdf" ,sbcl-prove-asdf)))
4676      (inputs
4677       `(("sbcl-ironclad" ,sbcl-ironclad)))
4678      (home-page "https://github.com/fukamachi/lack")
4679      (synopsis "Lack, the core of Clack")
4680      (description
4681       "Lack is a Common Lisp library which allows web applications to be
4682 constructed of modular components.  It was originally a part of Clack, however
4683 it's going to be rewritten as an individual project since Clack v2 with
4684 performance and simplicity in mind.")
4685      (license license:llgpl))))
4686
4687 (define-public cl-lack-util
4688   (sbcl-package->cl-source-package sbcl-lack-util))
4689
4690 (define-public sbcl-lack-middleware-backtrace
4691   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4692         (revision "1"))
4693     (package
4694      (name "sbcl-lack-middleware-backtrace")
4695      (version (git-version "0.1.0" revision commit))
4696      (source
4697       (origin
4698        (method git-fetch)
4699        (uri (git-reference
4700              (url "https://github.com/fukamachi/lack.git")
4701              (commit commit)))
4702        (file-name (git-file-name "lack-middleware-backtrace" version))
4703        (sha256
4704         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4705      (build-system asdf-build-system/sbcl)
4706      (arguments
4707       '(#:asd-file "lack-middleware-backtrace.asd"
4708         #:asd-system-name "lack-middleware-backtrace"
4709         #:test-asd-file "t-lack-middleware-backtrace.asd"
4710         ;; XXX: Component :LACK not found
4711         #:tests? #f))
4712      (native-inputs
4713       `(("prove-asdf" ,sbcl-prove-asdf)))
4714      (home-page "https://github.com/fukamachi/lack")
4715      (synopsis "Lack, the core of Clack")
4716      (description
4717       "Lack is a Common Lisp library which allows web applications to be
4718 constructed of modular components.  It was originally a part of Clack, however
4719 it's going to be rewritten as an individual project since Clack v2 with
4720 performance and simplicity in mind.")
4721      (license license:llgpl))))
4722
4723 (define-public cl-lack-middleware-backtrace
4724   (sbcl-package->cl-source-package sbcl-lack-middleware-backtrace))
4725
4726 (define-public sbcl-trivial-mimes
4727   (let ((commit "303f8ac0aa6ca0bc139aa3c34822e623c3723fab")
4728         (revision "1"))
4729     (package
4730       (name "sbcl-trivial-mimes")
4731       (version (git-version "1.1.0" revision commit))
4732       (source
4733        (origin
4734          (method git-fetch)
4735          (uri (git-reference
4736                (url "https://github.com/Shinmera/trivial-mimes.git")
4737                (commit commit)))
4738          (file-name (git-file-name name version))
4739          (sha256
4740           (base32 "17jxgl47r695bvsb7wi3n2ws5rp1zzgvw0zii8cy5ggw4b4ayv6m"))))
4741       (build-system asdf-build-system/sbcl)
4742       (arguments
4743        '(#:phases
4744          (modify-phases %standard-phases
4745            (add-after
4746                'unpack 'fix-paths
4747              (lambda* (#:key inputs #:allow-other-keys)
4748                (let ((anchor "#p\"/etc/mime.types\""))
4749                  (substitute* "mime-types.lisp"
4750                    ((anchor all)
4751                     (string-append
4752                      anchor "\n"
4753                      "(asdf:system-relative-pathname :trivial-mimes "
4754                      "\"../../share/common-lisp/" (%lisp-type)
4755                      "-source/trivial-mimes/mime.types\")")))))))))
4756       (native-inputs
4757        `(("stefil" ,sbcl-hu.dwim.stefil)))
4758       (inputs
4759        `(("sbcl-cl-fad" ,sbcl-cl-fad)))
4760       (home-page "https://shinmera.github.io/trivial-mimes/")
4761       (synopsis "Tiny Common Lisp library to detect mime types in files")
4762       (description
4763        "This is a teensy library that provides some functions to determine the
4764 mime-type of a file.")
4765       (license license:artistic2.0))))
4766
4767 (define-public cl-trivial-mimes
4768   (sbcl-package->cl-source-package sbcl-trivial-mimes))
4769
4770 (define-public ecl-trivial-mimes
4771   (sbcl-package->ecl-package sbcl-trivial-mimes))
4772
4773 (define-public sbcl-lack-middleware-static
4774   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4775         (revision "1"))
4776     (package
4777      (name "sbcl-lack-middleware-static")
4778      (version (git-version "0.1.0" revision commit))
4779      (source
4780       (origin
4781        (method git-fetch)
4782        (uri (git-reference
4783              (url "https://github.com/fukamachi/lack.git")
4784              (commit commit)))
4785        (file-name (git-file-name "lack-middleware-static" version))
4786        (sha256
4787         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4788      (build-system asdf-build-system/sbcl)
4789      (arguments
4790       '(#:asd-file "lack-middleware-static.asd"
4791         #:asd-system-name "lack-middleware-static"
4792         #:test-asd-file "t-lack-middleware-static.asd"
4793         ;; XXX: Component :LACK not found
4794         #:tests? #f))
4795      (native-inputs
4796       `(("prove-asdf" ,sbcl-prove-asdf)))
4797      (inputs
4798       `(("sbcl-ironclad" ,sbcl-ironclad)
4799         ("sbcl-trivial-mimes" ,sbcl-trivial-mimes)
4800         ("sbcl-local-time" ,sbcl-local-time)))
4801      (home-page "https://github.com/fukamachi/lack")
4802      (synopsis "Lack, the core of Clack")
4803      (description
4804       "Lack is a Common Lisp library which allows web applications to be
4805 constructed of modular components.  It was originally a part of Clack, however
4806 it's going to be rewritten as an individual project since Clack v2 with
4807 performance and simplicity in mind.")
4808      (license license:llgpl))))
4809
4810 (define-public cl-lack-middleware-static
4811   (sbcl-package->cl-source-package sbcl-lack-middleware-static))
4812
4813 (define-public sbcl-lack
4814   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4815         (revision "1"))
4816     (package
4817      (name "sbcl-lack")
4818      (version (git-version "0.1.0" revision commit))
4819      (source
4820       (origin
4821        (method git-fetch)
4822        (uri (git-reference
4823              (url "https://github.com/fukamachi/lack.git")
4824              (commit commit)))
4825        (file-name (git-file-name "lack" version))
4826        (sha256
4827         (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4828      (build-system asdf-build-system/sbcl)
4829      (arguments
4830       '(#:test-asd-file "t-lack.asd"
4831         ;; XXX: Component :CLACK not found
4832         #:tests? #f))
4833      (native-inputs
4834       `(("prove-asdf" ,sbcl-prove-asdf)))
4835      (inputs
4836       `(("sbcl-lack-component" ,sbcl-lack-component)
4837         ("sbcl-lack-util" ,sbcl-lack-util)))
4838      (home-page "https://github.com/fukamachi/lack")
4839      (synopsis "Lack, the core of Clack")
4840      (description
4841       "Lack is a Common Lisp library which allows web applications to be
4842 constructed of modular components.  It was originally a part of Clack, however
4843 it's going to be rewritten as an individual project since Clack v2 with
4844 performance and simplicity in mind.")
4845      (license license:llgpl))))
4846
4847 (define-public cl-lack
4848   (sbcl-package->cl-source-package sbcl-lack))
4849
4850 (define-public sbcl-ningle
4851   (let ((commit "50bd4f09b5a03a7249bd4d78265d6451563b25ad")
4852         (revision "1"))
4853     (package
4854       (name "sbcl-ningle")
4855       (version (git-version "0.3.0" revision commit))
4856       (source
4857        (origin
4858          (method git-fetch)
4859          (uri (git-reference
4860                (url "https://github.com/fukamachi/ningle.git")
4861                (commit commit)))
4862          (file-name (git-file-name name version))
4863          (sha256
4864           (base32 "1bsl8cnxhacb8p92z9n89vhk1ikmij5zavk0m2zvmj7iqm79jzgw"))))
4865       (build-system asdf-build-system/sbcl)
4866       (arguments
4867        ;; TODO: pull in clack-test
4868        '(#:tests? #f
4869          #:phases
4870          (modify-phases %standard-phases
4871            (delete 'cleanup-files)
4872            (delete 'cleanup)
4873            (add-before 'cleanup 'combine-fasls
4874              (lambda* (#:key outputs #:allow-other-keys)
4875                (let* ((out (assoc-ref outputs "out"))
4876                       (lib (string-append out "/lib/sbcl"))
4877                       (ningle-path (string-append lib "/ningle"))
4878                       (fasl-files (find-files out "\\.fasl$")))
4879                  (mkdir-p ningle-path)
4880                  (let ((fasl-path (lambda (name)
4881                                     (string-append ningle-path
4882                                                    "/"
4883                                                    (basename name)
4884                                                    "--system.fasl"))))
4885                    (for-each (lambda (file)
4886                                (rename-file file
4887                                             (fasl-path
4888                                              (basename file ".fasl"))))
4889                              fasl-files))
4890                  fasl-files)
4891                #t)))))
4892       (native-inputs
4893        `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4894          ("sbcl-prove" ,sbcl-prove)))
4895       (inputs
4896        `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
4897          ("sbcl-cl-syntax-annot" ,sbcl-cl-syntax-annot)
4898          ("sbcl-myway" ,sbcl-myway)
4899          ("sbcl-lack-request" ,sbcl-lack-request)
4900          ("sbcl-lack-response" ,sbcl-lack-response)
4901          ("sbcl-lack-component" ,sbcl-lack-component)
4902          ("sbcl-alexandria" ,sbcl-alexandria)
4903          ("sbcl-babel" ,sbcl-babel)))
4904       (home-page "https://8arrow.org/ningle/")
4905       (synopsis "Super micro framework for Common Lisp")
4906       (description
4907        "Ningle is a lightweight web application framework for Common Lisp.")
4908       (license license:llgpl))))
4909
4910 (define-public cl-ningle
4911   (sbcl-package->cl-source-package sbcl-ningle))
4912
4913 (define-public sbcl-clack
4914   (let ((commit "e3e032843bb1220ab96263c411aa7f2feb4746e0")
4915         (revision "1"))
4916     (package
4917      (name "sbcl-clack")
4918      (version (git-version "2.0.0" revision commit))
4919      (source
4920       (origin
4921        (method git-fetch)
4922        (uri (git-reference
4923              (url "https://github.com/fukamachi/clack.git")
4924              (commit commit)))
4925        (file-name (git-file-name name version))
4926        (sha256
4927         (base32 "1ymzs6qyrwhlj6cgqsnpyn6g5cbp7a3s1vgxwna20y2q7y4iacy0"))))
4928      (build-system asdf-build-system/sbcl)
4929      (inputs
4930       `(("sbcl-lack" ,sbcl-lack)
4931         ("sbcl-lack-middleware-backtrace" ,sbcl-lack-middleware-backtrace)
4932         ("sbcl-bordeaux-threads" ,sbcl-bordeaux-threads)))
4933      (home-page "https://github.com/fukamachi/clack")
4934      (synopsis "Web Application Environment for Common Lisp")
4935      (description
4936       "Clack is a web application environment for Common Lisp inspired by
4937 Python's WSGI and Ruby's Rack.")
4938      (license license:llgpl))))
4939
4940 (define-public cl-clack
4941   (sbcl-package->cl-source-package sbcl-clack))
4942
4943 (define-public sbcl-log4cl
4944   (let ((commit "611e094458504b938d49de904eab141285328c7c")
4945         (revision "1"))
4946     (package
4947       (name "sbcl-log4cl")
4948       (build-system asdf-build-system/sbcl)
4949       (version "1.1.2")
4950       (source
4951        (origin
4952          (method git-fetch)
4953          (uri (git-reference
4954                (url "https://github.com/sharplispers/log4cl")
4955                (commit commit)))
4956          (file-name (git-file-name name version))
4957          (sha256
4958           (base32
4959            "08jly0s0g26b56hhpfizxsb4j0yvbh946sd205gr42dkzv8l7dsc"))))
4960       ;; FIXME: tests require stefil, sbcl-hu.dwim.stefil wont work
4961       (arguments
4962        `(#:tests? #f))
4963       (inputs `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
4964       (synopsis "Common Lisp logging framework, modeled after Log4J")
4965       (home-page "https://github.com/7max/log4cl")
4966       (description "This is a Common Lisp logging framework that can log at
4967 various levels and mix text with expressions.")
4968       (license license:asl2.0))))
4969
4970 (define-public cl-log4cl
4971   (sbcl-package->cl-source-package sbcl-log4cl))
4972
4973 (define-public ecl-log4cl
4974   (sbcl-package->ecl-package sbcl-log4cl))
4975
4976 (define-public sbcl-find-port
4977   (let ((commit "00c96a25af93a0f8681d34ec548861f2d7485478")
4978         (revision "1"))
4979     (package
4980       (name "sbcl-find-port")
4981       (build-system asdf-build-system/sbcl)
4982       (version "0.1")
4983       (home-page "https://github.com/eudoxia0/find-port")
4984       (source
4985        (origin
4986          (method git-fetch)
4987          (uri (git-reference
4988                (url home-page)
4989                (commit commit)))
4990          (file-name (git-file-name name version))
4991          (sha256
4992           (base32
4993            "0d6dzbb45jh0rx90wgs6v020k2xa87mvzas3mvfzvivjvqqlpryq"))))
4994       (native-inputs
4995        `(("fiveam" ,sbcl-fiveam)))
4996       (inputs
4997        `(("sbcl-usocket" ,sbcl-usocket)))
4998       (synopsis "Find open ports programmatically in Common Lisp")
4999       (description "This is a small Common Lisp library that finds an open
5000 port within a range.")
5001       (license license:expat))))
5002
5003 (define-public cl-find-port
5004   (sbcl-package->cl-source-package sbcl-find-port))
5005
5006 (define-public ecl-find-port
5007   (sbcl-package->ecl-package sbcl-find-port))
5008
5009 (define-public sbcl-clunit
5010   (let ((commit "6f6d72873f0e1207f037470105969384f8380628")
5011         (revision "1"))
5012     (package
5013       (name "sbcl-clunit")
5014       (version (git-version "0.2.3" revision commit))
5015       (source
5016        (origin
5017          (method git-fetch)
5018          (uri (git-reference
5019                (url "https://github.com/tgutu/clunit.git")
5020                (commit commit)))
5021          (file-name (git-file-name name version))
5022          (sha256
5023           (base32
5024            "1idf2xnqzlhi8rbrqmzpmb3i1l6pbdzhhajkmhwbp6qjkmxa4h85"))))
5025       (build-system asdf-build-system/sbcl)
5026       (synopsis "CLUnit is a Common Lisp unit testing framework")
5027       (description
5028        "CLUnit is a Common Lisp unit testing framework.  It is designed
5029 to be easy to use so that you can quickly start testing.  CLUnit
5030 provides a rich set of features aimed at improving your unit testing
5031 experience.")
5032       (home-page "https://tgutu.github.io/clunit/")
5033       ;; MIT License
5034       (license license:expat))))
5035
5036 (define-public cl-clunit
5037   (sbcl-package->cl-source-package sbcl-clunit))
5038
5039 (define-public ecl-clunit
5040   (sbcl-package->ecl-package sbcl-clunit))
5041
5042 (define-public sbcl-py4cl
5043   (let ((commit "4c8a2b0814fd311f978964f825ce012290f60136")
5044         (revision "1"))
5045     (package
5046       (name "sbcl-py4cl")
5047       (version (git-version "0.0.0" revision commit))
5048       (source
5049        (origin
5050          (method git-fetch)
5051          (uri (git-reference
5052                (url "https://github.com/bendudson/py4cl.git")
5053                (commit commit)))
5054          (file-name (git-file-name name version))
5055          (sha256
5056           (base32
5057            "15mk7qdqjkj56gdnbyrdyz6r7m1h26ldvn6ch96pmvg5vmr1m45r"))
5058          (modules '((guix build utils)))))
5059       (build-system asdf-build-system/sbcl)
5060       (native-inputs
5061        `(("sbcl-clunit" ,sbcl-clunit)))
5062       (inputs
5063        `(("sbcl-trivial-garbage" ,sbcl-trivial-garbage)))
5064       (propagated-inputs
5065        ;; This package doesn't do anything without python available
5066        `(("python" ,python)
5067          ;; For multi-dimensional array support
5068          ("python-numpy" ,python-numpy)))
5069       (arguments
5070        '(#:phases
5071          (modify-phases %standard-phases
5072            (add-after 'unpack 'replace-*base-directory*-var
5073              (lambda* (#:key outputs #:allow-other-keys)
5074                ;; In the ASD, the author makes an attempt to
5075                ;; programatically determine the location of the
5076                ;; source-code so lisp can call into "py4cl.py". We can
5077                ;; hard-code this since we know where this file will
5078                ;; reside.
5079                (substitute* "src/callpython.lisp"
5080                  (("py4cl/config:\\*base-directory\\*")
5081                   (string-append
5082                    "\""
5083                    (assoc-ref outputs "out")
5084                    "/share/common-lisp/sbcl-source/py4cl/"
5085                    "\""))))))))
5086       (synopsis "Call python from Common Lisp")
5087       (description
5088        "Py4CL is a bridge between Common Lisp and Python, which enables Common
5089 Lisp to interact with Python code.  It uses streams to communicate with a
5090 separate python process, the approach taken by cl4py.  This is different to
5091 the CFFI approach used by burgled-batteries, but has the same goal.")
5092       (home-page "https://github.com/bendudson/py4cl")
5093       ;; MIT License
5094       (license license:expat))))
5095
5096 (define-public cl-py4cl
5097   (sbcl-package->cl-source-package sbcl-py4cl))
5098
5099 (define-public ecl-py4cl
5100   (sbcl-package->ecl-package sbcl-py4cl))
5101
5102 (define-public sbcl-parse-declarations
5103   (let ((commit "549aebbfb9403a7fe948654126b9c814f443f4f2")
5104         (revision "1"))
5105     (package
5106       (name "sbcl-parse-declarations")
5107       (version (git-version "1.0.0" revision commit))
5108       (source
5109        (origin
5110          (method git-fetch)
5111          (uri (git-reference
5112                (url (string-append
5113                      "https://gitlab.common-lisp.net/parse-declarations/"
5114                      "parse-declarations.git"))
5115                (commit commit)))
5116          (file-name (git-file-name name version))
5117          (sha256
5118           (base32 "03g5qks4c59nmxa48pbslxkfh77h8hn8566jddp6m9pl15dzzpxd"))))
5119       (build-system asdf-build-system/sbcl)
5120       (arguments
5121        `(#:asd-file "parse-declarations-1.0.asd"
5122          #:asd-system-name "parse-declarations-1.0"))
5123       (home-page "https://common-lisp.net/project/parse-declarations/")
5124       (synopsis "Parse, filter, and build declarations")
5125       (description
5126        "Parse-Declarations is a Common Lisp library to help writing
5127 macros which establish bindings.  To be semantically correct, such
5128 macros must take user declarations into account, as these may affect
5129 the bindings they establish.  Yet the ANSI standard of Common Lisp does
5130 not provide any operators to work with declarations in a convenient,
5131 high-level way.  This library provides such operators.")
5132       ;; MIT License
5133       (license license:expat))))
5134
5135 (define-public cl-parse-declarations
5136   (sbcl-package->cl-source-package sbcl-parse-declarations))
5137
5138 (define-public ecl-parse-declarations
5139   (sbcl-package->ecl-package sbcl-parse-declarations))
5140
5141 (define-public sbcl-cl-quickcheck
5142   (let ((commit "807b2792a30c883a2fbecea8e7db355b50ba662f")
5143         (revision "1"))
5144     (package
5145       (name "sbcl-cl-quickcheck")
5146       (version (git-version "0.0.4" revision commit))
5147       (source
5148        (origin
5149          (method git-fetch)
5150          (uri (git-reference
5151                (url "https://github.com/mcandre/cl-quickcheck.git")
5152                (commit commit)))
5153          (file-name (git-file-name name version))
5154          (sha256
5155           (base32
5156            "165lhypq5xkcys6hvzb3jq7ywnmqvzaflda29qk2cbs3ggas4767"))))
5157       (build-system asdf-build-system/sbcl)
5158       (synopsis
5159        "Common Lisp port of the QuickCheck unit test framework")
5160       (description
5161        "Common Lisp port of the QuickCheck unit test framework")
5162       (home-page "https://github.com/mcandre/cl-quickcheck")
5163       ;; MIT
5164       (license license:expat))))
5165
5166 (define-public cl-cl-quickcheck
5167   (sbcl-package->cl-source-package sbcl-cl-quickcheck))
5168
5169 (define-public ecl-cl-quickcheck
5170   (sbcl-package->ecl-package sbcl-cl-quickcheck))
5171
5172 (define-public sbcl-burgled-batteries3
5173   (let ((commit "f65f454d13bb6c40e17e9ec62e41eb5069e09760")
5174         (revision "2"))
5175     (package
5176       (name "sbcl-burgled-batteries3")
5177       (version (git-version "0.0.0" revision commit))
5178       (source
5179        (origin
5180          (method git-fetch)
5181          (uri (git-reference
5182                (url "https://github.com/snmsts/burgled-batteries3.git")
5183                (commit commit)))
5184          (file-name (git-file-name name version))
5185          (sha256
5186           (base32
5187            "1nzn7jawrfajyzwfnzrg2cmn9xxadcqh4szbpg0jggkhdkdzz4wa"))))
5188       (build-system asdf-build-system/sbcl)
5189       (arguments
5190        `(#:tests? #f
5191          #:modules (((guix build python-build-system) #:select (python-version))
5192                     ,@%asdf-build-system-modules)
5193          #:imported-modules ((guix build python-build-system)
5194                              ,@%asdf-build-system-modules)
5195          #:phases
5196          (modify-phases (@ (guix build asdf-build-system) %standard-phases)
5197            (add-after 'unpack 'set-*cpython-include-dir*-var
5198              (lambda* (#:key inputs #:allow-other-keys)
5199                (let ((python (assoc-ref inputs "python")))
5200                  (setenv "BB_PYTHON3_INCLUDE_DIR"
5201                          (string-append python "/include/python"
5202                                         (python-version python)))
5203                  (setenv "BB_PYTHON3_DYLIB"
5204                          (string-append python "/lib/libpython3.so"))
5205                  #t)))
5206            (add-after 'unpack 'adjust-for-python-3.8
5207              (lambda _
5208                ;; This method is no longer part of the public API.
5209                (substitute* "ffi-interface.lisp"
5210                  ((".*PyEval_ReInitThreads.*")
5211                   ""))
5212                #t)))))
5213       (native-inputs
5214        `(("sbcl-cl-fad" ,sbcl-cl-fad)
5215          ("sbcl-lift" ,sbcl-lift)
5216          ("sbcl-cl-quickcheck" ,sbcl-cl-quickcheck)))
5217       (inputs
5218        `(("python" ,python)
5219          ("sbcl-cffi" ,sbcl-cffi)
5220          ("sbcl-cffi-grovel" ,sbcl-cffi-grovel)
5221          ("sbcl-alexandria" , sbcl-alexandria)
5222          ("sbcl-parse-declarations-1.0" ,sbcl-parse-declarations)
5223          ("sbcl-trivial-garbage" ,sbcl-trivial-garbage)))
5224       (synopsis "Bridge between Python and Lisp (FFI bindings, etc.)")
5225       (description
5226        "This package provides a shim between Python3 (specifically, the
5227 CPython implementation of Python) and Common Lisp.")
5228       (home-page "https://github.com/snmsts/burgled-batteries3")
5229       (license license:expat))))
5230
5231 (define-public cl-burgled-batteries3
5232   (sbcl-package->cl-source-package sbcl-burgled-batteries3))
5233
5234 (define-public ecl-burgled-batteries3
5235   (sbcl-package->ecl-package sbcl-burgled-batteries3))
5236
5237 (define-public sbcl-metabang-bind
5238   (let ((commit "c93b7f7e1c18c954c2283efd6a7fdab36746ab5e")
5239         (revision "1"))
5240     (package
5241       (name "sbcl-metabang-bind")
5242       (version (git-version "0.8.0" revision commit))
5243       (source
5244        (origin
5245          (method git-fetch)
5246          (uri (git-reference
5247                (url "https://github.com/gwkkwg/metabang-bind.git")
5248                (commit commit)))
5249          (file-name (git-file-name name version))
5250          (sha256
5251           (base32
5252            "0hd0kr91795v77akpbcyqiss9p0p7ypa9dznrllincnmgvsxlmf0"))))
5253       (build-system asdf-build-system/sbcl)
5254       (native-inputs
5255        `(("sbcl-lift" ,sbcl-lift)))
5256       (synopsis "Macro that generalizes @code{multiple-value-bind} etc.")
5257       (description
5258        "Bind extends the idea of of let and destructing to provide a uniform
5259 syntax for all your accessor needs.  It combines @code{let},
5260 @code{destructuring-bind}, @code{with-slots}, @code{with-accessors}, structure
5261 editing, property or association-lists, and @code{multiple-value-bind} and a
5262 whole lot more into a single form.")
5263       (home-page "https://common-lisp.net/project/metabang-bind/")
5264       ;; MIT License
5265       (license license:expat))))
5266
5267 (define-public cl-metabang-bind
5268   (sbcl-package->cl-source-package sbcl-metabang-bind))
5269
5270 (define-public ecl-metabang-bind
5271   (sbcl-package->ecl-package sbcl-metabang-bind))
5272
5273 (define-public sbcl-fare-utils
5274   (let ((commit "66e9c6f1499140bc00ccc22febf2aa528cbb5724")
5275         (revision "1"))
5276     (package
5277       (name "sbcl-fare-utils")
5278       (version (git-version "1.0.0.5" revision commit))
5279       (source
5280        (origin
5281          (method git-fetch)
5282          (uri
5283           (git-reference
5284            (url
5285             "https://gitlab.common-lisp.net/frideau/fare-utils.git")
5286            (commit commit)))
5287          (file-name (git-file-name name version))
5288          (sha256
5289           (base32
5290            "01wsr1aap3jdzhn4hrqjbhsjx6qci9dbd3gh4gayv1p49rbg8aqr"))))
5291       (build-system asdf-build-system/sbcl)
5292       (arguments
5293        `(#:test-asd-file "test/fare-utils-test.asd"))
5294       (native-inputs
5295        `(("sbcl-hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
5296       (synopsis "Collection of utilities and data structures")
5297       (description
5298        "fare-utils is a small collection of utilities.  It contains a lot of
5299 basic everyday functions and macros.")
5300       (home-page "https://gitlab.common-lisp.net/frideau/fare-utils")
5301       ;; MIT License
5302       (license license:expat))))
5303
5304 (define-public cl-fare-utils
5305   (sbcl-package->cl-source-package sbcl-fare-utils))
5306
5307 (define-public ecl-fare-utils
5308   (sbcl-package->ecl-package sbcl-fare-utils))
5309
5310 (define-public sbcl-trivial-utf-8
5311   (let ((commit "4d427cfbb1c452436a0efb71c3205c9da67f718f")
5312         (revision "1"))
5313     (package
5314       (name "sbcl-trivial-utf-8")
5315       (version (git-version "0.0.0" revision commit))
5316       (source
5317        (origin
5318          (method git-fetch)
5319          (uri
5320           (git-reference
5321            (url (string-append "https://gitlab.common-lisp.net/"
5322                                "trivial-utf-8/trivial-utf-8.git"))
5323            (commit commit)))
5324          (file-name (git-file-name name version))
5325          (sha256
5326           (base32
5327            "1jz27gz8gvqdmvp3k9bxschs6d5b3qgk94qp2bj6nv1d0jc3m1l1"))))
5328       (arguments
5329        ;; Guix incorrectly assumes the "8" is part of the version
5330        ;; number and lobs it off.
5331        `(#:asd-file "trivial-utf-8.asd"
5332          #:asd-system-name "trivial-utf-8"))
5333       (build-system asdf-build-system/sbcl)
5334       (synopsis "UTF-8 input/output library")
5335       (description
5336        "The Babel library solves a similar problem while understanding more
5337 encodings.  Trivial UTF-8 was written before Babel existed, but for new
5338 projects you might be better off going with Babel.  The one plus that Trivial
5339 UTF-8 has is that it doesn't depend on any other libraries.")
5340       (home-page "https://common-lisp.net/project/trivial-utf-8/")
5341       (license license:bsd-3))))
5342
5343 (define-public cl-trivial-utf-8
5344   (sbcl-package->cl-source-package sbcl-trivial-utf-8))
5345
5346 (define-public ecl-trivial-utf-8
5347   (sbcl-package->ecl-package sbcl-trivial-utf-8))
5348
5349 (define-public sbcl-idna
5350   (package
5351     (name "sbcl-idna")
5352     (build-system asdf-build-system/sbcl)
5353     (version "0.2.2")
5354     (home-page "https://github.com/antifuchs/idna")
5355     (source
5356      (origin
5357        (method git-fetch)
5358        (uri (git-reference
5359              (url home-page)
5360              (commit version)))
5361        (file-name (git-file-name name version))
5362        (sha256
5363         (base32
5364          "00nbr3mffxhlq14gg9d16pa6691s4qh35inyw76v906s77khm5a2"))))
5365     (inputs
5366      `(("split-sequence" ,sbcl-split-sequence)))
5367     (synopsis "IDNA string encoding and decoding routines for Common Lisp")
5368     (description "This Common Lisp library provides string encoding and
5369 decoding routines for IDNA, the International Domain Names in Applications.")
5370     (license license:expat)))
5371
5372 (define-public cl-idna
5373   (sbcl-package->cl-source-package sbcl-idna))
5374
5375 (define-public ecl-idna
5376   (sbcl-package->ecl-package sbcl-idna))
5377
5378 (define-public sbcl-swap-bytes
5379   (package
5380     (name "sbcl-swap-bytes")
5381     (build-system asdf-build-system/sbcl)
5382     (version "1.2")
5383     (home-page "https://github.com/sionescu/swap-bytes")
5384     (source
5385      (origin
5386        (method git-fetch)
5387        (uri (git-reference
5388              (url home-page)
5389              (commit (string-append "v" version))))
5390        (file-name (git-file-name name version))
5391        (sha256
5392         (base32
5393          "1hw1v1lw26rifyznpnj1csphha9jgzwpiic16ni3pvs6hcsni9rz"))))
5394     (inputs
5395      `(("trivial-features" ,sbcl-trivial-features)))
5396     (native-inputs
5397      `(("fiveam" ,sbcl-fiveam)))
5398     (synopsis "Efficient endianness conversion for Common Lisp")
5399     (description "This Common Lisp library provides optimized byte-swapping
5400 primitives.  The library can change endianness of unsigned integers of length
5401 1/2/4/8.  Very useful in implementing various network protocols and file
5402 formats.")
5403     (license license:expat)))
5404
5405 (define-public cl-swap-bytes
5406   (sbcl-package->cl-source-package sbcl-swap-bytes))
5407
5408 (define-public ecl-swap-bytes
5409   (sbcl-package->ecl-package sbcl-swap-bytes))
5410
5411 (define-public sbcl-iolib.asdf
5412   ;; Latest release is from June 2017.
5413   (let ((commit "7f5ea3a8457a29d224b24653c2b3657fb1898021")
5414         (revision "2"))
5415     (package
5416       (name "sbcl-iolib.asdf")
5417       (build-system asdf-build-system/sbcl)
5418       (version (git-version "0.8.3" revision commit))
5419       (home-page "https://github.com/sionescu/iolib")
5420       (source
5421        (origin
5422          (method git-fetch)
5423          (uri (git-reference
5424                (url home-page)
5425                (commit commit)))
5426          (file-name (git-file-name name version))
5427          (sha256
5428           (base32
5429            "1bg5w7lm61hqk4b0svmri8a590q36z76jfa0sdgzb39r98c04w12"))))
5430       (inputs
5431        `(("alexandria" ,sbcl-alexandria)))
5432       (arguments
5433        '(#:asd-file "iolib.asdf.asd"))
5434       (synopsis "ASDF component classes for IOLib, a Common Lisp I/O library")
5435       (description "IOlib is to be a better and more modern I/O library than
5436 the standard Common Lisp library.  It contains a socket library, a DNS
5437 resolver, an I/O multiplexer(which supports @code{select(2)}, @code{epoll(4)}
5438 and @code{kqueue(2)}), a pathname library and file-system utilities.")
5439       (license license:expat))))
5440
5441 (define-public sbcl-iolib.conf
5442   (package
5443     (inherit sbcl-iolib.asdf)
5444     (name "sbcl-iolib.conf")
5445     (inputs
5446      `(("iolib.asdf" ,sbcl-iolib.asdf)))
5447     (arguments
5448      '(#:asd-file "iolib.conf.asd"))
5449     (synopsis "Compile-time configuration for IOLib, a Common Lisp I/O library")))
5450
5451 (define-public sbcl-iolib.common-lisp
5452   (package
5453     (inherit sbcl-iolib.asdf)
5454     (name "sbcl-iolib.common-lisp")
5455     (inputs
5456      `(("iolib.asdf" ,sbcl-iolib.asdf)
5457        ("iolib.conf" ,sbcl-iolib.conf)))
5458     (arguments
5459      '(#:asd-file "iolib.common-lisp.asd"))
5460     (synopsis "Slightly modified Common Lisp for IOLib, a Common Lisp I/O library")))
5461
5462 (define-public sbcl-iolib.base
5463   (package
5464     (inherit sbcl-iolib.asdf)
5465     (name "sbcl-iolib.base")
5466     (inputs
5467      `(("iolib.asdf" ,sbcl-iolib.asdf)
5468        ("iolib.conf" ,sbcl-iolib.conf)
5469        ("iolib.common-lisp" ,sbcl-iolib.common-lisp)
5470        ("split-sequence" ,sbcl-split-sequence)))
5471     (arguments
5472      '(#:asd-file "iolib.base.asd"))
5473     (synopsis "Base package for IOLib, a Common Lisp I/O library")))
5474
5475 (define-public sbcl-iolib.grovel
5476   (deprecated-package "sbcl-iolib.grovel" sbcl-cffi-grovel))
5477
5478 (define sbcl-iolib+syscalls
5479   (package
5480     (inherit sbcl-iolib.asdf)
5481     (name "sbcl-iolib+syscalls")
5482     (inputs
5483      `(("iolib.asdf" ,sbcl-iolib.asdf)
5484        ("iolib.conf" ,sbcl-iolib.conf)
5485        ("cffi-grovel" ,sbcl-cffi-grovel)
5486        ("iolib.base" ,sbcl-iolib.base)
5487        ("bordeaux-threads" ,sbcl-bordeaux-threads)
5488        ("idna" ,sbcl-idna)
5489        ("swap-bytes" ,sbcl-swap-bytes)
5490        ("libfixposix" ,libfixposix)
5491        ("cffi" ,sbcl-cffi)))
5492     (native-inputs
5493      `(("fiveam" ,sbcl-fiveam)))
5494     (arguments
5495      '(#:asd-file "iolib.asd"
5496        #:asd-system-name "iolib/syscalls"
5497        #:phases
5498        (modify-phases %standard-phases
5499          (add-after 'unpack 'fix-paths
5500            (lambda* (#:key inputs #:allow-other-keys)
5501              (substitute* "src/syscalls/ffi-functions-unix.lisp"
5502                (("\\(:default \"libfixposix\"\\)")
5503                 (string-append
5504                  "(:default \""
5505                  (assoc-ref inputs "libfixposix") "/lib/libfixposix\")")))
5506              ;; Socket tests need Internet access, disable them.
5507              (substitute* "iolib.asd"
5508                (("\\(:file \"sockets\" :depends-on \\(\"pkgdcl\" \"defsuites\"\\)\\)")
5509                 "")))))))
5510     (synopsis "Common Lisp I/O library")))
5511
5512 (define sbcl-iolib+multiplex
5513   (package
5514     (inherit sbcl-iolib+syscalls)
5515     (name "sbcl-iolib+multiplex")
5516     (inputs
5517      `(("iolib+syscalls" ,sbcl-iolib+syscalls)
5518        ,@(package-inputs sbcl-iolib+syscalls)))
5519     (arguments
5520      (substitute-keyword-arguments (package-arguments sbcl-iolib+syscalls)
5521        ((#:asd-system-name _) "iolib/multiplex")))))
5522
5523 (define sbcl-iolib+streams
5524   (package
5525     (inherit sbcl-iolib+syscalls)
5526     (name "sbcl-iolib+streams")
5527     (inputs
5528      `(("iolib+multiplex" ,sbcl-iolib+multiplex)
5529        ,@(package-inputs sbcl-iolib+syscalls)))
5530     (arguments
5531      (substitute-keyword-arguments (package-arguments sbcl-iolib+syscalls)
5532        ((#:asd-system-name _) "iolib/streams")))))
5533
5534 (define sbcl-iolib+sockets
5535   (package
5536     (inherit sbcl-iolib+syscalls)
5537     (name "sbcl-iolib+sockets")
5538     (inputs
5539      `(("iolib+syscalls" ,sbcl-iolib+syscalls)
5540        ("iolib+streams" ,sbcl-iolib+streams)
5541        ,@(package-inputs sbcl-iolib+syscalls)))
5542     (arguments
5543      (substitute-keyword-arguments (package-arguments sbcl-iolib+syscalls)
5544        ((#:asd-system-name _) "iolib/sockets")))))
5545
5546 (define-public sbcl-iolib
5547   (package
5548     (inherit sbcl-iolib+syscalls)
5549     (name "sbcl-iolib")
5550     (inputs
5551      `(("iolib+multiplex" ,sbcl-iolib+multiplex)
5552        ("iolib+streams" ,sbcl-iolib+streams)
5553        ("iolib+sockets" ,sbcl-iolib+sockets)
5554        ,@(package-inputs sbcl-iolib+syscalls)))
5555     (arguments
5556      (substitute-keyword-arguments (package-arguments sbcl-iolib+syscalls)
5557        ((#:asd-system-name _) "iolib")))))
5558
5559 (define-public cl-iolib
5560   (let ((parent (sbcl-package->cl-source-package sbcl-iolib)))
5561     (package
5562       (inherit parent)
5563       (propagated-inputs
5564        ;; Need header to compile.
5565        `(("libfixposix" ,libfixposix)
5566          ,@(package-propagated-inputs parent))))))
5567
5568 (define-public sbcl-ieee-floats
5569   (let ((commit "566b51a005e81ff618554b9b2f0b795d3b29398d")
5570         (revision "1"))
5571     (package
5572       (name "sbcl-ieee-floats")
5573       (build-system asdf-build-system/sbcl)
5574       (version (git-version "20170924" revision commit))
5575       (home-page "https://github.com/marijnh/ieee-floats/")
5576       (source
5577        (origin
5578          (method git-fetch)
5579          (uri (git-reference
5580                (url home-page)
5581                (commit commit)))
5582          (file-name (git-file-name name version))
5583          (sha256
5584           (base32
5585            "1xyj49j9x3lc84cv3dhbf9ja34ywjk1c46dklx425fxw9mkwm83m"))))
5586       (native-inputs
5587        `(("fiveam" ,sbcl-fiveam)))
5588       (synopsis "IEEE 754 binary representation for floats in Common Lisp")
5589       (description "This is a Common Lisp library that converts
5590 floating point values to IEEE 754 binary representation.")
5591       (license license:bsd-3))))
5592
5593 (define-public cl-ieee-floats
5594   (sbcl-package->cl-source-package sbcl-ieee-floats))
5595
5596 (define sbcl-closure-common
5597   (let ((commit "e3c5f5f454b72b01b89115e581c3c52a7e201e5c")
5598         (revision "1"))
5599     (package
5600       (name "sbcl-closure-common")
5601       (build-system asdf-build-system/sbcl)
5602       (version (git-version "20101006" revision commit))
5603       (home-page "https://common-lisp.net/project/cxml/")
5604       (source
5605        (origin
5606          (method git-fetch)
5607          (uri (git-reference
5608                (url "https://github.com/sharplispers/closure-common")
5609                (commit commit)))
5610          (file-name (git-file-name name version))
5611          (sha256
5612           (base32
5613            "0k5r2qxn122pxi301ijir3nayi9sg4d7yiy276l36qmzwhp4mg5n"))))
5614       (inputs
5615        `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)
5616          ("babel" ,sbcl-babel)))
5617       (synopsis "Support Common Lisp library for CXML")
5618       (description "Closure-common is an internal helper library.  The name
5619 Closure is a reference to the web browser it was originally written for.")
5620       ;; TODO: License?
5621       (license #f))))
5622
5623 (define-public sbcl-cxml+xml
5624   (let ((commit "00b22bf4c4cf11c993d5866fae284f95ab18e6bf")
5625         (revision "1"))
5626     (package
5627       (name "sbcl-cxml+xml")
5628       (build-system asdf-build-system/sbcl)
5629       (version (git-version "0.0.0" revision commit))
5630       (home-page "https://common-lisp.net/project/cxml/")
5631       (source
5632        (origin
5633          (method git-fetch)
5634          (uri (git-reference
5635                (url "https://github.com/sharplispers/cxml")
5636                (commit commit)))
5637          (file-name (git-file-name name version))
5638          (sha256
5639           (base32
5640            "13kif7rf3gqdycsk9zq0d7y0g9y81krkl0z87k0p2fkbjfgrph37"))))
5641       (inputs
5642        `(("closure-common" ,sbcl-closure-common)
5643          ("puri" ,sbcl-puri)
5644          ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
5645       (arguments
5646        `(#:asd-file "cxml.asd"
5647          #:asd-system-name "cxml/xml"))
5648       (synopsis "Common Lisp XML parser")
5649       (description "CXML implements a namespace-aware, validating XML 1.0
5650 parser as well as the DOM Level 2 Core interfaces.  Two parser interfaces are
5651 offered, one SAX-like, the other similar to StAX.")
5652       (license license:llgpl))))
5653
5654 (define sbcl-cxml+dom
5655   (package
5656     (inherit sbcl-cxml+xml)
5657     (name "sbcl-cxml+dom")
5658     (inputs
5659      `(("closure-common" ,sbcl-closure-common)
5660        ("puri" ,sbcl-puri)
5661        ("cxml+xml" ,sbcl-cxml+xml)))
5662     (arguments
5663      `(#:asd-file "cxml.asd"
5664        #:asd-system-name "cxml/dom"))))
5665
5666 (define sbcl-cxml+klacks
5667   (package
5668     (inherit sbcl-cxml+xml)
5669     (name "sbcl-cxml+klacks")
5670     (inputs
5671      `(("closure-common" ,sbcl-closure-common)
5672        ("puri" ,sbcl-puri)
5673        ("cxml+xml" ,sbcl-cxml+xml)))
5674     (arguments
5675      `(#:asd-file "cxml.asd"
5676        #:asd-system-name "cxml/klacks"))))
5677
5678 (define sbcl-cxml+test
5679   (package
5680     (inherit sbcl-cxml+xml)
5681     (name "sbcl-cxml+test")
5682     (inputs
5683      `(("closure-common" ,sbcl-closure-common)
5684        ("puri" ,sbcl-puri)
5685        ("cxml+xml" ,sbcl-cxml+xml)))
5686     (arguments
5687      `(#:asd-file "cxml.asd"
5688        #:asd-system-name "cxml/test"))))
5689
5690 (define-public sbcl-cxml
5691   (package
5692     (inherit sbcl-cxml+xml)
5693     (name "sbcl-cxml")
5694     (inputs
5695      `(("closure-common" ,sbcl-closure-common)
5696        ("puri" ,sbcl-puri)
5697        ("trivial-gray-streams" ,sbcl-trivial-gray-streams)
5698        ("cxml+dom" ,sbcl-cxml+dom)
5699        ("cxml+klacks" ,sbcl-cxml+klacks)
5700        ("cxml+test" ,sbcl-cxml+test)))
5701     (arguments
5702      `(#:asd-file "cxml.asd"
5703        #:asd-system-name "cxml"
5704        #:phases
5705        (modify-phases %standard-phases
5706          (add-after 'build 'install-dtd
5707            (lambda* (#:key outputs #:allow-other-keys)
5708              (install-file "catalog.dtd"
5709                            (string-append
5710                             (assoc-ref outputs "out")
5711                             "/lib/" (%lisp-type)))))
5712          (add-after 'create-asd 'remove-component
5713            ;; XXX: The original .asd has no components, but our build system
5714            ;; creates an entry nonetheless.  We need to remove it for the
5715            ;; generated .asd to load properly.  See trivia.trivial for a
5716            ;; similar problem.
5717            (lambda* (#:key outputs #:allow-other-keys)
5718              (let* ((out (assoc-ref outputs "out"))
5719                     (asd (string-append out "/lib/sbcl/cxml.asd")))
5720                (substitute* asd
5721                  (("  :components
5722 ")
5723                   ""))
5724                (substitute* asd
5725                  ((" *\\(\\(:compiled-file \"cxml--system\"\\)\\)")
5726                   ""))))))))))
5727
5728 (define-public cl-cxml
5729   (sbcl-package->cl-source-package sbcl-cxml))
5730
5731 (define-public sbcl-cl-reexport
5732   (let ((commit "312f3661bbe187b5f28536cd7ec2956e91366c3b")
5733         (revision "1"))
5734     (package
5735       (name "sbcl-cl-reexport")
5736       (build-system asdf-build-system/sbcl)
5737       (version (git-version "0.1" revision commit))
5738       (home-page "https://github.com/takagi/cl-reexport")
5739       (source
5740        (origin
5741          (method git-fetch)
5742          (uri (git-reference
5743                (url home-page)
5744                (commit commit)))
5745          (file-name (git-file-name name version))
5746          (sha256
5747           (base32
5748            "1cwpn1m3wrl0fl9plznn7p464db646gnfc8zkyk97dyxski2aq0x"))))
5749       (inputs
5750        `(("alexandria" ,sbcl-alexandria)))
5751       (arguments
5752        ;; TODO: Tests fail because cl-test-more is missing, but I can't find it online.
5753        `(#:tests? #f))
5754       (synopsis "HTTP cookie manager for Common Lisp")
5755       (description "cl-cookie is a Common Lisp library featuring parsing of
5756 cookie headers, cookie creation, cookie jar creation and more.")
5757       (license license:llgpl))))
5758
5759 (define-public cl-reexport
5760   (sbcl-package->cl-source-package sbcl-cl-reexport))
5761
5762 (define-public sbcl-cl-cookie
5763   (let ((commit "cea55aed8b9ad25fafd13defbcb9fe8f41b29546")
5764         (revision "1"))
5765     (package
5766       (name "sbcl-cl-cookie")
5767       (build-system asdf-build-system/sbcl)
5768       (version (git-version "0.9.10" revision commit))
5769       (home-page "https://github.com/fukamachi/cl-cookie")
5770       (source
5771        (origin
5772          (method git-fetch)
5773          (uri (git-reference
5774                (url home-page)
5775                (commit commit)))
5776          (file-name (git-file-name name version))
5777          (sha256
5778           (base32
5779            "090g7z75h98zvc1ldx0vh4jn4086dhjm2w30jcwkq553qmyxwl8h"))))
5780       (inputs
5781        `(("proc-parse" ,sbcl-proc-parse)
5782          ("alexandria" ,sbcl-alexandria)
5783          ("quri" ,sbcl-quri)
5784          ("cl-ppcre" ,sbcl-cl-ppcre)
5785          ("local-time" ,sbcl-local-time)))
5786       (native-inputs
5787        `(("prove-asdf" ,sbcl-prove-asdf)
5788          ("prove" ,sbcl-prove)))
5789       (arguments
5790        ;; TODO: Tests fail because cl-cookie depends on cl-cookie-test.
5791        `(#:tests? #f))
5792       (synopsis "HTTP cookie manager for Common Lisp")
5793       (description "cl-cookie is a Common Lisp library featuring parsing of
5794 cookie headers, cookie creation, cookie jar creation and more.")
5795       (license license:bsd-2))))
5796
5797 (define-public cl-cookie
5798   (sbcl-package->cl-source-package sbcl-cl-cookie))
5799
5800 (define-public sbcl-dexador
5801   (let ((commit "953090f04c4d1a9ee6632b90133cdc297b68badc")
5802         (revision "1"))
5803     (package
5804       (name "sbcl-dexador")
5805       (build-system asdf-build-system/sbcl)
5806       (version "0.9.14" )
5807       (home-page "https://github.com/fukamachi/dexador")
5808       (source
5809        (origin
5810          (method git-fetch)
5811          (uri (git-reference
5812                (url home-page)
5813                (commit commit)))
5814          (file-name (git-file-name name version))
5815          (sha256
5816           (base32
5817            "0w18fz3301rpmwc3kwb810czcd24mbf7r1z8vdyc0v5crjfpw3mn"))))
5818       (inputs
5819        `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)
5820          ("babel" ,sbcl-babel)
5821          ("usocket" ,sbcl-usocket)
5822          ("fast-http" ,sbcl-fast-http)
5823          ("quri" ,sbcl-quri)
5824          ("fast-io" ,sbcl-fast-io)
5825          ("chunga" ,sbcl-chunga)
5826          ("cl-ppcre" ,sbcl-cl-ppcre)
5827          ("cl-cookie" ,sbcl-cl-cookie)
5828          ("trivial-mimes" ,sbcl-trivial-mimes)
5829          ("chipz" ,sbcl-chipz)
5830          ("cl-base64" ,sbcl-cl-base64)
5831          ("cl-reexport" ,sbcl-cl-reexport)
5832          ("cl+ssl" ,sbcl-cl+ssl)
5833          ("bordeaux-threads" ,sbcl-bordeaux-threads)
5834          ("alexandria" ,sbcl-alexandria)))
5835       (native-inputs
5836        `(("prove" ,sbcl-prove)
5837          ("prove-asdf" ,sbcl-prove-asdf)
5838          ("lack-request" ,sbcl-lack-request)
5839          ("clack" ,sbcl-clack)
5840          ("babel" ,sbcl-babel)
5841          ("alexandria" ,sbcl-alexandria)
5842          ("cl-ppcre" ,sbcl-cl-ppcre)
5843          ("local-time" ,sbcl-local-time)
5844          ("trivial-features" ,sbcl-trivial-features)))
5845       (arguments
5846        ;; TODO: Circular dependency: tests depend on clack-test which depends on dexador.
5847        `(#:tests? #f
5848          #:phases
5849          (modify-phases %standard-phases
5850            (add-after 'unpack 'fix-permissions
5851              (lambda _ (make-file-writable "t/data/test.gz") #t)))))
5852       (synopsis "Yet another HTTP client for Common Lisp")
5853       (description "Dexador is yet another HTTP client for Common Lisp with
5854 neat APIs and connection-pooling.  It is meant to supersede Drakma.")
5855       (license license:expat))))
5856
5857 (define-public cl-dexador
5858   (package
5859     (inherit (sbcl-package->cl-source-package sbcl-dexador))
5860     (arguments
5861      `(#:phases
5862        ;; asdf-build-system/source has its own phases and does not inherit
5863        ;; from asdf-build-system/sbcl phases.
5864        (modify-phases %standard-phases/source
5865          ;; Already done in SBCL package.
5866          (delete 'reset-gzip-timestamps))))))
5867
5868 (define-public ecl-dexador
5869   (sbcl-package->ecl-package sbcl-dexador))
5870
5871 (define-public sbcl-lisp-namespace
5872   (let ((commit "28107cafe34e4c1c67490fde60c7f92dc610b2e0")
5873         (revision "1"))
5874     (package
5875       (name "sbcl-lisp-namespace")
5876       (build-system asdf-build-system/sbcl)
5877       (version (git-version "0.1" revision commit))
5878       (home-page "https://github.com/guicho271828/lisp-namespace")
5879       (source
5880        (origin
5881          (method git-fetch)
5882          (uri (git-reference
5883                (url home-page)
5884                (commit commit)))
5885          (file-name (git-file-name name version))
5886          (sha256
5887           (base32
5888            "1jw2wykp06z2afb9nm1lgfzll5cjlj36pnknjx614057zkkxq4iy"))))
5889       (inputs
5890        `(("alexandria" ,sbcl-alexandria)))
5891       (native-inputs
5892        `(("fiveam" ,sbcl-fiveam)))
5893       (arguments
5894        `(#:test-asd-file "lisp-namespace.test.asd"
5895         ;; XXX: Component LISP-NAMESPACE-ASD::LISP-NAMESPACE.TEST not found
5896          #:tests? #f))
5897       (synopsis "LISP-N, or extensible namespaces in Common Lisp")
5898       (description "Common Lisp already has major 2 namespaces, function
5899 namespace and value namespace (or variable namespace), but there are actually
5900 more — e.g., class namespace.
5901 This library offers macros to deal with symbols from any namespace.")
5902       (license license:llgpl))))
5903
5904 (define-public cl-lisp-namespace
5905   (sbcl-package->cl-source-package sbcl-lisp-namespace))
5906
5907 (define-public sbcl-trivial-cltl2
5908   (let ((commit "8a3bda30dc25d2f65fcf514d0eb6e6db75252c61")
5909         (revision "2"))
5910     (package
5911       (name "sbcl-trivial-cltl2")
5912       (build-system asdf-build-system/sbcl)
5913       (version (git-version "0.1.1" revision commit))
5914       (home-page "https://github.com/Zulu-Inuoe/trivial-cltl2")
5915       (source
5916        (origin
5917          (method git-fetch)
5918          (uri (git-reference
5919                (url home-page)
5920                (commit commit)))
5921          (file-name (git-file-name name version))
5922          (sha256
5923           (base32
5924            "08cnzb9rnczn4pn2zpf0587ny4wjy1mjndy885fz9pw7xrlx37ip"))))
5925       (synopsis "Simple CLtL2 compatibility layer for Common Lisp")
5926       (description "This library is a portable compatibility layer around
5927 \"Common Lisp the Language, 2nd
5928 Edition\" (@url{https://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node102.html})
5929 and it exports symbols from implementation-specific packages.")
5930       (license license:llgpl))))
5931
5932 (define-public cl-trivial-cltl2
5933   (sbcl-package->cl-source-package sbcl-trivial-cltl2))
5934
5935 (define-public sbcl-introspect-environment
5936   (let ((commit "fff42f8f8fd0d99db5ad6c5812e53de7d660020b")
5937         (revision "1"))
5938     (package
5939       (name "sbcl-introspect-environment")
5940       (build-system asdf-build-system/sbcl)
5941       (version (git-version "0.1" revision commit))
5942       (home-page "https://github.com/Bike/introspect-environment")
5943       (source
5944        (origin
5945          (method git-fetch)
5946          (uri (git-reference
5947                (url home-page)
5948                (commit commit)))
5949          (file-name (git-file-name name version))
5950          (sha256
5951           (base32
5952            "1i305n0wfmpac63ni4i3vixnnkl8daw5ncxy0k3dv92krgx6qzhp"))))
5953       (native-inputs
5954        `(("fiveam" ,sbcl-fiveam)))
5955       (synopsis "Common Lisp environment introspection portability layer")
5956       (description "This library is a small interface to portable but
5957 nonstandard introspection of Common Lisp environments.  It is intended to
5958 allow a bit more compile-time introspection of environments in Common Lisp.
5959
5960 Quite a bit of information is available at the time a macro or compiler-macro
5961 runs; inlining info, type declarations, that sort of thing.  This information
5962 is all standard - any Common Lisp program can @code{(declare (integer x))} and
5963 such.
5964
5965 This info ought to be accessible through the standard @code{&environment}
5966 parameters, but it is not.  Several implementations keep the information for
5967 their own purposes but do not make it available to user programs, because
5968 there is no standard mechanism to do so.
5969
5970 This library uses implementation-specific hooks to make information available
5971 to users.  This is currently supported on SBCL, CCL, and CMUCL.  Other
5972 implementations have implementations of the functions that do as much as they
5973 can and/or provide reasonable defaults.")
5974       (license license:wtfpl2))))
5975
5976 (define-public cl-introspect-environment
5977   (sbcl-package->cl-source-package sbcl-introspect-environment))
5978
5979 (define-public sbcl-type-i
5980   (let ((commit "d34440ab4ebf5a46a58deccb35950b15670e3667")
5981         (revision "2"))
5982     (package
5983       (name "sbcl-type-i")
5984       (build-system asdf-build-system/sbcl)
5985       (version (git-version "0.1" revision commit))
5986       (home-page "https://github.com/guicho271828/type-i")
5987       (source
5988        (origin
5989          (method git-fetch)
5990          (uri (git-reference
5991                (url home-page)
5992                (commit commit)))
5993          (file-name (git-file-name name version))
5994          (sha256
5995           (base32
5996            "12wsga0pwjkkr176lnjwkmmlm3ccp0n310sjj9h20lk53iyd0z69"))))
5997       (inputs
5998        `(("alexandria" ,sbcl-alexandria)
5999          ("introspect-environment" ,sbcl-introspect-environment)
6000          ("trivia.trivial" ,sbcl-trivia.trivial)))
6001       (native-inputs
6002        `(("fiveam" ,sbcl-fiveam)))
6003       (arguments
6004        `(#:test-asd-file "type-i.test.asd"))
6005       (synopsis "Type inference utility on unary predicates for Common Lisp")
6006       (description "This library tries to provide a way to detect what kind of
6007 type the given predicate is trying to check.  This is different from inferring
6008 the return type of a function.")
6009       (license license:llgpl))))
6010
6011 (define-public cl-type-i
6012   (sbcl-package->cl-source-package sbcl-type-i))
6013
6014 (define-public sbcl-optima
6015   (let ((commit "373b245b928c1a5cce91a6cb5bfe5dd77eb36195")
6016         (revision "1"))
6017     (package
6018       (name "sbcl-optima")
6019       (build-system asdf-build-system/sbcl)
6020       (version (git-version "1.0" revision commit))
6021       (home-page "https://github.com/m2ym/optima")
6022       (source
6023        (origin
6024          (method git-fetch)
6025          (uri (git-reference
6026                (url home-page)
6027                (commit commit)))
6028          (file-name (git-file-name name version))
6029          (sha256
6030           (base32
6031            "1yw4ymq7ms89342kkvb3aqxgv0w38m9kd8ikdqxxzyybnkjhndal"))))
6032       (inputs
6033        `(("alexandria" ,sbcl-alexandria)
6034          ("closer-mop" ,sbcl-closer-mop)))
6035       (native-inputs
6036        `(("eos" ,sbcl-eos)))
6037       (arguments
6038        ;; XXX: Circular dependencies: tests depend on optima.ppcre which depends on optima.
6039        `(#:tests? #f
6040          #:test-asd-file "optima.test.asd"))
6041       (synopsis "Optimized pattern matching library for Common Lisp")
6042       (description "Optima is a fast pattern matching library which uses
6043 optimizing techniques widely used in the functional programming world.")
6044       (license license:expat))))
6045
6046 (define-public cl-optima
6047   (sbcl-package->cl-source-package sbcl-optima))
6048
6049 (define-public sbcl-fare-quasiquote
6050   (let ((commit "640d39a0451094071b3e093c97667b3947f43639")
6051         (revision "1"))
6052     (package
6053       (name "sbcl-fare-quasiquote")
6054       (build-system asdf-build-system/sbcl)
6055       (version (git-version "1.0.1" revision commit))
6056       (home-page "https://gitlab.common-lisp.net/frideau/fare-quasiquote")
6057       (source
6058        (origin
6059          (method git-fetch)
6060          (uri (git-reference
6061                (url (string-append "https://gitlab.common-lisp.net/frideau/"
6062                                    "fare-quasiquote.git"))
6063                (commit commit)))
6064          (file-name (git-file-name name version))
6065          (sha256
6066           (base32 "1g6q11l50kgija9f55lzqpcwvaq0ljiw8v1j265hnyg6nahjwjvg"))))
6067       (inputs
6068        `(("fare-utils" ,sbcl-fare-utils)))
6069       (arguments
6070        ;; XXX: Circular dependencies: Tests depend on subsystems,
6071        ;; which depend on the main systems.
6072        `(#:tests? #f
6073          #:phases
6074          (modify-phases %standard-phases
6075            ;; XXX: Require 1.0.0 version of fare-utils, and we package some
6076            ;; commits after 1.0.0.5, but ASDF fails to read the
6077            ;; "-REVISION-COMMIT" part generated by Guix.
6078            (add-after 'unpack 'patch-requirement
6079              (lambda _
6080                (substitute* "fare-quasiquote.asd"
6081                  (("\\(:version \"fare-utils\" \"1.0.0\"\\)")
6082                   "\"fare-utils\"")))))))
6083       (synopsis "Pattern-matching friendly implementation of quasiquote")
6084       (description "The main purpose of this n+2nd reimplementation of
6085 quasiquote is enable matching of quasiquoted patterns, using Optima or
6086 Trivia.")
6087       (license license:expat))))
6088
6089 (define-public cl-fare-quasiquote
6090   (sbcl-package->cl-source-package sbcl-fare-quasiquote))
6091
6092 (define-public sbcl-fare-quasiquote-optima
6093   (package
6094     (inherit sbcl-fare-quasiquote)
6095     (name "sbcl-fare-quasiquote-optima")
6096     (inputs
6097      `(("optima" ,sbcl-optima)
6098        ("fare-quasiquote" ,sbcl-fare-quasiquote)))
6099     (arguments
6100      '(#:phases
6101        (modify-phases %standard-phases
6102          (add-after 'unpack 'patch-requirement
6103            (lambda _
6104              (substitute* "fare-quasiquote-optima.asd"
6105                (("\\(:version \"optima\" \"1\\.0\"\\)")
6106                 "\"optima\""))
6107              #t)))))))
6108
6109 (define-public cl-fare-quasiquote-optima
6110   (sbcl-package->cl-source-package sbcl-fare-quasiquote-optima))
6111
6112 (define-public sbcl-fare-quasiquote-readtable
6113   (package
6114     (inherit sbcl-fare-quasiquote)
6115     (name "sbcl-fare-quasiquote-readtable")
6116     (inputs
6117      `(("fare-quasiquote" ,sbcl-fare-quasiquote)
6118        ("named-readtables" ,sbcl-named-readtables)))
6119     (description "The main purpose of this n+2nd reimplementation of
6120 quasiquote is enable matching of quasiquoted patterns, using Optima or
6121 Trivia.
6122
6123 This package uses fare-quasiquote with named-readtable.")))
6124
6125 (define-public cl-fare-quasiquote-readtable
6126   (sbcl-package->cl-source-package sbcl-fare-quasiquote-readtable))
6127
6128 ;; TODO: Add support for component-less system in asdf-build-system/sbcl.
6129 (define-public sbcl-fare-quasiquote-extras
6130   (package
6131     (inherit sbcl-fare-quasiquote)
6132     (name "sbcl-fare-quasiquote-extras")
6133     (build-system asdf-build-system/sbcl)
6134     (inputs
6135      `(("fare-quasiquote-optima" ,sbcl-fare-quasiquote-optima)
6136        ("fare-quasiquote-readtable" ,sbcl-fare-quasiquote-readtable)))
6137     (arguments
6138      `(#:phases
6139        (modify-phases %standard-phases
6140          (replace 'build
6141            (lambda* (#:key outputs #:allow-other-keys)
6142              (let* ((out (assoc-ref outputs "out"))
6143                     (lib (string-append out "/lib/" (%lisp-type))))
6144                (mkdir-p lib)
6145                (install-file "fare-quasiquote-extras.asd" lib)
6146                (make-file-writable
6147                 (string-append lib "/fare-quasiquote-extras.asd"))
6148                #t)))
6149          (add-after 'create-asd-file 'fix-asd-file
6150            (lambda* (#:key outputs #:allow-other-keys)
6151              (let* ((out (assoc-ref outputs "out"))
6152                     (lib (string-append out "/lib/" (%lisp-type)))
6153                     (asd (string-append lib "/fare-quasiquote-extras.asd")))
6154                (substitute* asd
6155                  ((":class")
6156                   "")
6157                  (("asdf/bundle:prebuilt-system")
6158                   "")
6159                  ((":components")
6160                   "")
6161                  (("\\(\\(:compiled-file \"fare-quasiquote-extras--system\"\\)\\)")
6162                   "")))
6163              #t)))))
6164     (description "This library combines @code{fare-quasiquote-readtable} and
6165 @code{fare-quasiquote-optima}.")))
6166
6167 (define-public cl-fare-quasiquote-extras
6168   (package
6169     (inherit cl-fare-quasiquote)
6170     (name "cl-fare-quasiquote-extras")
6171     (build-system asdf-build-system/source)
6172     (propagated-inputs
6173      `(("fare-quasiquote" ,cl-fare-quasiquote)
6174        ("fare-quasiquote-optima" ,cl-fare-quasiquote-optima)
6175        ("fare-quasiquote-readtable" ,cl-fare-quasiquote-readtable)))
6176     (description "This library combines @code{fare-quasiquote-readtable} and
6177 @code{fare-quasiquote-optima}.")))
6178
6179 (define-public sbcl-trivia.level0
6180   (let ((commit "37698b47a14c2007630468de7a993694ef7bd475")
6181         (revision "2"))
6182     (package
6183       (name "sbcl-trivia.level0")
6184       (build-system asdf-build-system/sbcl)
6185       (version (git-version "0.0.0" revision commit))
6186       (home-page "https://github.com/guicho271828/trivia")
6187       (source
6188        (origin
6189          (method git-fetch)
6190          (uri (git-reference
6191                (url home-page)
6192                (commit commit)))
6193          (file-name (git-file-name name version))
6194          (sha256
6195           (base32
6196            "0rsbwbw3ipxxgr6zzhci12nilq8zky475kmhz1rcxy4q8a85vn72"))))
6197       (inputs
6198        `(("alexandria" ,sbcl-alexandria)))
6199       (synopsis "Pattern matching in Common Lisp")
6200       (description "Trivia is a pattern matching compiler that is compatible
6201 with Optima, another pattern matching library for Common Lisp.  It is meant to
6202 be faster and more extensible than Optima.")
6203       (license license:llgpl))))
6204
6205 (define-public sbcl-trivia.level1
6206   (package
6207     (inherit sbcl-trivia.level0)
6208     (name "sbcl-trivia.level1")
6209     (inputs
6210      `(("trivia.level0" ,sbcl-trivia.level0)))
6211     (description "Trivia is a pattern matching compiler that is compatible
6212 with Optima, another pattern matching library for Common Lisp.  It is meant to
6213 be faster and more extensible than Optima.
6214
6215 This system contains the core patterns of Trivia.")))
6216
6217 (define-public sbcl-trivia.level2
6218   (package
6219     (inherit sbcl-trivia.level0)
6220     (name "sbcl-trivia.level2")
6221     (inputs
6222      `(("trivia.level1" ,sbcl-trivia.level1)
6223        ("lisp-namespace" ,sbcl-lisp-namespace)
6224        ("trivial-cltl2" ,sbcl-trivial-cltl2)
6225        ("closer-mop" ,sbcl-closer-mop)))
6226     (description "Trivia is a pattern matching compiler that is compatible
6227 with Optima, another pattern matching library for Common Lisp.  It is meant to
6228 be faster and more extensible than Optima.
6229
6230 This system contains a non-optimized pattern matcher compatible with Optima,
6231 with extensible optimizer interface.")))
6232
6233 (define-public sbcl-trivia.trivial
6234   (package
6235     (inherit sbcl-trivia.level0)
6236     (name "sbcl-trivia.trivial")
6237     (inputs
6238      `(("trivia.level2" ,sbcl-trivia.level2)))
6239     (arguments
6240      `(#:phases
6241        (modify-phases %standard-phases
6242          (replace 'create-asd-file
6243            (lambda* (#:key outputs inputs #:allow-other-keys)
6244              (let* ((out (assoc-ref outputs "out"))
6245                     (lib (string-append out "/lib/" (%lisp-type)))
6246                     (level2 (assoc-ref inputs "trivia.level2")))
6247                (mkdir-p lib)
6248                (install-file "trivia.trivial.asd" lib)
6249                ;; XXX: This .asd does not have any component and the build
6250                ;; system fails to work in this case.  We should update the
6251                ;; build system to handle component-less .asd.
6252                ;; TODO: How do we append to file in Guile?  It seems that
6253                ;; (open-file ... "a") gets a "Permission denied".
6254                (substitute* (string-append lib "/trivia.trivial.asd")
6255                  (("\"\\)")
6256                   (string-append "\")
6257
6258 (progn (asdf/source-registry:ensure-source-registry)
6259        (setf (gethash
6260                \"trivia.level2\"
6261                asdf/source-registry:*source-registry*)
6262              #p\""
6263                                  level2
6264                                  "/share/common-lisp/sbcl-bundle-systems/trivia.level2.asd\"))")))))))))
6265     (description "Trivia is a pattern matching compiler that is compatible
6266 with Optima, another pattern matching library for Common Lisp.  It is meant to
6267 be faster and more extensible than Optima.
6268
6269 This system contains the base level system of Trivia with a trivial optimizer.")))
6270
6271 (define-public sbcl-trivia.balland2006
6272   (package
6273     (inherit sbcl-trivia.level0)
6274     (name "sbcl-trivia.balland2006")
6275     (inputs
6276      `(("trivia.trivial" ,sbcl-trivia.trivial)
6277        ("iterate" ,sbcl-iterate)
6278        ("type-i" ,sbcl-type-i)
6279        ("alexandria" ,sbcl-alexandria)))
6280     (arguments
6281      ;; Tests are done in trivia itself.
6282      `(#:tests? #f))
6283     (description "Trivia is a pattern matching compiler that is compatible
6284 with Optima, another pattern matching library for Common Lisp.  It is meant to
6285 be faster and more extensible than Optima.
6286
6287 This system contains the base level system of Trivia with a trivial optimizer.")))
6288
6289 (define-public sbcl-trivia.ppcre
6290   (package
6291     (inherit sbcl-trivia.level0)
6292     (name "sbcl-trivia.ppcre")
6293     (inputs
6294      `(("trivia.trivial" ,sbcl-trivia.trivial)
6295        ("cl-ppcre" ,sbcl-cl-ppcre)))
6296     (description "Trivia is a pattern matching compiler that is compatible
6297 with Optima, another pattern matching library for Common Lisp.  It is meant to
6298 be faster and more extensible than Optima.
6299
6300 This system contains the PPCRE extension.")))
6301
6302 (define-public sbcl-trivia.quasiquote
6303   (package
6304     (inherit sbcl-trivia.level0)
6305     (name "sbcl-trivia.quasiquote")
6306     (inputs
6307      `(("trivia.trivial" ,sbcl-trivia.trivial)
6308        ("fare-quasiquote" ,sbcl-fare-quasiquote)
6309        ("fare-quasiquote-readtable" ,sbcl-fare-quasiquote-readtable)))
6310     (description "Trivia is a pattern matching compiler that is compatible
6311 with Optima, another pattern matching library for Common Lisp.  It is meant to
6312 be faster and more extensible than Optima.
6313
6314 This system contains the fare-quasiquote extension.")))
6315
6316 (define-public sbcl-trivia.cffi
6317   (package
6318     (inherit sbcl-trivia.level0)
6319     (name "sbcl-trivia.cffi")
6320     (inputs
6321      `(("cffi" ,sbcl-cffi)
6322        ("trivia.trivial" ,sbcl-trivia.trivial)))
6323     (description "Trivia is a pattern matching compiler that is compatible
6324 with Optima, another pattern matching library for Common Lisp.  It is meant to
6325 be faster and more extensible than Optima.
6326
6327 This system contains the CFFI foreign slot access extension.")))
6328
6329 (define-public sbcl-trivia
6330   (package
6331     (inherit sbcl-trivia.level0)
6332     (name "sbcl-trivia")
6333     (inputs
6334      `(("trivia.balland2006" ,sbcl-trivia.balland2006)))
6335     (native-inputs
6336      `(("fiveam" ,sbcl-fiveam)
6337        ("trivia.ppcre" ,sbcl-trivia.ppcre)
6338        ("trivia.quasiquote" ,sbcl-trivia.quasiquote)
6339        ("trivia.cffi" ,sbcl-trivia.cffi)
6340        ("optima" ,sbcl-optima)))
6341     (arguments
6342      `(#:test-asd-file "trivia.test.asd"
6343        #:phases
6344        (modify-phases %standard-phases
6345          (add-after 'create-asd 'remove-component
6346            ;; XXX: The original .asd has no components, but our build system
6347            ;; creates an entry nonetheless.  We need to remove it for the
6348            ;; generated .asd to load properly.  See trivia.trivial for a
6349            ;; similar problem.
6350            (lambda* (#:key outputs #:allow-other-keys)
6351              (let* ((out (assoc-ref outputs "out"))
6352                     (asd (string-append out "/lib/" (%lisp-type) "/trivia.asd")))
6353                (substitute* asd
6354                  (("  :components
6355 ")
6356                   ""))
6357                (substitute* asd
6358                  ((" *\\(\\(:compiled-file \"trivia--system\"\\)\\)")
6359                   ""))))))))
6360     (description "Trivia is a pattern matching compiler that is compatible
6361 with Optima, another pattern matching library for Common Lisp.  It is meant to
6362 be faster and more extensible than Optima.")))
6363
6364 (define-public cl-trivia
6365   (sbcl-package->cl-source-package sbcl-trivia))
6366
6367 (define-public sbcl-mk-string-metrics
6368   (package
6369     (name "sbcl-mk-string-metrics")
6370     (version "0.1.2")
6371     (home-page "https://github.com/cbaggers/mk-string-metrics/")
6372     (source (origin
6373               (method git-fetch)
6374               (uri (git-reference
6375                     (url home-page)
6376                     (commit version)))
6377               (sha256
6378                (base32 "0bg0bv2mfd4k0g3x72x563hvmrx18xavaffr6xk5rh4if5j7kcf6"))
6379               (file-name (git-file-name name version))))
6380     (build-system asdf-build-system/sbcl)
6381     (synopsis "Calculate various string metrics efficiently in Common Lisp")
6382     (description "This library implements efficient algorithms that calculate
6383 various string metrics in Common Lisp:
6384
6385 @itemize
6386 @item Damerau-Levenshtein distance
6387 @item Hamming distance
6388 @item Jaccard similarity coefficient
6389 @item Jaro distance
6390 @item Jaro-Winkler distance
6391 @item Levenshtein distance
6392 @item Normalized Damerau-Levenshtein distance
6393 @item Normalized Levenshtein distance
6394 @item Overlap coefficient
6395 @end itemize\n")
6396     (license license:x11)))
6397
6398 (define-public cl-mk-string-metrics
6399   (sbcl-package->cl-source-package sbcl-mk-string-metrics))
6400
6401 (define-public sbcl-cl-str
6402   (let ((commit "eb480f283e28802d67b35bf916506701152f9a2a"))
6403     (package
6404       (name "sbcl-cl-str")
6405       (version (git-version "0.17" "1" commit))
6406       (home-page "https://github.com/vindarel/cl-str")
6407       (source (origin
6408                 (method git-fetch)
6409                 (uri (git-reference
6410                       (url home-page)
6411                       (commit commit)))
6412                 (sha256
6413                  (base32 "1hpq5m8zjjnzns370zy27z2vcm1p8n2ka5ij2x67gyc9amz9vla0"))
6414                 (file-name (git-file-name name version))))
6415       (build-system asdf-build-system/sbcl)
6416       (inputs
6417        `(("cl-ppcre" ,sbcl-cl-ppcre)
6418          ("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)
6419          ("cl-change-case" ,sbcl-cl-change-case)))
6420       (native-inputs
6421        `(("prove" ,sbcl-prove)
6422          ("prove-asdf" ,sbcl-prove-asdf)))
6423       (arguments
6424        `(#:asd-file "str.asd"
6425          #:asd-system-name "str"
6426          #:test-asd-file "str.test.asd"))
6427       (synopsis "Modern, consistent and terse Common Lisp string manipulation library")
6428       (description "A modern and consistent Common Lisp string manipulation
6429 library that focuses on modernity, simplicity and discoverability:
6430 @code{(str:trim s)} instead of @code{(string-trim '(#\\Space ...) s)}), or
6431 @code{str:concat strings} instead of an unusual format construct; one
6432 discoverable library instead of many; consistency and composability, where
6433 @code{s} is always the last argument, which makes it easier to feed pipes and
6434 arrows.")
6435       (license license:expat))))
6436
6437 (define-public cl-str
6438   (sbcl-package->cl-source-package sbcl-cl-str))
6439
6440 (define-public sbcl-cl-xmlspam
6441   (let ((commit "ea06abcca2a73a9779bcfb09081e56665f94e22a"))
6442     (package
6443       (name "sbcl-cl-xmlspam")
6444       (build-system asdf-build-system/sbcl)
6445       (version (git-version "0.0.0" "1" commit))
6446       (home-page "https://github.com/rogpeppe/cl-xmlspam")
6447       (source
6448        (origin
6449          (method git-fetch)
6450          (uri (git-reference
6451                (url home-page)
6452                (commit commit)))
6453          (file-name (string-append name "-" version))
6454          (sha256
6455           (base32
6456            "0w4rqvrgdgk3fwfq3kx4r7wwdr2bv3b6n3bdqwsiriw9psqzpz2s"))))
6457       (inputs
6458        `(("cxml" ,sbcl-cxml)
6459          ("cl-ppcre" ,sbcl-cl-ppcre)))
6460       (synopsis "Concise, regexp-like pattern matching on streaming XML for Common Lisp")
6461       (description "CXML does an excellent job at parsing XML elements, but what
6462 do you do when you have a XML file that's larger than you want to fit in
6463 memory, and you want to extract some information from it?  Writing code to deal
6464 with SAX events, or even using Klacks, quickly becomes tedious.
6465 @code{cl-xmlspam} (for XML Stream PAttern Matcher) is designed to make it easy
6466 to write code that mirrors the structure of the XML that it's parsing.  It
6467 also makes it easy to shift paradigms when necessary - the usual Lisp control
6468 constructs can be used interchangeably with pattern matching, and the full
6469 power of CXML is available when necessary.")
6470       (license license:bsd-3))))
6471
6472 ;; TODO: dbus uses ASDF's package-inferred-system which is not supported by
6473 ;; asdf-build-system/sbcl as of 2019-08-02.  We should fix
6474 ;; asdf-build-system/sbcl.
6475 (define-public cl-dbus
6476   (let ((commit "24b452df3a45ca5dc95015500f34baad175c981a")
6477         (revision "1"))
6478     (package
6479       (name "cl-dbus")
6480       (build-system asdf-build-system/source)
6481       (version (git-version "20190408" revision commit))
6482       (home-page "https://github.com/death/dbus")
6483       (source
6484        (origin
6485          (method git-fetch)
6486          (uri (git-reference
6487                (url home-page)
6488                (commit commit)))
6489          (file-name (git-file-name name version))
6490          (sha256
6491           (base32
6492            "0fw2q866yddbf23nk9pxphm9gsasx35vjyss82xzvndnjmzlqfl5"))))
6493       ;; Inputs must be propagated or else packages depending on this won't
6494       ;; have the necessary packages.
6495       (propagated-inputs
6496        `(("alexandria" ,sbcl-alexandria)
6497          ("trivial-garbage" ,sbcl-trivial-garbage)
6498          ("babel" ,sbcl-babel)
6499          ("iolib" ,sbcl-iolib)
6500          ("ieee-floats" ,sbcl-ieee-floats)
6501          ("flexi-streams" ,sbcl-flexi-streams)
6502          ("cl-xmlspam" ,sbcl-cl-xmlspam)
6503          ("ironclad" ,sbcl-ironclad)))
6504       (synopsis "D-Bus client library for Common Lisp")
6505       (description "This is a Common Lisp library that publishes D-Bus
6506 objects as well as send and notify other objects connected to a bus.")
6507       (license license:bsd-2))))
6508
6509 (define-public sbcl-cl-hooks
6510   (let ((commit "5b638083f3b4f1221a52631d9c8a0a265565cac7")
6511         (revision "1"))
6512     (package
6513       (name "sbcl-cl-hooks")
6514       (build-system asdf-build-system/sbcl)
6515       (version (git-version "0.2.1" revision commit))
6516       (home-page "https://github.com/scymtym/architecture.hooks")
6517       (source
6518        (origin
6519          (method git-fetch)
6520          (uri (git-reference
6521                (url home-page)
6522                (commit commit)))
6523          (file-name (git-file-name name version))
6524          (sha256
6525           (base32
6526            "0bg3l0a28lw5gqqjp6p6b5nhwqk46sgkb7184w5qbfngw1hk8x9y"))))
6527       (inputs
6528        `(("alexandria" ,sbcl-alexandria)
6529          ("let-plus" ,sbcl-let-plus)
6530          ("trivial-garbage" ,sbcl-trivial-garbage)
6531          ("closer-mop" ,sbcl-closer-mop)))
6532       (native-inputs
6533        `(("fiveam" ,sbcl-fiveam)))
6534       (synopsis "Hooks extension point mechanism (as in Emacs) for Common Lisp")
6535       (description "A hook, in the present context, is a certain kind of
6536 extension point in a program that allows interleaving the execution of
6537 arbitrary code with the execution of a the program without introducing any
6538 coupling between the two.  Hooks are used extensively in the extensible editor
6539 Emacs.
6540
6541 In the Common LISP Object System (CLOS), a similar kind of extensibility is
6542 possible using the flexible multi-method dispatch mechanism.  It may even seem
6543 that the concept of hooks does not provide any benefits over the possibilities
6544 of CLOS.  However, there are some differences:
6545
6546 @itemize
6547
6548 @item There can be only one method for each combination of specializers and
6549 qualifiers.  As a result this kind of extension point cannot be used by
6550 multiple extensions independently.
6551 @item Removing code previously attached via a @code{:before}, @code{:after} or
6552 @code{:around} method can be cumbersome.
6553 @item There could be other or even multiple extension points besides @code{:before}
6554 and @code{:after} in a single method.
6555 @item Attaching codes to individual objects using eql specializers can be
6556 cumbersome.
6557 @item Introspection of code attached a particular extension point is
6558 cumbersome since this requires enumerating and inspecting the methods of a
6559 generic function.
6560 @end itemize
6561
6562 This library tries to complement some of these weaknesses of method-based
6563 extension-points via the concept of hooks.")
6564       (license license:llgpl))))
6565
6566 (define-public cl-hooks
6567   (sbcl-package->cl-source-package sbcl-cl-hooks))
6568
6569 (define-public ecl-cl-hooks
6570   (sbcl-package->ecl-package sbcl-cl-hooks))
6571
6572 (define-public sbcl-s-sysdeps
6573   ;; No release since 2013.
6574   (let ((commit "9aa23bbdceb24bcdbe0e7c39fa1901858f823106")
6575         (revision "2"))
6576     (package
6577       (name "sbcl-s-sysdeps")
6578       (build-system asdf-build-system/sbcl)
6579       (version (git-version "1" revision commit))
6580       (home-page "https://github.com/svenvc/s-sysdeps")
6581       (source
6582        (origin
6583          (method git-fetch)
6584          (uri (git-reference
6585                (url home-page)
6586                (commit commit)))
6587          (file-name (git-file-name name version))
6588          (sha256
6589           (base32
6590            "1fh8r7kf8s3hvqdg6b71b8p7w3v2kkga9bw8j3qqdxhzr6anpm0b"))))
6591       (inputs
6592        `(("bordeaux-threads" ,sbcl-bordeaux-threads)
6593          ("usocket" ,sbcl-usocket)
6594          ("usocket-server" ,sbcl-usocket-server)))
6595       (synopsis "Common Lisp abstraction layer over platform dependent functionality")
6596       (description "@code{s-sysdeps} is an abstraction layer over platform
6597 dependent functionality.  This simple package is used as a building block in a
6598 number of other open source projects.
6599
6600 @code{s-sysdeps} abstracts:
6601
6602 @itemize
6603 @item managing processes,
6604 @item implementing a standard TCP/IP server,
6605 @item opening a client TCP/IP socket stream,
6606 @item working with process locks.
6607 @end itemize\n")
6608       (license license:llgpl))))
6609
6610 (define-public cl-s-sysdeps
6611   (sbcl-package->cl-source-package sbcl-s-sysdeps))
6612
6613 (define-public ecl-s-sysdeps
6614   (sbcl-package->ecl-package sbcl-s-sysdeps))
6615
6616 (define-public sbcl-cl-prevalence
6617   (let ((commit "da3ed6c4594b1c2fca90c178c1993973c4bf16c9")
6618         (revision "2"))
6619     (package
6620       (name "sbcl-cl-prevalence")
6621       (build-system asdf-build-system/sbcl)
6622       (version (git-version "5" revision commit))
6623       (home-page "https://github.com/40ants/cl-prevalence")
6624       (source
6625        (origin
6626          (method git-fetch)
6627          (uri (git-reference
6628                (url home-page)
6629                (commit commit)))
6630          (file-name (git-file-name name version))
6631          (sha256
6632           (base32
6633            "0bq905hv1626dl6b7s0zn4lbdh608g1pxaljl1fda6pwp9hmj95a"))))
6634       (inputs
6635        `(("s-sysdeps" ,sbcl-s-sysdeps)
6636          ("s-xml" ,sbcl-s-xml)))
6637       (synopsis "Implementation of object prevalence for Common Lisp")
6638       (description "This Common Lisp library implements object prevalence (see
6639 @url{https://en.wikipedia.org/wiki/System_prevalence}).  It allows
6640 for (de)serializing to and from s-exps as well as XML.  Serialization of arbitrary
6641 classes and cyclic data structures are supported.")
6642       (license license:llgpl))))
6643
6644 (define-public cl-prevalence
6645   (sbcl-package->cl-source-package sbcl-cl-prevalence))
6646
6647 (define-public ecl-cl-prevalence
6648   (sbcl-package->ecl-package sbcl-cl-prevalence))
6649
6650 (define-public sbcl-series
6651   (let ((commit "da9061b336119d1e5214aff9117171d494d5a58a")
6652         (revision "1"))
6653     (package
6654       (name "sbcl-series")
6655       (version (git-version "2.2.11" revision commit))
6656       (source
6657        (origin
6658          (method git-fetch)
6659          (uri (git-reference
6660                (url "git://git.code.sf.net/p/series/series")
6661                (commit commit)))
6662          (file-name (git-file-name name version))
6663          (sha256
6664           (base32
6665            "07hk2lhfx42zk018pxqvn4gs77vd4n4g8m4xxbqaxgca76mifwfw"))))
6666       (build-system asdf-build-system/sbcl)
6667       (arguments
6668        ;; Disable the tests, they are apparently buggy and I didn't find
6669        ;; a simple way to make them run and pass.
6670        '(#:tests? #f))
6671       (synopsis "Series data structure for Common Lisp")
6672       (description
6673        "This Common Lisp library provides a series data structure much like
6674 a sequence, with similar kinds of operations.  The difference is that in many
6675 situations, operations on series may be composed functionally and yet execute
6676 iteratively, without the need to construct intermediate series values
6677 explicitly.  In this manner, series provide both the clarity of a functional
6678 programming style and the efficiency of an iterative programming style.")
6679       (home-page "http://series.sourceforge.net/")
6680       (license license:expat))))
6681
6682 (define-public cl-series
6683   (sbcl-package->cl-source-package sbcl-series))
6684
6685 (define-public ecl-series
6686   (sbcl-package->ecl-package sbcl-series))
6687
6688 (define-public sbcl-periods
6689   (let ((commit "983d4a57325db3c8def942f163133cec5391ec28")
6690         (revision "1"))
6691     (package
6692       (name "sbcl-periods")
6693       (version (git-version "0.0.2" revision commit))
6694       (source
6695        (origin
6696          (method git-fetch)
6697          (uri (git-reference
6698                (url "https://github.com/jwiegley/periods.git")
6699                (commit commit)))
6700          (file-name (git-file-name name version))
6701          (sha256
6702           (base32
6703            "0z30jr3lxz3cmi019fsl4lgcgwf0yqpn95v9zkkkwgymdrkd4lga"))))
6704       (build-system asdf-build-system/sbcl)
6705       (inputs
6706        `(("local-time" ,sbcl-local-time)))
6707       (synopsis "Common Lisp library for manipulating date/time objects")
6708       (description
6709        "Periods is a Common Lisp library providing a set of utilities for
6710 manipulating times, distances between times, and both contiguous and
6711 discontiguous ranges of time.")
6712       (home-page "https://github.com/jwiegley/periods")
6713       (license license:bsd-3))))
6714
6715 (define-public cl-periods
6716   (sbcl-package->cl-source-package sbcl-periods))
6717
6718 (define-public ecl-periods
6719   (sbcl-package->ecl-package sbcl-periods))
6720
6721 (define-public sbcl-periods-series
6722   (package
6723     (inherit sbcl-periods)
6724     (name "sbcl-periods-series")
6725     (inputs
6726      `(("periods" ,sbcl-periods)
6727        ("series" ,sbcl-series)))
6728     (arguments
6729      '(#:asd-file "periods-series.asd"
6730        #:asd-system-name "periods-series"))
6731     (description
6732      "Periods-series is an extension of the periods Common Lisp library
6733 providing functions compatible with the series Common Lisp library.")))
6734
6735 (define-public cl-periods-series
6736   (sbcl-package->cl-source-package sbcl-periods-series))
6737
6738 (define-public ecl-periods-series
6739   (sbcl-package->ecl-package sbcl-periods-series))
6740
6741 (define-public sbcl-metatilities-base
6742   (let ((commit "6eaa9e3ff0939a93a92109dd0fcd218de85417d5")
6743         (revision "1"))
6744     (package
6745       (name "sbcl-metatilities-base")
6746       (version (git-version "0.6.6" revision commit))
6747       (source
6748        (origin
6749          (method git-fetch)
6750          (uri (git-reference
6751                (url "https://github.com/gwkkwg/metatilities-base.git")
6752                (commit commit)))
6753          (file-name (git-file-name name version))
6754          (sha256
6755           (base32
6756            "0xpa86pdzlnf4v5g64j3ifaplx71sx2ha8b7vvakswi652679ma0"))))
6757       (build-system asdf-build-system/sbcl)
6758       (native-inputs
6759        `(("lift" ,sbcl-lift)))
6760       (synopsis "Core of the metatilities Common Lisp library")
6761       (description
6762        "Metatilities-base is the core of the metatilities Common Lisp library
6763 which implements a set of utilities.")
6764       (home-page "https://common-lisp.net/project/metatilities-base/")
6765       (license license:expat))))
6766
6767 (define-public cl-metatilities-base
6768   (sbcl-package->cl-source-package sbcl-metatilities-base))
6769
6770 (define-public ecl-metatilities-base
6771   (sbcl-package->ecl-package sbcl-metatilities-base))
6772
6773 (define-public sbcl-cl-containers
6774   (let ((commit "3d1df53c22403121bffb5d553cf7acb1503850e7")
6775         (revision "3"))
6776     (package
6777       (name "sbcl-cl-containers")
6778       (version (git-version "0.12.1" revision commit))
6779       (source
6780        (origin
6781          (method git-fetch)
6782          (uri (git-reference
6783                (url "https://github.com/gwkkwg/cl-containers.git")
6784                (commit commit)))
6785          (file-name (git-file-name name version))
6786          (sha256
6787           (base32
6788            "18s6jfq11n8nv9k4biz32pm1s7y9zl054ry1gmdbcf39nisy377y"))))
6789       (build-system asdf-build-system/sbcl)
6790       (native-inputs
6791        `(("lift" ,sbcl-lift)))
6792       (inputs
6793        `(("metatilities-base" ,sbcl-metatilities-base)))
6794       (arguments
6795        '(#:phases
6796          (modify-phases %standard-phases
6797            (add-after 'unpack 'relax-version-checks
6798              (lambda _
6799                (substitute* "cl-containers.asd"
6800                  (("\\(:version \"metatilities-base\" \"0\\.6\\.6\"\\)")
6801                   "\"metatilities-base\""))
6802                (substitute* "cl-containers-test.asd"
6803                  (("\\(:version \"lift\" \"1\\.7\\.0\"\\)")
6804                   "\"lift\""))
6805                #t)))))
6806       (synopsis "Container library for Common Lisp")
6807       (description
6808        "Common Lisp ships with a set of powerful built in data structures
6809 including the venerable list, full featured arrays, and hash-tables.
6810 CL-containers enhances and builds on these structures by adding containers
6811 that are not available in native Lisp (for example: binary search trees,
6812 red-black trees, sparse arrays and so on), and by providing a standard
6813 interface so that they are simpler to use and so that changing design
6814 decisions becomes significantly easier.")
6815       (home-page "https://common-lisp.net/project/cl-containers/")
6816       (license license:expat))))
6817
6818 (define-public cl-containers
6819   (sbcl-package->cl-source-package sbcl-cl-containers))
6820
6821 (define-public ecl-cl-containers
6822   (sbcl-package->ecl-package sbcl-cl-containers))
6823
6824 (define-public sbcl-xlunit
6825   (let ((commit "3805d34b1d8dc77f7e0ee527a2490194292dd0fc")
6826         (revision "1"))
6827     (package
6828       (name "sbcl-xlunit")
6829       (version (git-version "0.6.3" revision commit))
6830       (source
6831        (origin
6832          (method git-fetch)
6833          (uri (git-reference
6834                (url "http://git.kpe.io/xlunit.git")
6835                (commit commit)))
6836          (file-name (git-file-name name version))
6837          (sha256
6838           (base32
6839            "0argfmp9nghs4sihyj3f8ch9qfib2b7ll07v5m9ziajgzsfl5xw3"))))
6840       (build-system asdf-build-system/sbcl)
6841       (arguments
6842        '(#:phases
6843          (modify-phases %standard-phases
6844            (add-after 'unpack 'fix-tests
6845              (lambda _
6846                (substitute* "xlunit.asd"
6847                  ((" :force t") ""))
6848                #t)))))
6849       (synopsis "Unit testing package for Common Lisp")
6850       (description
6851        "The XLUnit package is a toolkit for building test suites.  It is based
6852 on the XPTest package by Craig Brozensky and the JUnit package by Kent Beck.")
6853       (home-page "http://quickdocs.org/xlunit/")
6854       (license license:bsd-3))))
6855
6856 (define-public cl-xlunit
6857   (sbcl-package->cl-source-package sbcl-xlunit))
6858
6859 (define-public ecl-xlunit
6860   (sbcl-package->ecl-package sbcl-xlunit))
6861
6862 (define-public sbcl-fprog
6863   (let ((commit "7016d1a98215f82605d1c158e7a16504ca1f4636")
6864         (revision "1"))
6865     (package
6866       (name "sbcl-fprog")
6867       (version (git-version "1.0.0" revision commit))
6868       (source
6869        (origin
6870          (method git-fetch)
6871          (uri (git-reference
6872                (url "https://github.com/jwiegley/cambl.git")
6873                (commit commit)))
6874          (file-name (git-file-name name version))
6875          (sha256
6876           (base32
6877            "103mry04j2k9vznsxm7wcvccgxkil92cdrv52miwcmxl8daa4jiz"))))
6878       (build-system asdf-build-system/sbcl)
6879       (synopsis "Functional programming utilities for Common Lisp")
6880       (description
6881        "@code{fprog} is a Common Lisp library allowing iteration over
6882 immutable lists sharing identical sublists.")
6883       (home-page "https://github.com/jwiegley/cambl")
6884       (license license:bsd-3))))
6885
6886 (define-public cl-fprog
6887   (sbcl-package->cl-source-package sbcl-fprog))
6888
6889 (define-public ecl-fprog
6890   (sbcl-package->ecl-package sbcl-fprog))
6891
6892 (define-public sbcl-cambl
6893   (let ((commit "7016d1a98215f82605d1c158e7a16504ca1f4636")
6894         (revision "1"))
6895     (package
6896       (inherit sbcl-fprog)
6897       (name "sbcl-cambl")
6898       (version (git-version "4.0.0" revision commit))
6899       (native-inputs
6900        `(("xlunit" ,sbcl-xlunit)))
6901       (inputs
6902        `(("alexandria" ,sbcl-alexandria)
6903          ("cl-containers" ,sbcl-cl-containers)
6904          ("local-time" ,sbcl-local-time)
6905          ("periods" ,sbcl-periods)
6906          ("fprog" ,sbcl-fprog)))
6907       (synopsis "Commoditized amounts and balances for Common Lisp")
6908       (description
6909        "CAMBL is a Common Lisp library providing a convenient facility for
6910 working with commoditized values.  It does not allow compound units (and so is
6911 not suited for scientific operations) but does work rather nicely for the
6912 purpose of financial calculations."))))
6913
6914 (define-public cl-cambl
6915   (sbcl-package->cl-source-package sbcl-cambl))
6916
6917 (define-public ecl-cambl
6918   (sbcl-package->ecl-package sbcl-cambl))
6919
6920 (define-public sbcl-cl-ledger
6921   (let ((commit "08e0be41795e804cd36142e51756ad0b1caa377b")
6922         (revision "1"))
6923     (package
6924       (name "sbcl-cl-ledger")
6925       (version (git-version "4.0.0" revision commit))
6926       (source
6927        (origin
6928          (method git-fetch)
6929          (uri (git-reference
6930                (url "https://github.com/ledger/cl-ledger.git")
6931                (commit commit)))
6932          (file-name (git-file-name name version))
6933          (sha256
6934           (base32
6935            "1via0qf6wjcyxnfbmfxjvms0ik9j8rqbifgpmnhrzvkhrq9pv8h1"))))
6936       (build-system asdf-build-system/sbcl)
6937       (inputs
6938        `(("cambl" ,sbcl-cambl)
6939          ("cl-ppcre" ,sbcl-cl-ppcre)
6940          ("local-time" ,sbcl-local-time)
6941          ("periods-series" ,sbcl-periods-series)))
6942       (arguments
6943        '(#:phases
6944          (modify-phases %standard-phases
6945            (add-after 'unpack 'fix-system-definition
6946              (lambda _
6947                (substitute* "cl-ledger.asd"
6948                  (("  :build-operation program-op") "")
6949                  (("  :build-pathname \"cl-ledger\"") "")
6950                  (("  :entry-point \"ledger::main\"") ""))
6951                #t)))))
6952       (synopsis "Common Lisp port of the Ledger accounting system")
6953       (description
6954        "CL-Ledger is a Common Lisp port of the Ledger double-entry accounting
6955 system.")
6956       (home-page "https://github.com/ledger/cl-ledger")
6957       (license license:bsd-3))))
6958
6959 (define-public cl-ledger
6960   (sbcl-package->cl-source-package sbcl-cl-ledger))
6961
6962 (define-public ecl-cl-ledger
6963   (sbcl-package->ecl-package sbcl-cl-ledger))
6964
6965 (define-public sbcl-bst
6966   (let ((commit "34f9c7e8e0a9f2c952fe310ab36cb630d5d9c15a")
6967         (revision "1"))
6968     (package
6969       (name "sbcl-bst")
6970       (version (git-version "1.1" revision commit))
6971       (source
6972        (origin
6973          (method git-fetch)
6974          (uri (git-reference
6975                (url "https://github.com/glv2/bst.git")
6976                (commit commit)))
6977          (file-name (git-file-name name version))
6978          (sha256
6979           (base32
6980            "1amxns7hvvh4arwbh8ciwfzplg127vh37dnbamv1m1kmmnmihfc8"))))
6981       (build-system asdf-build-system/sbcl)
6982       (native-inputs
6983        `(("alexandria" ,sbcl-alexandria)
6984          ("fiveam" ,sbcl-fiveam)))
6985       (synopsis "Binary search tree for Common Lisp")
6986       (description
6987        "BST is a Common Lisp library for working with binary search trees that
6988 can contain any kind of values.")
6989       (home-page "https://github.com/glv2/bst")
6990       (license license:gpl3))))
6991
6992 (define-public cl-bst
6993   (sbcl-package->cl-source-package sbcl-bst))
6994
6995 (define-public ecl-bst
6996   (sbcl-package->ecl-package sbcl-bst))
6997
6998 (define-public sbcl-cl-octet-streams
6999   (package
7000     (name "sbcl-cl-octet-streams")
7001     (version "1.0")
7002     (source
7003      (origin
7004        (method git-fetch)
7005        (uri (git-reference
7006              (url "https://github.com/glv2/cl-octet-streams.git")
7007              (commit (string-append "v" version))))
7008        (file-name (git-file-name name version))
7009        (sha256
7010         (base32
7011          "1d7mn6ydv0j2x4r7clpc9ijjwrnfpxmvhifv8n5j7jh7s744sf8d"))))
7012     (build-system asdf-build-system/sbcl)
7013     (native-inputs
7014      `(("fiveam" ,sbcl-fiveam)))
7015     (inputs
7016      `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
7017     (synopsis "In-memory octet streams for Common Lisp")
7018     (description
7019      "CL-octet-streams is a library implementing in-memory octet
7020 streams for Common Lisp.  It was inspired by the trivial-octet-streams and
7021 cl-plumbing libraries.")
7022     (home-page "https://github.com/glv2/cl-octet-streams")
7023     (license license:gpl3+)))
7024
7025 (define-public cl-octet-streams
7026   (sbcl-package->cl-source-package sbcl-cl-octet-streams))
7027
7028 (define-public ecl-cl-octet-streams
7029   (sbcl-package->ecl-package sbcl-cl-octet-streams))
7030
7031 (define-public sbcl-lzlib
7032   (let ((commit "0de1db7129fef9a58a059d35a2fa2ecfc5b47b47")
7033         (revision "1"))
7034     (package
7035       (name "sbcl-lzlib")
7036       (version (git-version "1.0" revision commit))
7037       (source
7038        (origin
7039          (method git-fetch)
7040          (uri (git-reference
7041                (url "https://github.com/glv2/cl-lzlib.git")
7042                (commit commit)))
7043          (file-name (git-file-name name version))
7044          (sha256
7045           (base32
7046            "12ny7vj52fgnd8hb8fc8mry92vq4c1x72x2350191m4476j95clz"))))
7047       (build-system asdf-build-system/sbcl)
7048       (native-inputs
7049        `(("fiveam" ,sbcl-fiveam)))
7050       (inputs
7051        `(("cffi" ,sbcl-cffi)
7052          ("cl-octet-streams" ,sbcl-cl-octet-streams)
7053          ("lzlib" ,lzlib)))
7054       (arguments
7055        '(#:phases
7056          (modify-phases %standard-phases
7057            (add-after 'unpack 'fix-paths
7058              (lambda* (#:key inputs #:allow-other-keys)
7059                (substitute* "src/lzlib.lisp"
7060                  (("liblz\\.so")
7061                   (string-append (assoc-ref inputs "lzlib") "/lib/liblz.so")))
7062                #t)))))
7063       (synopsis "Common Lisp library for lzip (de)compression")
7064       (description
7065        "This Common Lisp library provides functions for lzip (LZMA)
7066 compression/decompression using bindings to the lzlib C library.")
7067       (home-page "https://github.com/glv2/cl-lzlib")
7068       (license license:gpl3+))))
7069
7070 (define-public cl-lzlib
7071   (sbcl-package->cl-source-package sbcl-lzlib))
7072
7073 (define-public ecl-lzlib
7074   (sbcl-package->ecl-package sbcl-lzlib))
7075
7076 (define-public sbcl-chanl
7077   (let ((commit "56e90a126c78b39bb621a01585e8d3b985238e8c")
7078         (revision "1"))
7079     (package
7080       (name "sbcl-chanl")
7081       (version (git-version "0.4.1" revision commit))
7082       (source
7083        (origin
7084          (method git-fetch)
7085          (uri (git-reference
7086                (url "https://github.com/zkat/chanl.git")
7087                (commit commit)))
7088          (file-name (git-file-name name version))
7089          (sha256
7090           (base32
7091            "0b1cf6c12qx5cy1fw2z42jgh566rp3l8nv5qf0qqc569s7bgmrh4"))))
7092       (build-system asdf-build-system/sbcl)
7093       (native-inputs
7094        `(("fiveam" ,sbcl-fiveam)))
7095       (inputs
7096        `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
7097       (synopsis "Portable channel-based concurrency for Common Lisp")
7098       (description "Common Lisp library for channel-based concurrency.  In
7099 a nutshell, you create various threads sequentially executing tasks you need
7100 done, and use channel objects to communicate and synchronize the state of these
7101 threads.")
7102       (home-page "https://github.com/zkat/chanl")
7103       (license (list license:expat license:bsd-3)))))
7104
7105 (define-public cl-chanl
7106   (sbcl-package->cl-source-package sbcl-chanl))
7107
7108 (define-public ecl-chanl
7109   (sbcl-package->ecl-package sbcl-chanl))
7110
7111 (define-public sbcl-cl-store
7112   (let ((commit "c787337a16ea8cf8a06227f35933a4ec774746b3")
7113         (revision "1"))
7114     (package
7115       (name "sbcl-cl-store")
7116       (version (git-version "0.8.11" revision commit))
7117       (source
7118        (origin
7119          (method git-fetch)
7120          (uri (git-reference
7121                (url "https://github.com/skypher/cl-store.git")
7122                (commit commit)))
7123          (file-name (git-file-name name version))
7124          (sha256
7125           (base32
7126            "194srkg8nrym19c6i7zbnkzshc1qhqa82m53qnkirz9fw928bqxr"))))
7127       (build-system asdf-build-system/sbcl)
7128       (native-inputs
7129        `(("rt" ,sbcl-rt)))
7130       (synopsis "Common Lisp library to serialize data")
7131       (description
7132        "CL-STORE is a portable serialization package which should give you the
7133 ability to store all Common Lisp data types into streams.")
7134       (home-page "https://www.common-lisp.net/project/cl-store/")
7135       (license license:expat))))
7136
7137 (define-public cl-store
7138   (sbcl-package->cl-source-package sbcl-cl-store))
7139
7140 (define-public ecl-cl-store
7141   (sbcl-package->ecl-package sbcl-cl-store))
7142
7143 (define-public sbcl-cl-gobject-introspection
7144   (let ((commit "7b703e2384945ea0ac39d9b766de434a08d81560")
7145         (revision "0"))
7146     (package
7147       (name "sbcl-cl-gobject-introspection")
7148       (version (git-version "0.3" revision commit))
7149       (home-page "https://github.com/andy128k/cl-gobject-introspection")
7150       (source
7151        (origin
7152          (method git-fetch)
7153          (uri (git-reference
7154                (url home-page)
7155                (commit commit)))
7156          (file-name (git-file-name name version))
7157          (sha256
7158           (base32
7159            "1zcqd2qj14f6b38vys8gr89s6cijsp9r8j43xa8lynilwva7bwyh"))))
7160       (build-system asdf-build-system/sbcl)
7161       (inputs
7162        `(("alexandria" ,sbcl-alexandria)
7163          ("cffi" ,sbcl-cffi)
7164          ("iterate" ,sbcl-iterate)
7165          ("trivial-garbage" ,sbcl-trivial-garbage)
7166          ("glib" ,glib)
7167          ("gobject-introspection" ,gobject-introspection)))
7168       (native-inputs
7169        `(("fiveam" ,sbcl-fiveam)))
7170       (arguments
7171        ;; TODO: Tests fail, see
7172        ;; https://github.com/andy128k/cl-gobject-introspection/issues/70.
7173        '(#:tests? #f
7174          #:phases
7175          (modify-phases %standard-phases
7176            (add-after (quote unpack) (quote fix-paths)
7177              (lambda* (#:key inputs #:allow-other-keys)
7178                (substitute* "src/init.lisp"
7179                  (("libgobject-2\\.0\\.so")
7180                   (string-append (assoc-ref inputs "glib") "/lib/libgobject-2.0.so"))
7181                  (("libgirepository-1\\.0\\.so")
7182                   (string-append (assoc-ref inputs "gobject-introspection")
7183                                  "/lib/libgirepository-1.0.so")))
7184                #t)))))
7185       (synopsis "Common Lisp bindings to GObject Introspection")
7186       (description
7187        "This library is a bridge between Common Lisp and GObject
7188 Introspection, which enables Common Lisp programs to access the full interface
7189 of C+GObject libraries without the need of writing dedicated bindings.")
7190       (license (list license:bsd-3
7191                      ;; Tests are under a different license.
7192                      license:llgpl)))))
7193
7194 (define-public cl-gobject-introspection
7195   (sbcl-package->cl-source-package sbcl-cl-gobject-introspection))
7196
7197 (define-public sbcl-string-case
7198   (let ((commit "718c761e33749e297cd2809c7ba3ade1985c49f7")
7199         (revision "0"))
7200     (package
7201       (name "sbcl-string-case")
7202       (version (git-version "0.0.2" revision commit))
7203       (home-page "https://github.com/pkhuong/string-case")
7204       (source
7205        (origin
7206          (method git-fetch)
7207          (uri (git-reference
7208                (url home-page)
7209                (commit commit)))
7210          (file-name (git-file-name name version))
7211          (sha256
7212           (base32
7213            "1n5i3yh0h5s636rcnwn7jwqy3rjflikra04lymimhpcshhjsk0md"))))
7214       (build-system asdf-build-system/sbcl)
7215       (synopsis "Efficient string= case in Common Lisp")
7216       (description
7217        "@code{string-case} is a Common Lisp macro that generates specialised decision
7218 trees to dispatch on string equality.")
7219       (license license:bsd-3))))
7220
7221 (define-public cl-string-case
7222   (sbcl-package->cl-source-package sbcl-string-case))
7223
7224 (define-public ecl-string-case
7225   (sbcl-package->ecl-package sbcl-string-case))
7226
7227 (define-public sbcl-global-vars
7228   (let ((commit "c749f32c9b606a1457daa47d59630708ac0c266e")
7229         (revision "0"))
7230     (package
7231       (name "sbcl-global-vars")
7232       (version (git-version "1.0.0" revision commit))
7233       (home-page "https://github.com/lmj/global-vars")
7234       (source
7235        (origin
7236          (method git-fetch)
7237          (uri (git-reference
7238                (url home-page)
7239                (commit commit)))
7240          (file-name (git-file-name name version))
7241          (sha256
7242           (base32
7243            "06m3xc8l3pgsapl8fvsi9wf6y46zs75cp9zn7zh6dc65v4s5wz3d"))))
7244       (build-system asdf-build-system/sbcl)
7245       (synopsis "Efficient global variables in Common Lisp")
7246       (description
7247        "In Common Lisp, a special variable that is never dynamically bound
7248 typically serves as a stand-in for a global variable.  The @code{global-vars}
7249 library provides true global variables that are implemented by some compilers.
7250 An attempt to rebind a global variable properly results in a compiler error.
7251 That is, a global variable cannot be dynamically bound.
7252
7253 Global variables therefore allow us to communicate an intended usage that
7254 differs from special variables.  Global variables are also more efficient than
7255 special variables, especially in the presence of threads.")
7256       (license license:expat))))
7257
7258 (define-public cl-global-vars
7259   (sbcl-package->cl-source-package sbcl-global-vars))
7260
7261 (define-public ecl-global-vars
7262   (sbcl-package->ecl-package sbcl-global-vars))
7263
7264 (define-public sbcl-trivial-file-size
7265   (let ((commit "1c1d672a01a446ba0391dbb4ffc40be3b0476f23")
7266         (revision "0"))
7267     (package
7268       (name "sbcl-trivial-file-size")
7269       (version (git-version "0.0.0" revision commit))
7270       (home-page "https://github.com/ruricolist/trivial-file-size")
7271       (source
7272        (origin
7273          (method git-fetch)
7274          (uri (git-reference
7275                (url home-page)
7276                (commit commit)))
7277          (file-name (git-file-name name version))
7278          (sha256
7279           (base32
7280            "17pp86c9zs4y7i1sh7q9gbfw9iqv6655k7fz8qbj9ly1ypgxp4qs"))))
7281       (build-system asdf-build-system/sbcl)
7282       (native-inputs
7283        `(("fiveam" ,sbcl-fiveam)))
7284       (synopsis "Size of a file in bytes in Common Lisp")
7285       (description
7286        "The canonical way to determine the size of a file in bytes, using Common Lisp,
7287 is to open the file with an element type of (unsigned-byte 8) and then
7288 calculate the length of the stream.  This is less than ideal.  In most cases
7289 it is better to get the size of the file from its metadata, using a system
7290 call.
7291
7292 This library exports a single function, file-size-in-octets.  It returns the
7293 size of a file in bytes, using system calls when possible.")
7294       (license license:expat))))
7295
7296 (define-public cl-trivial-file-size
7297   (sbcl-package->cl-source-package sbcl-trivial-file-size))
7298
7299 (define-public ecl-trivial-file-size
7300   (sbcl-package->ecl-package sbcl-trivial-file-size))
7301
7302 (define-public sbcl-trivial-macroexpand-all
7303   (let ((commit "933270ac7107477de1bc92c1fd641fe646a7a8a9")
7304         (revision "0"))
7305     (package
7306       (name "sbcl-trivial-macroexpand-all")
7307       (version (git-version "0.0.0" revision commit))
7308       (home-page "https://github.com/cbaggers/trivial-macroexpand-all")
7309       (source
7310        (origin
7311          (method git-fetch)
7312          (uri (git-reference
7313                (url home-page)
7314                (commit commit)))
7315          (file-name (git-file-name name version))
7316          (sha256
7317           (base32
7318            "191hnn4b5j4i3crydmlzbm231kj0h7l8zj6mzj69r1npbzkas4bd"))))
7319       (build-system asdf-build-system/sbcl)
7320       (native-inputs
7321        `(("fiveam" ,sbcl-fiveam)))
7322       (synopsis "Portable macroexpand-all for Common Lisp")
7323       (description
7324        "This library provides a macroexpand-all function that calls the
7325 implementation specific equivalent.")
7326       (license license:unlicense))))
7327
7328 (define-public cl-trivial-macroexpand-all
7329   (sbcl-package->cl-source-package sbcl-trivial-macroexpand-all))
7330
7331 (define-public ecl-trivial-macroexpand-all
7332   (sbcl-package->ecl-package sbcl-trivial-macroexpand-all))
7333
7334 (define-public sbcl-serapeum
7335   (let ((commit "64f0c4a161bbbda7c275012ca1415b4293b9e169")
7336         (revision "1"))
7337     (package
7338       (name "sbcl-serapeum")
7339       (version (git-version "0.0.0" revision commit))
7340       (home-page "https://github.com/ruricolist/serapeum")
7341       (source
7342        (origin
7343          (method git-fetch)
7344          (uri (git-reference
7345                (url home-page)
7346                (commit commit)))
7347          (file-name (git-file-name name version))
7348          (sha256
7349           (base32
7350            "0djnj0py8hdjnk5j6shjq2kbmyxqd5sw79cilcfmpfz4dzjdgkx9"))))
7351       (build-system asdf-build-system/sbcl)
7352       (inputs
7353        `(("alexandria" ,sbcl-alexandria)
7354          ("trivia" ,sbcl-trivia)
7355          ("trivia.quasiquote" ,sbcl-trivia.quasiquote)
7356          ("split-sequence" ,sbcl-split-sequence)
7357          ("string-case" ,sbcl-string-case)
7358          ("parse-number" ,sbcl-parse-number)
7359          ("trivial-garbage" ,sbcl-trivial-garbage)
7360          ("bordeaux-threads" ,sbcl-bordeaux-threads)
7361          ("named-readtables" ,sbcl-named-readtables)
7362          ("fare-quasiquote-extras" ,sbcl-fare-quasiquote-extras)
7363          ("parse-declarations-1.0" ,sbcl-parse-declarations)
7364          ("global-vars" ,sbcl-global-vars)
7365          ("trivial-file-size" ,sbcl-trivial-file-size)
7366          ("trivial-macroexpand-all" ,sbcl-trivial-macroexpand-all)))
7367       (native-inputs
7368        `(("fiveam" ,sbcl-fiveam)
7369          ("local-time" ,sbcl-local-time)))
7370       (arguments
7371        '(#:phases
7372          (modify-phases %standard-phases
7373            (add-after 'unpack 'disable-failing-tests
7374              (lambda* (#:key inputs #:allow-other-keys)
7375                (substitute* "serapeum.asd"
7376                  ;; Guix does not have Quicklisp, and probably never will.
7377                  (("\\(:file \"quicklisp\"\\)") ""))
7378                #t)))))
7379       (synopsis "Common Lisp utility library beyond Alexandria")
7380       (description
7381        "Serapeum is a conservative library of Common Lisp utilities.  It is a
7382 supplement, not a competitor, to Alexandria.")
7383       (license license:expat))))
7384
7385 (define-public cl-serapeum
7386   (sbcl-package->cl-source-package sbcl-serapeum))
7387
7388 (define-public sbcl-arrows
7389   (let ((commit "df7cf0067e0132d9697ac8b1a4f1b9c88d4f5382")
7390         (revision "0"))
7391     (package
7392       (name "sbcl-arrows")
7393       (version (git-version "0.2.0" revision commit))
7394       (source
7395        (origin
7396          (method git-fetch)
7397          (uri (git-reference
7398                (url "https://gitlab.com/Harleqin/arrows.git")
7399                (commit commit)))
7400          (file-name (git-file-name name version))
7401          (sha256
7402           (base32
7403            "042k9vkssrqx9nhp14wdzm942zgdxvp35mba0p2syz98i75im2yy"))))
7404       (build-system asdf-build-system/sbcl)
7405       (native-inputs
7406        `(("hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
7407       (synopsis "Clojure-like arrow macros for Common Lisp")
7408       (description
7409        "This library implements the @code{->} and @code{->>} macros from
7410 Clojure, as well as several expansions on the idea.")
7411       (home-page "https://gitlab.com/Harleqin/arrows")
7412       (license license:public-domain))))
7413
7414 (define-public cl-arrows
7415   (sbcl-package->cl-source-package sbcl-arrows))
7416
7417 (define-public ecl-arrows
7418   (sbcl-package->ecl-package sbcl-arrows))
7419
7420 (define-public sbcl-simple-parallel-tasks
7421   (let ((commit "db460f7a3f7bbfe2d3a2223ed21e162068d04dda")
7422         (revision "0"))
7423     (package
7424       (name "sbcl-simple-parallel-tasks")
7425       (version (git-version "1.0" revision commit))
7426       (source
7427        (origin
7428          (method git-fetch)
7429          (uri (git-reference
7430                (url "https://github.com/glv2/simple-parallel-tasks.git")
7431                (commit commit)))
7432          (file-name (git-file-name name version))
7433          (sha256
7434           (base32
7435            "0amw3qk23wnlyrsgzszs6rs7y4zvxv8dr03rnqhc60mnm8ds4dd5"))))
7436       (build-system asdf-build-system/sbcl)
7437       (native-inputs
7438        `(("fiveam" ,sbcl-fiveam)))
7439       (inputs
7440        `(("chanl" ,sbcl-chanl)))
7441       (synopsis "Common Lisp library to evaluate some forms in parallel")
7442       (description "This is a simple Common Lisp library to evaluate some
7443 forms in parallel.")
7444       (home-page "https://github.com/glv2/simple-parallel-tasks")
7445       (license license:gpl3))))
7446
7447 (define-public cl-simple-parallel-tasks
7448   (sbcl-package->cl-source-package sbcl-simple-parallel-tasks))
7449
7450 (define-public ecl-simple-parallel-tasks
7451   (sbcl-package->ecl-package sbcl-simple-parallel-tasks))
7452
7453 (define-public sbcl-cl-heap
7454   (package
7455     (name "sbcl-cl-heap")
7456     (version "0.1.6")
7457     (source
7458      (origin
7459        (method url-fetch)
7460        (uri (string-append "https://common-lisp.net/project/cl-heap/releases/"
7461                            "cl-heap_" version ".tar.gz"))
7462        (sha256
7463         (base32
7464          "163hb07p2nxz126rpq3cj5dyala24n0by5i5786n2qcr1w0bak4i"))))
7465     (build-system asdf-build-system/sbcl)
7466     (native-inputs
7467      `(("xlunit" ,sbcl-xlunit)))
7468     (arguments
7469      `(#:test-asd-file "cl-heap-tests.asd"))
7470     (synopsis "Heap and priority queue data structures for Common Lisp")
7471     (description
7472      "CL-HEAP provides various implementations of heap data structures (a
7473 binary heap and a Fibonacci heap) as well as an efficient priority queue.")
7474     (home-page "https://common-lisp.net/project/cl-heap/")
7475     (license license:gpl3+)))
7476
7477 (define-public cl-heap
7478   (sbcl-package->cl-source-package sbcl-cl-heap))
7479
7480 (define-public ecl-cl-heap
7481   (sbcl-package->ecl-package sbcl-cl-heap))
7482
7483 (define-public sbcl-curry-compose-reader-macros
7484   (let ((commit "beaa92dedf392726c042184bfd6149fa8d9e6ac2")
7485         (revision "0"))
7486     (package
7487       (name "sbcl-curry-compose-reader-macros")
7488       (version (git-version "1.0.0" revision commit))
7489       (source
7490        (origin
7491          (method git-fetch)
7492          (uri
7493           (git-reference
7494            (url "https://github.com/eschulte/curry-compose-reader-macros.git")
7495            (commit commit)))
7496          (file-name (git-file-name name version))
7497          (sha256
7498           (base32
7499            "0rv9bl8xrad5wfcg5zs1dazvnpmvqz6297lbn8bywsrcfnlf7h98"))))
7500       (build-system asdf-build-system/sbcl)
7501       (inputs
7502        `(("alexandria" ,sbcl-alexandria)
7503          ("named-readtables" ,sbcl-named-readtables)))
7504       (synopsis "Reader macros for partial application and composition")
7505       (description
7506        "This Common Lisp library provides reader macros for concise expression
7507 of function partial application and composition.")
7508       (home-page "https://eschulte.github.io/curry-compose-reader-macros/")
7509       (license license:public-domain))))
7510
7511 (define-public cl-curry-compose-reader-macros
7512   (sbcl-package->cl-source-package sbcl-curry-compose-reader-macros))
7513
7514 (define-public ecl-curry-compose-reader-macros
7515   (sbcl-package->ecl-package sbcl-curry-compose-reader-macros))
7516
7517 (define-public sbcl-yason
7518   (package
7519     (name "sbcl-yason")
7520     (version "0.7.7")
7521     (source
7522      (origin
7523        (method git-fetch)
7524        (uri (git-reference
7525              (url "https://github.com/phmarek/yason.git")
7526              (commit (string-append "v" version))))
7527        (file-name (git-file-name name version))
7528        (sha256
7529         (base32
7530          "0479rbjgbj80jpk5bby18inlv1kfp771a82rlcq5psrz65qqa9bj"))))
7531     (build-system asdf-build-system/sbcl)
7532     (inputs
7533      `(("alexandria" ,sbcl-alexandria)
7534        ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
7535     (synopsis "Common Lisp JSON parser/encoder")
7536     (description
7537      "YASON is a Common Lisp library for encoding and decoding data in the
7538 JSON interchange format.")
7539     (home-page "https://github.com/phmarek/yason")
7540     (license license:bsd-3)))
7541
7542 (define-public cl-yason
7543   (sbcl-package->cl-source-package sbcl-yason))
7544
7545 (define-public ecl-yason
7546   (sbcl-package->ecl-package sbcl-yason))
7547
7548 (define-public sbcl-stefil
7549   (let ((commit "0398548ec95dceb50fc2c2c03e5fb0ce49b86c7a")
7550         (revision "0"))
7551     (package
7552       (name "sbcl-stefil")
7553       (version (git-version "0.1" revision commit))
7554       (source
7555        (origin
7556          (method git-fetch)
7557          (uri (git-reference
7558                (url "https://gitlab.common-lisp.net/stefil/stefil.git")
7559                (commit commit)))
7560          (file-name (git-file-name name version))
7561          (sha256
7562           (base32
7563            "0bqz64q2szzhf91zyqyssmvrz7da6442rs01808pf3wrdq28bclh"))))
7564       (build-system asdf-build-system/sbcl)
7565       (inputs
7566        `(("alexandria" ,sbcl-alexandria)
7567          ("iterate" ,sbcl-iterate)
7568          ("metabang-bind" ,sbcl-metabang-bind)))
7569       (propagated-inputs
7570        ;; Swank doesn't have a pre-compiled package, therefore we must
7571        ;; propagate its sources.
7572        `(("swank" ,cl-slime-swank)))
7573       (arguments
7574        '(#:phases
7575          (modify-phases %standard-phases
7576            (add-after 'unpack 'drop-unnecessary-dependency
7577              (lambda _
7578                (substitute* "package.lisp"
7579                  ((":stefil-system") ""))
7580                #t)))))
7581       (home-page "https://common-lisp.net/project/stefil/index-old.shtml")
7582       (synopsis "Simple test framework")
7583       (description
7584        "Stefil is a simple test framework for Common Lisp, with a focus on
7585 interactive development.")
7586       (license license:public-domain))))
7587
7588 (define-public cl-stefil
7589   (sbcl-package->cl-source-package sbcl-stefil))
7590
7591 (define-public sbcl-graph
7592   (let ((commit "78bf9ec930d8eae4f0861b5be76765fb1e45e24f")
7593         (revision "0"))
7594     (package
7595       (name "sbcl-graph")
7596       (version (git-version "0.0.0" revision commit))
7597       (source
7598        (origin
7599          (method git-fetch)
7600          (uri
7601           (git-reference
7602            (url "https://github.com/eschulte/graph.git")
7603            (commit commit)))
7604          (file-name (git-file-name name version))
7605          (sha256
7606           (base32
7607            "1qpij4xh8bqwc2myahpilcbh916v7vg0acz2fij14d3y0jm02h0g"))
7608          (patches (search-patches "sbcl-graph-asdf-definitions.patch"))))
7609       (build-system asdf-build-system/sbcl)
7610       (native-inputs
7611        `(("stefil" ,sbcl-stefil)))
7612       (inputs
7613        `(("alexandria" ,sbcl-alexandria)
7614          ("cl-heap" ,sbcl-cl-heap)
7615          ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
7616          ("metabang-bind" ,sbcl-metabang-bind)
7617          ("named-readtables" ,sbcl-named-readtables)))
7618       (arguments
7619        '(#:test-asd-file "graph-test.asd"))
7620       (synopsis "Graph data structure and algorithms for Common Lisp")
7621       (description
7622        "The GRAPH Common Lisp library provides a data structures to represent
7623 graphs, as well as some graph manipulation and analysis algorithms (shortest
7624 path, maximum flow, minimum spanning tree, etc.).")
7625       (home-page "https://eschulte.github.io/graph/")
7626       (license license:gpl3+))))
7627
7628 (define-public cl-graph
7629   (sbcl-package->cl-source-package sbcl-graph))
7630
7631 (define-public sbcl-graph-dot
7632   (package
7633     (inherit sbcl-graph)
7634     (name "sbcl-graph-dot")
7635     (inputs
7636      `(("alexandria" ,sbcl-alexandria)
7637        ("cl-ppcre" ,sbcl-cl-ppcre)
7638        ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
7639        ("graph" ,sbcl-graph)
7640        ("metabang-bind" ,sbcl-metabang-bind)
7641        ("named-readtables" ,sbcl-named-readtables)))
7642     (arguments
7643      (substitute-keyword-arguments (package-arguments sbcl-graph)
7644        ((#:asd-file _ "") "graph-dot.asd")
7645        ((#:asd-system-name _ #f) "graph-dot")))
7646     (synopsis "Serialize graphs to and from DOT format")))
7647
7648 (define-public sbcl-graph-json
7649   (package
7650     (inherit sbcl-graph)
7651     (name "sbcl-graph-json")
7652     (inputs
7653      `(("alexandria" ,sbcl-alexandria)
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        ("yason" ,sbcl-yason)))
7659     (arguments
7660      (substitute-keyword-arguments (package-arguments sbcl-graph)
7661        ((#:asd-file _ "") "graph-json.asd")
7662        ((#:asd-system-name _ #f) "graph-json")))
7663     (synopsis "Serialize graphs to and from JSON format")))
7664
7665 (define-public sbcl-trivial-indent
7666   (let ((commit "2d016941751647c6cc5bd471751c2cf68861c94a")
7667         (revision "0"))
7668     (package
7669       (name "sbcl-trivial-indent")
7670       (version (git-version "1.0.0" revision commit))
7671       (source
7672        (origin
7673          (method git-fetch)
7674          (uri
7675           (git-reference
7676            (url "https://github.com/Shinmera/trivial-indent")
7677            (commit commit)))
7678          (file-name (git-file-name name version))
7679          (sha256
7680           (base32
7681            "1sj90nqz17w4jq0ixz00gb9g5g6d2s7l8r17zdby27gxxh51w266"))))
7682       (build-system asdf-build-system/sbcl)
7683       (synopsis "Simple Common Lisp library to allow indentation hints for SWANK")
7684       (description
7685        "This library allows you to define custom indentation hints for your
7686 macros if the one recognised by SLIME automatically produces unwanted
7687 results.")
7688       (home-page "https://shinmera.github.io/trivial-indent/")
7689       (license license:zlib))))
7690
7691 (define-public cl-trivial-indent
7692   (sbcl-package->cl-source-package sbcl-trivial-indent))
7693
7694 (define-public sbcl-documentation-utils
7695   (let ((commit "98630dd5f7e36ae057fa09da3523f42ccb5d1f55")
7696         (revision "0"))
7697     (package
7698       (name "sbcl-documentation-utils")
7699       (version (git-version "1.2.0" revision commit))
7700       (source
7701        (origin
7702          (method git-fetch)
7703          (uri
7704           (git-reference
7705            (url "https://github.com/Shinmera/documentation-utils.git")
7706            (commit commit)))
7707          (file-name (git-file-name name version))
7708          (sha256
7709           (base32
7710            "098qhkqskmmrh4wix34mawf7p5c87yql28r51r75yjxj577k5idq"))))
7711       (build-system asdf-build-system/sbcl)
7712       (inputs
7713        `(("trivial-indent" ,sbcl-trivial-indent)))
7714       (synopsis "Few simple tools to document Common Lisp libraries")
7715       (description
7716        "This is a small library to help you with managing the Common Lisp
7717 docstrings for your library.")
7718       (home-page "https://shinmera.github.io/documentation-utils/")
7719       (license license:zlib))))
7720
7721 (define-public cl-documentation-utils
7722   (sbcl-package->cl-source-package sbcl-documentation-utils))
7723
7724 (define-public ecl-documentation-utils
7725   (sbcl-package->ecl-package sbcl-documentation-utils))
7726
7727 (define-public sbcl-form-fiddle
7728   (let ((commit "e0c23599dbb8cff3e83e012f3d86d0764188ad18")
7729         (revision "0"))
7730     (package
7731       (name "sbcl-form-fiddle")
7732       (version (git-version "1.1.0" revision commit))
7733       (source
7734        (origin
7735          (method git-fetch)
7736          (uri
7737           (git-reference
7738            (url "https://github.com/Shinmera/form-fiddle")
7739            (commit commit)))
7740          (file-name (git-file-name name version))
7741          (sha256
7742           (base32
7743            "041iznc9mpfyrl0sv5893ys9pbb2pvbn9g3clarqi7gsfj483jln"))))
7744       (build-system asdf-build-system/sbcl)
7745       (inputs
7746        `(("documentation-utils" ,sbcl-documentation-utils)))
7747       (synopsis "Utilities to destructure Common Lisp lambda forms")
7748       (description
7749        "Often times we need to destructure a form definition in a Common Lisp
7750 macro.  This library provides a set of simple utilities to help with that.")
7751       (home-page "https://shinmera.github.io/form-fiddle/")
7752       (license license:zlib))))
7753
7754 (define-public cl-form-fiddle
7755   (sbcl-package->cl-source-package sbcl-form-fiddle))
7756
7757 (define-public sbcl-parachute
7758   (let ((commit "ca04dd8e43010a6dfffa26dbe1d62af86008d666")
7759         (revision "0"))
7760     (package
7761       (name "sbcl-parachute")
7762       (version (git-version "1.1.1" revision commit))
7763       (source
7764        (origin
7765          (method git-fetch)
7766          (uri
7767           (git-reference
7768            (url "https://github.com/Shinmera/parachute")
7769            (commit commit)))
7770          (file-name (git-file-name name version))
7771          (sha256
7772           (base32
7773            "1mvsm3r0r6a2bg75nw0q7n9vlby3ch45qjl7hnb5k1z2n5x5lh60"))))
7774       (build-system asdf-build-system/sbcl)
7775       (inputs
7776        `(("documentation-utils" ,sbcl-documentation-utils)
7777          ("form-fiddle" ,sbcl-form-fiddle)))
7778       (synopsis "Extensible and cross-compatible testing framework for Common Lisp")
7779       (description
7780        "Parachute is a simple-to-use and extensible testing framework.
7781 In Parachute, things are organised as a bunch of named tests within a package.
7782 Each test can contain a bunch of test forms that make up its body.")
7783       (home-page "https://shinmera.github.io/parachute/")
7784       (license license:zlib))))
7785
7786 (define-public cl-parachute
7787   (sbcl-package->cl-source-package sbcl-parachute))
7788
7789 (define-public sbcl-array-utils
7790   (let ((commit "f90eb9070d0b2205af51126a35033574725e5c56")
7791         (revision "0"))
7792     (package
7793       (name "sbcl-array-utils")
7794       (version (git-version "1.1.1" revision commit))
7795       (source
7796        (origin
7797          (method git-fetch)
7798          (uri
7799           (git-reference
7800            (url "https://github.com/Shinmera/array-utils")
7801            (commit commit)))
7802          (file-name (git-file-name name version))
7803          (sha256
7804           (base32
7805            "0zhwfbpr53vs1ii4sx75dz2k9yhh1xpwdqqpg8nmfndxkmhpbi3x"))))
7806       (build-system asdf-build-system/sbcl)
7807       (native-inputs
7808        `(("parachute" ,sbcl-parachute)))
7809       (inputs
7810        `(("documentation-utils" ,sbcl-documentation-utils)))
7811       (synopsis "Tiny collection of array and vector utilities for Common Lisp")
7812       (description
7813        "A miniature toolkit that contains some useful shifting/popping/pushing
7814 functions for arrays and vectors.  Originally from Plump.")
7815       (home-page "https://shinmera.github.io/array-utils/")
7816       (license license:zlib))))
7817
7818 (define-public cl-array-utils
7819   (sbcl-package->cl-source-package sbcl-array-utils))
7820
7821 (define-public sbcl-plump
7822   (let ((commit "34f890fe46efdebe7bb70d218f1937e98f632bf9")
7823         (revision "1"))
7824     (package
7825       (name "sbcl-plump")
7826       (version (git-version "2.0.0" revision commit))
7827       (source
7828        (origin
7829          (method git-fetch)
7830          (uri
7831           (git-reference
7832            (url "https://github.com/Shinmera/plump")
7833            (commit commit)))
7834          (file-name (git-file-name name version))
7835          (sha256
7836           (base32
7837            "0a0x8wn6vv1ylxcwck12k18gy0a366kdm6ddxxk7yynl4mwnqgkh"))))
7838       (build-system asdf-build-system/sbcl)
7839       (inputs
7840        `(("array-utils" ,sbcl-array-utils)
7841          ("documentation-utils" ,sbcl-documentation-utils)))
7842       (synopsis "Lenient XML / XHTML / HTML parser for Common Lisp")
7843       (description
7844        "Plump is a parser for HTML/XML-like documents, focusing on being
7845 lenient towards invalid markup.  It can handle things like invalid attributes,
7846 bad closing tag order, unencoded entities, inexistent tag types, self-closing
7847 tags and so on.  It parses documents to a class representation and offers a
7848 small set of DOM functions to manipulate it.  It can be extended to parse to
7849 your own classes.")
7850       (home-page "https://shinmera.github.io/plump/")
7851       (license license:zlib))))
7852
7853 (define-public cl-plump
7854   (sbcl-package->cl-source-package sbcl-plump))
7855
7856 (define-public sbcl-antik-base
7857   (let ((commit "e4711a69b3d6bf37b5727af05c3cfd03e8428ba3")
7858         (revision "1"))
7859     (package
7860       (name "sbcl-antik-base")
7861       (version (git-version "0.0.0" revision commit))
7862       (source
7863        (origin
7864          (method git-fetch)
7865          (uri (git-reference
7866                (url "https://gitlab.common-lisp.net/antik/antik.git")
7867                (commit commit)))
7868          (file-name (git-file-name name version))
7869          (sha256
7870           (base32
7871            "047ga2c38par2xbgg4qx6hwv06qhf1c1f67as8xvir6s80lip1km"))))
7872       (build-system asdf-build-system/sbcl)
7873       (inputs
7874        `(("alexandria" ,sbcl-alexandria)
7875          ("cl-ppcre" ,sbcl-cl-ppcre)
7876          ("iterate" ,sbcl-iterate)
7877          ("metabang-bind" ,sbcl-metabang-bind)
7878          ("named-readtables" ,sbcl-named-readtables)
7879          ("split-sequence" ,sbcl-split-sequence)))
7880       (native-inputs
7881        `(("lisp-unit" ,sbcl-lisp-unit)))
7882       (synopsis "Scientific and engineering computation in Common Lisp")
7883       (description
7884        "Antik provides a foundation for scientific and engineering
7885 computation in Common Lisp.  It is designed not only to facilitate
7886 numerical computations, but to permit the use of numerical computation
7887 libraries and the interchange of data and procedures, whether
7888 foreign (non-Lisp) or Lisp libraries.  It is named after the
7889 Antikythera mechanism, one of the oldest examples of a scientific
7890 computer known.")
7891       (home-page "https://common-lisp.net/project/antik/")
7892       (license license:gpl3))))
7893
7894 (define-public cl-antik-base
7895   (sbcl-package->cl-source-package sbcl-antik-base))
7896
7897 (define-public ecl-antik-base
7898   (sbcl-package->ecl-package sbcl-antik-base))
7899
7900 (define-public sbcl-foreign-array
7901   (package
7902     (inherit sbcl-antik-base)
7903     (name "sbcl-foreign-array")
7904     (arguments
7905      (substitute-keyword-arguments (package-arguments sbcl-antik-base)
7906        ((#:asd-file _ "") "foreign-array.asd")
7907        ((#:asd-system-name _ #f) "foreign-array")))
7908     (inputs
7909      `(("antik-base" ,sbcl-antik-base)
7910        ("cffi" ,sbcl-cffi)
7911        ("trivial-garbage" ,sbcl-trivial-garbage)
7912        ("static-vectors" ,sbcl-static-vectors)))
7913     (synopsis "Common Lisp library providing access to foreign arrays")))
7914
7915 (define-public cl-foreign-array
7916   (sbcl-package->cl-source-package sbcl-foreign-array))
7917
7918 (define-public ecl-foreign-array
7919   (sbcl-package->ecl-package sbcl-foreign-array))
7920
7921 (define-public sbcl-physical-dimension
7922   (package
7923     (inherit sbcl-antik-base)
7924     (name "sbcl-physical-dimension")
7925     (inputs
7926      `(("fare-utils" ,sbcl-fare-utils)
7927        ("foreign-array" ,sbcl-foreign-array)
7928        ("trivial-utf-8" ,sbcl-trivial-utf-8)))
7929     (arguments
7930      (substitute-keyword-arguments (package-arguments sbcl-antik-base)
7931        ((#:asd-file _ "") "physical-dimension.asd")
7932        ((#:asd-system-name _ #f) "physical-dimension")))
7933     (synopsis
7934      "Common Lisp library providing computations with physical units")))
7935
7936 (define-public cl-physical-dimension
7937   (sbcl-package->cl-source-package sbcl-physical-dimension))
7938
7939 (define-public sbcl-science-data
7940   (package
7941     (inherit sbcl-antik-base)
7942     (name "sbcl-science-data")
7943     (inputs
7944      `(("physical-dimension" ,sbcl-physical-dimension)
7945        ("drakma" ,sbcl-drakma)))
7946     (arguments
7947      (substitute-keyword-arguments (package-arguments sbcl-antik-base)
7948        ((#:asd-file _ "") "science-data.asd")
7949        ((#:asd-system-name _ #f) "science-data")))
7950     (synopsis
7951      "Common Lisp library for scientific and engineering numerical data")))
7952
7953 (define-public cl-science-data
7954   (sbcl-package->cl-source-package sbcl-science-data))
7955
7956 (define-public sbcl-gsll
7957   (let ((commit "1a8ada22f9cf5ed7372d352b2317f4ccdb6ab308")
7958         (revision "1"))
7959     (package
7960       (name "sbcl-gsll")
7961       (version (git-version "0.0.0" revision commit))
7962       (source
7963        (origin
7964          (method git-fetch)
7965          (uri (git-reference
7966                (url "https://gitlab.common-lisp.net/antik/gsll.git")
7967                (commit commit)))
7968          (file-name (git-file-name name version))
7969          (sha256
7970           (base32
7971            "0z5nypfk26hxihb08p085644afawicrgb4xvadh3lmrn46qbjfn4"))))
7972       (build-system asdf-build-system/sbcl)
7973       (native-inputs
7974        `(("lisp-unit" ,sbcl-lisp-unit)))
7975       (inputs
7976        `(("alexandria" ,sbcl-alexandria)
7977          ("cffi-grovel" ,sbcl-cffi-grovel)
7978          ("cffi-libffi" ,sbcl-cffi-libffi)
7979          ("foreign-array" ,sbcl-foreign-array)
7980          ("gsl" ,gsl)
7981          ("metabang-bind" ,sbcl-metabang-bind)
7982          ("trivial-features" ,sbcl-trivial-features)
7983          ("trivial-garbage" ,sbcl-trivial-garbage)))
7984       (arguments
7985        `(#:tests? #f
7986          #:phases
7987          (modify-phases %standard-phases
7988            (add-after 'unpack 'fix-cffi-paths
7989              (lambda* (#:key inputs #:allow-other-keys)
7990                (substitute* "gsll.asd"
7991                  ((":depends-on \\(#:foreign-array")
7992                   ":depends-on (#:foreign-array #:cffi-libffi"))
7993                (substitute* "init/init.lisp"
7994                  (("libgslcblas.so" all)
7995                   (string-append
7996                    (assoc-ref inputs "gsl") "/lib/" all)))
7997                (substitute* "init/init.lisp"
7998                  (("libgsl.so" all)
7999                   (string-append
8000                    (assoc-ref inputs "gsl") "/lib/" all))))))))
8001       (synopsis "GNU Scientific Library for Lisp")
8002       (description
8003        "The GNU Scientific Library for Lisp (GSLL) allows the use of the
8004 GNU Scientific Library (GSL) from Common Lisp.  This library provides a
8005 full range of common mathematical operations useful to scientific and
8006 engineering applications.  The design of the GSLL interface is such
8007 that access to most of the GSL library is possible in a Lisp-natural
8008 way; the intent is that the user not be hampered by the restrictions
8009 of the C language in which GSL has been written.  GSLL thus provides
8010 interactive use of GSL for getting quick answers, even for someone not
8011 intending to program in Lisp.")
8012       (home-page "https://common-lisp.net/project/gsll/")
8013       (license license:gpl3))))
8014
8015 (define-public cl-gsll
8016   (sbcl-package->cl-source-package sbcl-gsll))
8017
8018 (define-public sbcl-antik
8019   (package
8020     (inherit sbcl-antik-base)
8021     (name "sbcl-antik")
8022     (inputs
8023      `(("gsll" ,sbcl-gsll)
8024        ("physical-dimension" ,sbcl-physical-dimension)))
8025     (arguments
8026      (substitute-keyword-arguments (package-arguments sbcl-antik-base)
8027        ((#:asd-file _ "") "antik.asd")
8028        ((#:asd-system-name _ #f) "antik")))))
8029
8030 (define-public cl-antik
8031   (sbcl-package->cl-source-package sbcl-antik))
8032
8033 (define-public sbcl-cl-interpol
8034   (let ((commit "1fd288d861db85bc4677cff3cdd6af75fda1afb4")
8035         (revision "1"))
8036     (package
8037       (name "sbcl-cl-interpol")
8038       (version (git-version "0.2.6" revision commit))
8039       (source
8040        (origin
8041          (method git-fetch)
8042          (uri (git-reference
8043                (url "https://github.com/edicl/cl-interpol.git")
8044                (commit commit)))
8045          (file-name (git-file-name name version))
8046          (sha256
8047           (base32
8048            "1hnikak52hmcq1r5f616m6qq1108qnkw80pja950nv1fq5p0ppjn"))))
8049       (build-system asdf-build-system/sbcl)
8050       (inputs
8051        `(("cl-unicode" ,sbcl-cl-unicode)
8052          ("named-readtables" ,sbcl-named-readtables)))
8053       (native-inputs
8054        `(("flexi-streams" ,sbcl-flexi-streams)))
8055       (synopsis "String interpolation for Common Lisp")
8056       (description
8057        "CL-INTERPOL is a library for Common Lisp which modifies the
8058 reader so that you can have interpolation within strings similar to
8059 Perl or Unix Shell scripts.  It also provides various ways to insert
8060 arbitrary characters into literal strings even if your editor/IDE
8061 doesn't support them.")
8062       (home-page "https://edicl.github.io/cl-interpol/")
8063       (license license:bsd-3))))
8064
8065 (define-public cl-interpol
8066   (sbcl-package->cl-source-package sbcl-cl-interpol))
8067
8068 (define-public ecl-cl-interpol
8069   (sbcl-package->ecl-package sbcl-cl-interpol))
8070
8071 (define sbcl-symbol-munger-boot0
8072   ;; There is a cyclical dependency between symbol-munger and lisp-unit2.
8073   ;; See https://github.com/AccelerationNet/symbol-munger/issues/4
8074   (let ((commit "cc2bb4b7acd454d756484aec81ba487648385fc3")
8075         (revision "1"))
8076     (package
8077       (name "sbcl-symbol-munger-boot0")
8078       (version (git-version "0.0.1" revision commit))
8079       (source
8080        (origin
8081          (method git-fetch)
8082          (uri (git-reference
8083                (url "https://github.com/AccelerationNet/symbol-munger.git")
8084                (commit commit)))
8085          (file-name (git-file-name name version))
8086          (sha256
8087           (base32
8088            "0diav5ricqsybqvbp4bkxyj3bn3v9n7xb2pqqc4vg1algsw2pyjl"))))
8089       (build-system asdf-build-system/sbcl)
8090       (arguments
8091        `(#:asd-file "symbol-munger.asd"
8092          #:asd-system-name "symbol-munger"))
8093       (inputs
8094        `(("iterate" ,sbcl-iterate)
8095          ("alexandria" ,sbcl-alexandria)))
8096       (native-inputs
8097        `(("lisp-unit" ,sbcl-lisp-unit)))
8098       (synopsis
8099        "Capitalization and spacing conversion functions for Common Lisp")
8100       (description
8101        "This is a Common Lisp library to change the capitalization and spacing
8102 of a string or a symbol.  It can convert to and from Lisp, english, underscore
8103 and camel-case rules.")
8104       (home-page "https://github.com/AccelerationNet/symbol-munger")
8105       ;; The package declares a BSD license, but all of the license
8106       ;; text is MIT.
8107       ;; See https://github.com/AccelerationNet/symbol-munger/issues/5
8108       (license license:expat))))
8109
8110 (define sbcl-lisp-unit2-boot0
8111   ;; There is a cyclical dependency between symbol-munger and lisp-unit2.
8112   ;; See https://github.com/AccelerationNet/symbol-munger/issues/4
8113   (let ((commit "fb9721524d1e4e73abb223ee036d74ce14a5505c")
8114         (revision "1"))
8115     (package
8116       (name "sbcl-lisp-unit2-boot0")
8117       (version (git-version "0.2.0" revision commit))
8118       (source
8119        (origin
8120          (method git-fetch)
8121          (uri (git-reference
8122                (url "https://github.com/AccelerationNet/lisp-unit2.git")
8123                (commit commit)))
8124          (file-name (git-file-name name version))
8125          (sha256
8126           (base32
8127            "1rsqy8y0jqll6xn9a593848f5wvd5ribv4csry1ly0hmdhfnqzlp"))))
8128       (build-system asdf-build-system/sbcl)
8129       (arguments
8130        `(#:asd-file "lisp-unit2.asd"
8131          #:asd-system-name "lisp-unit2"))
8132       (inputs
8133        `(("alexandria" ,sbcl-alexandria)
8134          ("cl-interpol" ,sbcl-cl-interpol)
8135          ("iterate" ,sbcl-iterate)
8136          ("symbol-munger-boot0" ,sbcl-symbol-munger-boot0)))
8137       (synopsis "Test Framework for Common Lisp")
8138       (description
8139        "LISP-UNIT2 is a Common Lisp library that supports unit testing in the
8140 style of JUnit for Java.  It is a new version of the lisp-unit library written
8141 by Chris Riesbeck.")
8142       (home-page "https://github.com/AccelerationNet/lisp-unit2")
8143       (license license:expat))))
8144
8145 (define-public sbcl-symbol-munger
8146   (let ((commit "97598d4c3c53fd5da72ab78908fbd5d8c7a13416")
8147         (revision "1"))
8148     (package
8149       (name "sbcl-symbol-munger")
8150       (version (git-version "0.0.1" revision commit))
8151       (source
8152        (origin
8153          (method git-fetch)
8154          (uri (git-reference
8155                (url "https://github.com/AccelerationNet/symbol-munger.git")
8156                (commit commit)))
8157          (file-name (git-file-name name version))
8158          (sha256
8159           (base32
8160            "0y8jywjy0ldyhp7bxf16fdvdd2qgqnd7nlhlqfpfnzxcqk4xy1km"))))
8161       (build-system asdf-build-system/sbcl)
8162       (inputs
8163        `(("alexandria" ,sbcl-alexandria)
8164          ("iterate" ,sbcl-iterate)))
8165       (native-inputs
8166        `(("lisp-unit2-boot0" ,sbcl-lisp-unit2-boot0)))
8167       (synopsis
8168        "Capitalization and spacing conversion functions for Common Lisp")
8169       (description
8170        "This is a Common Lisp library to change the capitalization and spacing
8171 of a string or a symbol.  It can convert to and from Lisp, english, underscore
8172 and camel-case rules.")
8173       (home-page "https://github.com/AccelerationNet/symbol-munger")
8174       ;; The package declares a BSD license, but all of the license
8175       ;; text is MIT.
8176       ;; See https://github.com/AccelerationNet/symbol-munger/issues/5
8177       (license license:expat))))
8178
8179 (define-public cl-symbol-munger
8180   (sbcl-package->cl-source-package sbcl-symbol-munger))
8181
8182 (define-public ecl-symbol-munger
8183   (sbcl-package->ecl-package sbcl-symbol-munger))
8184
8185 (define-public sbcl-lisp-unit2
8186   (package
8187     (inherit sbcl-lisp-unit2-boot0)
8188     (name "sbcl-lisp-unit2")
8189     (inputs
8190      `(("alexandria" ,sbcl-alexandria)
8191        ("cl-interpol" ,sbcl-cl-interpol)
8192        ("iterate" ,sbcl-iterate)
8193        ("symbol-munger" ,sbcl-symbol-munger)))))
8194
8195 (define-public cl-lisp-unit2
8196   (sbcl-package->cl-source-package sbcl-lisp-unit2))
8197
8198 (define-public ecl-lisp-unit2
8199   (sbcl-package->ecl-package sbcl-lisp-unit2))
8200
8201 (define-public sbcl-cl-csv
8202   (let ((commit "3eba29c8364b033fbe0d189c2500559278b6a362")
8203         (revision "1"))
8204     (package
8205       (name "sbcl-cl-csv")
8206       (version (git-version "1.0.6" revision commit))
8207       (source
8208        (origin
8209          (method git-fetch)
8210          (uri (git-reference
8211                (url "https://github.com/AccelerationNet/cl-csv.git")
8212                (commit commit)))
8213          (file-name (git-file-name name version))
8214          (sha256
8215           (base32
8216            "07h4ni89jzx93clx453hlnnb5g53hhlcmz5hghqv6ysam48lc8g6"))))
8217       (build-system asdf-build-system/sbcl)
8218       (arguments
8219        ;; See: https://github.com/AccelerationNet/cl-csv/pull/34
8220        `(#:tests? #f))
8221       (inputs
8222        `(("alexandria" ,sbcl-alexandria)
8223          ("cl-interpol" ,sbcl-cl-interpol)
8224          ("iterate" ,sbcl-iterate)))
8225       (native-inputs
8226        `(("lisp-unit2" ,sbcl-lisp-unit2)))
8227       (synopsis "Common lisp library for comma-separated values")
8228       (description
8229        "This is a Common Lisp library providing functions to read/write CSV
8230 from/to strings, streams and files.")
8231       (home-page "https://github.com/AccelerationNet/cl-csv")
8232       (license license:bsd-3))))
8233
8234 (define-public cl-csv
8235   (sbcl-package->cl-source-package sbcl-cl-csv))
8236
8237 (define-public ecl-cl-csv
8238   (sbcl-package->ecl-package sbcl-cl-csv))
8239
8240 (define-public sbcl-external-program
8241   (let ((commit "5888b8f1fd3953feeeacecbba4384ddda584a749")
8242         (revision "1"))
8243     (package
8244       (name "sbcl-external-program")
8245       (version (git-version "0.0.6" revision commit))
8246       (source
8247        (origin
8248          (method git-fetch)
8249          (uri (git-reference
8250                (url "https://github.com/sellout/external-program.git")
8251                (commit commit)))
8252          (file-name (git-file-name name version))
8253          (sha256
8254           (base32
8255            "0vww1x3yilb3bjwg6k184vaj4vxyxw4vralhnlm6lk4xac67kc9z"))))
8256       (build-system asdf-build-system/sbcl)
8257       (inputs
8258        `(("trivial-features" ,sbcl-trivial-features)))
8259       (native-inputs
8260        `(("fiveam" ,sbcl-fiveam)))
8261       (synopsis "Common Lisp library for running external programs")
8262       (description
8263        "EXTERNAL-PROGRAM enables running programs outside the Lisp
8264 process.  It is an attempt to make the RUN-PROGRAM functionality in
8265 implementations like SBCL and CCL as portable as possible without
8266 sacrificing much in the way of power.")
8267       (home-page "https://github.com/sellout/external-program")
8268       (license license:llgpl))))
8269
8270 (define-public cl-external-program
8271   (sbcl-package->cl-source-package sbcl-external-program))
8272
8273 (define-public ecl-external-program
8274   (sbcl-package->ecl-package sbcl-external-program))
8275
8276 (define sbcl-cl-ana-boot0
8277   (let ((commit "fa7cee4c50aa1c859652813049ba0da7c18a0df9")
8278         (revision "1"))
8279     (package
8280      (name "sbcl-cl-ana-boot0")
8281      (version (git-version "0.0.0" revision commit))
8282      (source
8283       (origin
8284        (method git-fetch)
8285        (uri (git-reference
8286              (url "https://github.com/ghollisjr/cl-ana.git")
8287              (commit commit)))
8288        (file-name (git-file-name name version))
8289        (sha256
8290         (base32
8291          "0mr47l57m276dbpap7irr4fcnk5fgknhf6mgv4043s8h73amk5qh"))))
8292      (build-system asdf-build-system/sbcl)
8293      (synopsis "Common Lisp data analysis library")
8294      (description
8295       "CL-ANA is a data analysis library in Common Lisp providing tabular and
8296 binned data analysis along with nonlinear least squares fitting and
8297 visualization.")
8298      (home-page "https://github.com/ghollisjr/cl-ana")
8299      (license license:gpl3))))
8300
8301 (define-public sbcl-cl-ana.pathname-utils
8302   (package
8303     (inherit sbcl-cl-ana-boot0)
8304     (name "sbcl-cl-ana.pathname-utils")
8305     (arguments
8306      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8307        ((#:asd-file _ "") "pathname-utils/cl-ana.pathname-utils.asd")
8308        ((#:asd-system-name _ #f) "cl-ana.pathname-utils")))))
8309
8310 (define-public cl-ana.pathname-utils
8311   (sbcl-package->cl-source-package sbcl-cl-ana.pathname-utils))
8312
8313 (define-public ecl-cl-ana.pathname-utils
8314   (sbcl-package->ecl-package sbcl-cl-ana.pathname-utils))
8315
8316 (define-public sbcl-cl-ana.package-utils
8317   (package
8318     (inherit sbcl-cl-ana-boot0)
8319     (name "sbcl-cl-ana.package-utils")
8320     (inputs
8321      `(("alexandria" ,sbcl-alexandria)))
8322     (arguments
8323      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8324        ((#:asd-file _ "") "package-utils/cl-ana.package-utils.asd")
8325        ((#:asd-system-name _ #f) "cl-ana.package-utils")))))
8326
8327 (define-public cl-ana.package-utils
8328   (sbcl-package->cl-source-package sbcl-cl-ana.package-utils))
8329
8330 (define-public ecl-cl-ana.package-utils
8331   (sbcl-package->ecl-package sbcl-cl-ana.package-utils))
8332
8333 (define-public sbcl-cl-ana.string-utils
8334   (package
8335     (inherit sbcl-cl-ana-boot0)
8336     (name "sbcl-cl-ana.string-utils")
8337     (inputs
8338      `(("split-sequence" ,sbcl-split-sequence)))
8339     (arguments
8340      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8341        ((#:asd-file _ "") "string-utils/cl-ana.string-utils.asd")
8342        ((#:asd-system-name _ #f) "cl-ana.string-utils")))))
8343
8344 (define-public cl-ana.string-utils
8345   (sbcl-package->cl-source-package sbcl-cl-ana.string-utils))
8346
8347 (define-public ecl-cl-ana.string-utils
8348   (sbcl-package->ecl-package sbcl-cl-ana.string-utils))
8349
8350 (define-public sbcl-cl-ana.functional-utils
8351   (package
8352     (inherit sbcl-cl-ana-boot0)
8353     (name "sbcl-cl-ana.functional-utils")
8354     (arguments
8355      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8356        ((#:asd-file _ "") "functional-utils/cl-ana.functional-utils.asd")
8357        ((#:asd-system-name _ #f) "cl-ana.functional-utils")))))
8358
8359 (define-public cl-ana.functional-utils
8360   (sbcl-package->cl-source-package sbcl-cl-ana.functional-utils))
8361
8362 (define-public ecl-cl-ana.functional-utils
8363   (sbcl-package->ecl-package sbcl-cl-ana.functional-utils))
8364
8365 (define-public sbcl-cl-ana.list-utils
8366   (package
8367     (inherit sbcl-cl-ana-boot0)
8368     (name "sbcl-cl-ana.list-utils")
8369     (inputs
8370      `(("alexandria" ,sbcl-alexandria)
8371        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
8372        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)))
8373     (arguments
8374      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8375        ((#:asd-file _ "") "list-utils/cl-ana.list-utils.asd")
8376        ((#:asd-system-name _ #f) "cl-ana.list-utils")))))
8377
8378 (define-public cl-ana.list-utils
8379   (sbcl-package->cl-source-package sbcl-cl-ana.list-utils))
8380
8381 (define-public ecl-cl-ana.list-utils
8382   (sbcl-package->ecl-package sbcl-cl-ana.list-utils))
8383
8384 (define-public sbcl-cl-ana.generic-math
8385   (package
8386     (inherit sbcl-cl-ana-boot0)
8387     (name "sbcl-cl-ana.generic-math")
8388     (inputs
8389      `(("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8390        ("cl-ana.package-utils" ,sbcl-cl-ana.package-utils)))
8391     (arguments
8392      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8393        ((#:asd-file _ "") "generic-math/cl-ana.generic-math.asd")
8394        ((#:asd-system-name _ #f) "cl-ana.generic-math")))))
8395
8396 (define-public cl-ana.generic-math
8397   (sbcl-package->cl-source-package sbcl-cl-ana.generic-math))
8398
8399 (define-public ecl-cl-ana.generic-math
8400   (sbcl-package->ecl-package sbcl-cl-ana.generic-math))
8401
8402 (define-public sbcl-cl-ana.math-functions
8403   (package
8404     (inherit sbcl-cl-ana-boot0)
8405     (name "sbcl-cl-ana.math-functions")
8406     (inputs
8407      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8408        ("gsll" ,sbcl-gsll)))
8409     (arguments
8410      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8411        ((#:asd-file _ "") "math-functions/cl-ana.math-functions.asd")
8412        ((#:asd-system-name _ #f) "cl-ana.math-functions")))))
8413
8414 (define-public cl-ana.math-functions
8415   (sbcl-package->cl-source-package sbcl-cl-ana.math-functions))
8416
8417 (define-public sbcl-cl-ana.calculus
8418   (package
8419     (inherit sbcl-cl-ana-boot0)
8420     (name "sbcl-cl-ana.calculus")
8421     (inputs
8422      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)))
8423     (arguments
8424      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8425        ((#:asd-file _ "") "calculus/cl-ana.calculus.asd")
8426        ((#:asd-system-name _ #f) "cl-ana.calculus")))))
8427
8428 (define-public cl-ana.calculus
8429   (sbcl-package->cl-source-package sbcl-cl-ana.calculus))
8430
8431 (define-public ecl-cl-ana.calculus
8432   (sbcl-package->ecl-package sbcl-cl-ana.calculus))
8433
8434 (define-public sbcl-cl-ana.symbol-utils
8435   (package
8436     (inherit sbcl-cl-ana-boot0)
8437     (name "sbcl-cl-ana.symbol-utils")
8438     (inputs
8439      `(("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)))
8440     (arguments
8441      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8442        ((#:asd-file _ "") "symbol-utils/cl-ana.symbol-utils.asd")
8443        ((#:asd-system-name _ #f) "cl-ana.symbol-utils")))))
8444
8445 (define-public cl-ana.symbol-utils
8446   (sbcl-package->cl-source-package sbcl-cl-ana.symbol-utils))
8447
8448 (define-public ecl-cl-ana.symbol-utils
8449   (sbcl-package->ecl-package sbcl-cl-ana.symbol-utils))
8450
8451 (define-public sbcl-cl-ana.macro-utils
8452   (package
8453     (inherit sbcl-cl-ana-boot0)
8454     (name "sbcl-cl-ana.macro-utils")
8455     (inputs
8456      `(("alexandria" ,sbcl-alexandria)
8457        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8458        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8459        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8460        ("split-sequence" ,sbcl-split-sequence)))
8461     (arguments
8462      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8463        ((#:asd-file _ "") "macro-utils/cl-ana.macro-utils.asd")
8464        ((#:asd-system-name _ #f) "cl-ana.macro-utils")))))
8465
8466 (define-public cl-ana.macro-utils
8467   (sbcl-package->cl-source-package sbcl-cl-ana.macro-utils))
8468
8469 (define-public ecl-cl-ana.macro-utils
8470   (sbcl-package->ecl-package sbcl-cl-ana.macro-utils))
8471
8472 (define-public sbcl-cl-ana.binary-tree
8473   (package
8474     (inherit sbcl-cl-ana-boot0)
8475     (name "sbcl-cl-ana.binary-tree")
8476     (inputs
8477      `(("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
8478        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8479        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)))
8480     (arguments
8481      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8482        ((#:asd-file _ "") "binary-tree/cl-ana.binary-tree.asd")
8483        ((#:asd-system-name _ #f) "cl-ana.binary-tree")))))
8484
8485 (define-public cl-ana.binary-tree
8486   (sbcl-package->cl-source-package sbcl-cl-ana.binary-tree))
8487
8488 (define-public ecl-cl-ana.binary-tree
8489   (sbcl-package->ecl-package sbcl-cl-ana.binary-tree))
8490
8491 (define-public sbcl-cl-ana.tensor
8492   (package
8493     (inherit sbcl-cl-ana-boot0)
8494     (name "sbcl-cl-ana.tensor")
8495     (inputs
8496      `(("alexandria" ,sbcl-alexandria)
8497        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8498        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8499        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8500        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)))
8501     (arguments
8502      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8503        ((#:asd-file _ "") "tensor/cl-ana.tensor.asd")
8504        ((#:asd-system-name _ #f) "cl-ana.tensor")))))
8505
8506 (define-public cl-ana.tensor
8507   (sbcl-package->cl-source-package sbcl-cl-ana.tensor))
8508
8509 (define-public ecl-cl-ana.tensor
8510   (sbcl-package->ecl-package sbcl-cl-ana.tensor))
8511
8512 (define-public sbcl-cl-ana.error-propogation
8513   (package
8514     (inherit sbcl-cl-ana-boot0)
8515     (name "sbcl-cl-ana.error-propogation")
8516     (inputs
8517      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8518        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)))
8519     (arguments
8520      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8521        ((#:asd-file _ "") "error-propogation/cl-ana.error-propogation.asd")
8522        ((#:asd-system-name _ #f) "cl-ana.error-propogation")))))
8523
8524 (define-public cl-ana.error-propogation
8525   (sbcl-package->cl-source-package sbcl-cl-ana.error-propogation))
8526
8527 (define-public sbcl-cl-ana.quantity
8528   (package
8529     (inherit sbcl-cl-ana-boot0)
8530     (name "sbcl-cl-ana.quantity")
8531     (inputs
8532      `(("alexandria" ,sbcl-alexandria)
8533        ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
8534        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8535        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8536        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8537        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)))
8538     (arguments
8539      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8540        ((#:asd-file _ "") "quantity/cl-ana.quantity.asd")
8541        ((#:asd-system-name _ #f) "cl-ana.quantity")))))
8542
8543 (define-public cl-ana.quantity
8544   (sbcl-package->cl-source-package sbcl-cl-ana.quantity))
8545
8546 (define-public sbcl-cl-ana.table
8547   (package
8548     (inherit sbcl-cl-ana-boot0)
8549     (name "sbcl-cl-ana.table")
8550     (inputs
8551      `(("alexandria" ,sbcl-alexandria)
8552        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
8553        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8554        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8555        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8556        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)))
8557     (arguments
8558      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8559        ((#:asd-file _ "") "table/cl-ana.table.asd")
8560        ((#:asd-system-name _ #f) "cl-ana.table")))))
8561
8562 (define-public cl-ana.table
8563   (sbcl-package->cl-source-package sbcl-cl-ana.table))
8564
8565 (define-public ecl-cl-ana.table
8566   (sbcl-package->ecl-package sbcl-cl-ana.table))
8567
8568 (define-public sbcl-cl-ana.table-utils
8569   (package
8570     (inherit sbcl-cl-ana-boot0)
8571     (name "sbcl-cl-ana.table-utils")
8572     (inputs
8573      `(("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8574        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8575        ("cl-ana.table" ,sbcl-cl-ana.table)))
8576     (arguments
8577      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8578        ((#:asd-file _ "") "table-utils/cl-ana.table-utils.asd")
8579        ((#:asd-system-name _ #f) "cl-ana.table-utils")))))
8580
8581 (define-public cl-ana.table-utils
8582   (sbcl-package->cl-source-package sbcl-cl-ana.table-utils))
8583
8584 (define-public ecl-cl-ana.table-utils
8585   (sbcl-package->ecl-package sbcl-cl-ana.table-utils))
8586
8587 (define-public sbcl-cl-ana.hdf-cffi
8588   (package
8589     (inherit sbcl-cl-ana-boot0)
8590     (name "sbcl-cl-ana.hdf-cffi")
8591     (inputs
8592      `(("cffi" ,sbcl-cffi)
8593        ("hdf5" ,hdf5-parallel-openmpi)))
8594     (arguments
8595      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8596        ((#:asd-file _ "") "hdf-cffi/cl-ana.hdf-cffi.asd")
8597        ((#:asd-system-name _ #f) "cl-ana.hdf-cffi")
8598        ((#:phases phases '%standard-phases)
8599         `(modify-phases ,phases
8600            (add-after 'unpack 'fix-paths
8601              (lambda* (#:key inputs #:allow-other-keys)
8602                (substitute* "hdf-cffi/hdf-cffi.lisp"
8603                  (("/usr/lib/i386-linux-gnu/hdf5/serial/libhdf5.so")
8604                   (string-append
8605                    (assoc-ref inputs "hdf5")
8606                    "/lib/libhdf5.so")))))))))))
8607
8608 (define-public cl-ana.hdf-cffi
8609   (sbcl-package->cl-source-package sbcl-cl-ana.hdf-cffi))
8610
8611 (define-public ecl-cl-ana.hdf-cffi
8612   (sbcl-package->ecl-package sbcl-cl-ana.hdf-cffi))
8613
8614 (define-public sbcl-cl-ana.int-char
8615   (package
8616     (inherit sbcl-cl-ana-boot0)
8617     (name "sbcl-cl-ana.int-char")
8618     (arguments
8619      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8620        ((#:asd-file _ "") "int-char/cl-ana.int-char.asd")
8621        ((#:asd-system-name _ #f) "cl-ana.int-char")))))
8622
8623 (define-public cl-ana.int-char
8624   (sbcl-package->cl-source-package sbcl-cl-ana.int-char))
8625
8626 (define-public ecl-cl-ana.int-char
8627   (sbcl-package->ecl-package sbcl-cl-ana.int-char))
8628
8629 (define-public sbcl-cl-ana.memoization
8630   (package
8631     (inherit sbcl-cl-ana-boot0)
8632     (name "sbcl-cl-ana.memoization")
8633     (inputs
8634      `(("alexandria" ,sbcl-alexandria)))
8635     (arguments
8636      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8637        ((#:asd-file _ "") "memoization/cl-ana.memoization.asd")
8638        ((#:asd-system-name _ #f) "cl-ana.memoization")))))
8639
8640 (define-public cl-ana.memoization
8641   (sbcl-package->cl-source-package sbcl-cl-ana.memoization))
8642
8643 (define-public ecl-cl-ana.memoization
8644   (sbcl-package->ecl-package sbcl-cl-ana.memoization))
8645
8646 (define-public sbcl-cl-ana.typespec
8647   (package
8648     (inherit sbcl-cl-ana-boot0)
8649     (name "sbcl-cl-ana.typespec")
8650     (inputs
8651      `(("alexandria" ,sbcl-alexandria)
8652        ("cffi" ,sbcl-cffi)
8653        ("cl-ana.int-char" ,sbcl-cl-ana.int-char)
8654        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8655        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
8656        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8657        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8658        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)))
8659     (arguments
8660      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8661        ((#:asd-file _ "") "typespec/cl-ana.typespec.asd")
8662        ((#:asd-system-name _ #f) "cl-ana.typespec")))))
8663
8664 (define-public cl-ana.typespec
8665   (sbcl-package->cl-source-package sbcl-cl-ana.typespec))
8666
8667 (define-public ecl-cl-ana.typespec
8668   (sbcl-package->ecl-package sbcl-cl-ana.typespec))
8669
8670 (define-public sbcl-cl-ana.hdf-typespec
8671   (package
8672     (inherit sbcl-cl-ana-boot0)
8673     (name "sbcl-cl-ana.hdf-typespec")
8674     (inputs
8675      `(("alexandria" ,sbcl-alexandria)
8676        ("cffi" ,sbcl-cffi)
8677        ("cl-ana.hdf-cffi" ,sbcl-cl-ana.hdf-cffi)
8678        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8679        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
8680        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8681        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8682        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
8683     (arguments
8684      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8685        ((#:asd-file _ "") "hdf-typespec/cl-ana.hdf-typespec.asd")
8686        ((#:asd-system-name _ #f) "cl-ana.hdf-typespec")))))
8687
8688 (define-public cl-ana.hdf-typespec
8689   (sbcl-package->cl-source-package sbcl-cl-ana.hdf-typespec))
8690
8691 (define-public ecl-cl-ana.hdf-typespec
8692   (sbcl-package->ecl-package sbcl-cl-ana.hdf-typespec))
8693
8694 (define-public sbcl-cl-ana.hdf-utils
8695   (package
8696     (inherit sbcl-cl-ana-boot0)
8697     (name "sbcl-cl-ana.hdf-utils")
8698     (inputs
8699      `(("alexandria" ,sbcl-alexandria)
8700        ("cffi" ,sbcl-cffi)
8701        ("cl-ana.hdf-cffi" ,sbcl-cl-ana.hdf-cffi)
8702        ("cl-ana.hdf-typespec" ,sbcl-cl-ana.hdf-typespec)
8703        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8704        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
8705        ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
8706        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8707        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
8708     (arguments
8709      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8710        ((#:asd-file _ "") "hdf-utils/cl-ana.hdf-utils.asd")
8711        ((#:asd-system-name _ #f) "cl-ana.hdf-utils")))))
8712
8713 (define-public cl-ana.hdf-utils
8714   (sbcl-package->cl-source-package sbcl-cl-ana.hdf-utils))
8715
8716 (define-public ecl-cl-ana.hdf-utils
8717   (sbcl-package->ecl-package sbcl-cl-ana.hdf-utils))
8718
8719 (define-public sbcl-cl-ana.typed-table
8720   (package
8721     (inherit sbcl-cl-ana-boot0)
8722     (name "sbcl-cl-ana.typed-table")
8723     (inputs
8724      `(("alexandria" ,sbcl-alexandria)
8725        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8726        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8727        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8728        ("cl-ana.table" ,sbcl-cl-ana.table)
8729        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
8730     (arguments
8731      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8732        ((#:asd-file _ "") "typed-table/cl-ana.typed-table.asd")
8733        ((#:asd-system-name _ #f) "cl-ana.typed-table")))))
8734
8735 (define-public cl-ana.typed-table
8736   (sbcl-package->cl-source-package sbcl-cl-ana.typed-table))
8737
8738 (define-public ecl-cl-ana.typed-table
8739   (sbcl-package->ecl-package sbcl-cl-ana.typed-table))
8740
8741 (define-public sbcl-cl-ana.hdf-table
8742   (package
8743     (inherit sbcl-cl-ana-boot0)
8744     (name "sbcl-cl-ana.hdf-table")
8745     (inputs
8746      `(("alexandria" ,sbcl-alexandria)
8747        ("cl-ana.binary-tree" ,sbcl-cl-ana.binary-tree)
8748        ("cl-ana.hdf-cffi" ,sbcl-cl-ana.hdf-cffi)
8749        ("cl-ana.hdf-typespec" ,sbcl-cl-ana.hdf-typespec)
8750        ("cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
8751        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8752        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
8753        ("cl-ana.table" ,sbcl-cl-ana.table)
8754        ("cl-ana.typed-table" ,sbcl-cl-ana.typed-table)
8755        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
8756     (arguments
8757      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8758        ((#:asd-file _ "") "hdf-table/cl-ana.hdf-table.asd")
8759        ((#:asd-system-name _ #f) "cl-ana.hdf-table")))))
8760
8761 (define-public cl-ana.hdf-table
8762   (sbcl-package->cl-source-package sbcl-cl-ana.hdf-table))
8763
8764 (define-public ecl-cl-ana.hdf-table
8765   (sbcl-package->ecl-package sbcl-cl-ana.hdf-table))
8766
8767 (define-public sbcl-cl-ana.gsl-cffi
8768   (package
8769     (inherit sbcl-cl-ana-boot0)
8770     (name "sbcl-cl-ana.gsl-cffi")
8771     (inputs
8772      `(("cffi" ,sbcl-cffi)
8773        ("gsl" ,gsl)))
8774     (arguments
8775      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8776        ((#:asd-file _ "") "gsl-cffi/cl-ana.gsl-cffi.asd")
8777        ((#:asd-system-name _ #f) "cl-ana.gsl-cffi")
8778        ((#:phases phases '%standard-phases)
8779         `(modify-phases ,phases
8780            (add-after 'unpack 'fix-paths
8781              (lambda* (#:key inputs #:allow-other-keys)
8782                (substitute* "gsl-cffi/gsl-cffi.lisp"
8783                  (("define-foreign-library gsl-cffi" all)
8784                   (string-append all " (:unix "
8785                                  (assoc-ref inputs "gsl")
8786                                  "/lib/libgsl.so)")))))))))))
8787
8788 (define-public cl-ana.gsl-cffi
8789   (sbcl-package->cl-source-package sbcl-cl-ana.gsl-cffi))
8790
8791 (define-public ecl-cl-ana.gsl-cffi
8792   (sbcl-package->ecl-package sbcl-cl-ana.gsl-cffi))
8793
8794 (define-public sbcl-cl-ana.ntuple-table
8795   (package
8796     (inherit sbcl-cl-ana-boot0)
8797     (name "sbcl-cl-ana.ntuple-table")
8798     (inputs
8799      `(("alexandria" ,sbcl-alexandria)
8800        ("cffi" ,sbcl-cffi)
8801        ("cl-ana.gsl-cffi" ,sbcl-cl-ana.gsl-cffi)
8802        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8803        ("cl-ana.table" ,sbcl-cl-ana.table)
8804        ("cl-ana.typed-table" ,sbcl-cl-ana.typed-table)
8805        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)
8806        ("gsll" ,sbcl-gsll)))
8807     (arguments
8808      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8809        ((#:asd-file _ "") "ntuple-table/cl-ana.ntuple-table.asd")
8810        ((#:asd-system-name _ #f) "cl-ana.ntuple-table")))))
8811
8812 (define-public cl-ana.ntuple-table
8813   (sbcl-package->cl-source-package sbcl-cl-ana.ntuple-table))
8814
8815 (define-public sbcl-cl-ana.csv-table
8816   (package
8817     (inherit sbcl-cl-ana-boot0)
8818     (name "sbcl-cl-ana.csv-table")
8819     (inputs
8820      `(("alexandria" ,sbcl-alexandria)
8821        ("antik" ,sbcl-antik)
8822        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8823        ("cl-ana.table" ,sbcl-cl-ana.table)
8824        ("cl-csv" ,sbcl-cl-csv)
8825        ("iterate" ,sbcl-iterate)))
8826     (arguments
8827      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8828        ((#:asd-file _ "") "csv-table/cl-ana.csv-table.asd")
8829        ((#:asd-system-name _ #f) "cl-ana.csv-table")))))
8830
8831 (define-public cl-ana.csv-table
8832   (sbcl-package->cl-source-package sbcl-cl-ana.csv-table))
8833
8834 (define-public sbcl-cl-ana.reusable-table
8835   (package
8836     (inherit sbcl-cl-ana-boot0)
8837     (name "sbcl-cl-ana.reusable-table")
8838     (inputs
8839      `(("alexandria" ,sbcl-alexandria)
8840        ("cl-ana.table" ,sbcl-cl-ana.table)))
8841     (arguments
8842      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8843        ((#:asd-file _ "") "reusable-table/cl-ana.reusable-table.asd")
8844        ((#:asd-system-name _ #f) "cl-ana.reusable-table")))))
8845
8846 (define-public cl-ana.reusable-table
8847   (sbcl-package->cl-source-package sbcl-cl-ana.reusable-table))
8848
8849 (define-public ecl-cl-ana.reusable-table
8850   (sbcl-package->ecl-package sbcl-cl-ana.reusable-table))
8851
8852 (define-public sbcl-cl-ana.linear-algebra
8853   (package
8854     (inherit sbcl-cl-ana-boot0)
8855     (name "sbcl-cl-ana.linear-algebra")
8856     (inputs
8857      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8858        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8859        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
8860        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
8861        ("gsll" ,sbcl-gsll)))
8862     (arguments
8863      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8864        ((#:asd-file _ "") "linear-algebra/cl-ana.linear-algebra.asd")
8865        ((#:asd-system-name _ #f) "cl-ana.linear-algebra")))))
8866
8867 (define-public cl-ana.linear-algebra
8868   (sbcl-package->cl-source-package sbcl-cl-ana.linear-algebra))
8869
8870 (define-public sbcl-cl-ana.lorentz
8871   (package
8872     (inherit sbcl-cl-ana-boot0)
8873     (name "sbcl-cl-ana.lorentz")
8874     (inputs
8875      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8876        ("cl-ana.linear-algebra" ,sbcl-cl-ana.linear-algebra)
8877        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
8878        ("iterate" ,sbcl-iterate)))
8879     (arguments
8880      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8881        ((#:asd-file _ "") "lorentz/cl-ana.lorentz.asd")
8882        ((#:asd-system-name _ #f) "cl-ana.lorentz")))))
8883
8884 (define-public cl-ana.lorentz
8885   (sbcl-package->cl-source-package sbcl-cl-ana.lorentz))
8886
8887 (define-public sbcl-cl-ana.clos-utils
8888   (package
8889     (inherit sbcl-cl-ana-boot0)
8890     (name "sbcl-cl-ana.clos-utils")
8891     (inputs
8892      `(("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8893        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8894        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
8895        ("closer-mop" ,sbcl-closer-mop)))
8896     (arguments
8897      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8898        ((#:asd-file _ "") "clos-utils/cl-ana.clos-utils.asd")
8899        ((#:asd-system-name _ #f) "cl-ana.clos-utils")))))
8900
8901 (define-public cl-ana.clos-utils
8902   (sbcl-package->cl-source-package sbcl-cl-ana.clos-utils))
8903
8904 (define-public ecl-cl-ana.clos-utils
8905   (sbcl-package->ecl-package sbcl-cl-ana.clos-utils))
8906
8907 (define-public sbcl-cl-ana.hash-table-utils
8908   (package
8909     (inherit sbcl-cl-ana-boot0)
8910     (name "sbcl-cl-ana.hash-table-utils")
8911     (arguments
8912      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8913        ((#:asd-file _ "") "hash-table-utils/cl-ana.hash-table-utils.asd")
8914        ((#:asd-system-name _ #f) "cl-ana.hash-table-utils")))))
8915
8916 (define-public cl-ana.hash-table-utils
8917   (sbcl-package->cl-source-package sbcl-cl-ana.hash-table-utils))
8918
8919 (define-public ecl-cl-ana.hash-table-utils
8920   (sbcl-package->ecl-package sbcl-cl-ana.hash-table-utils))
8921
8922 (define-public sbcl-cl-ana.map
8923   (package
8924     (inherit sbcl-cl-ana-boot0)
8925     (name "sbcl-cl-ana.map")
8926     (inputs
8927      `(("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)))
8928     (arguments
8929      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8930        ((#:asd-file _ "") "map/cl-ana.map.asd")
8931        ((#:asd-system-name _ #f) "cl-ana.map")))))
8932
8933 (define-public cl-ana.map
8934   (sbcl-package->cl-source-package sbcl-cl-ana.map))
8935
8936 (define-public ecl-cl-ana.map
8937   (sbcl-package->ecl-package sbcl-cl-ana.map))
8938
8939 (define-public sbcl-cl-ana.fitting
8940   (package
8941     (inherit sbcl-cl-ana-boot0)
8942     (name "sbcl-cl-ana.fitting")
8943     (inputs
8944      `(("alexandria" ,sbcl-alexandria)
8945        ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
8946        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8947        ("cl-ana.map" ,sbcl-cl-ana.map)
8948        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
8949        ("gsll" ,sbcl-gsll)))
8950     (arguments
8951      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8952        ((#:asd-file _ "") "fitting/cl-ana.fitting.asd")
8953        ((#:asd-system-name _ #f) "cl-ana.fitting")))))
8954
8955 (define-public cl-ana.fitting
8956   (sbcl-package->cl-source-package sbcl-cl-ana.fitting))
8957
8958 (define-public sbcl-cl-ana.histogram
8959   (package
8960     (inherit sbcl-cl-ana-boot0)
8961     (name "sbcl-cl-ana.histogram")
8962     (inputs
8963      `(("alexandria" ,sbcl-alexandria)
8964        ("iterate" ,sbcl-iterate)
8965        ("cl-ana.binary-tree" ,sbcl-cl-ana.binary-tree)
8966        ("cl-ana.clos-utils" ,sbcl-cl-ana.clos-utils)
8967        ("cl-ana.fitting" ,sbcl-cl-ana.fitting)
8968        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
8969        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8970        ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
8971        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8972        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8973        ("cl-ana.map" ,sbcl-cl-ana.map)
8974        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)))
8975     (arguments
8976      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8977        ((#:asd-file _ "") "histogram/cl-ana.histogram.asd")
8978        ((#:asd-system-name _ #f) "cl-ana.histogram")))))
8979
8980 (define-public cl-ana.histogram
8981   (sbcl-package->cl-source-package sbcl-cl-ana.histogram))
8982
8983 (define-public sbcl-cl-ana.file-utils
8984   (package
8985     (inherit sbcl-cl-ana-boot0)
8986     (name "sbcl-cl-ana.file-utils")
8987     (inputs
8988      `(("external-program" ,sbcl-external-program)
8989        ("split-sequence" ,sbcl-split-sequence)))
8990     (arguments
8991      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8992        ((#:asd-file _ "") "file-utils/cl-ana.file-utils.asd")
8993        ((#:asd-system-name _ #f) "cl-ana.file-utils")))))
8994
8995 (define-public cl-ana.file-utils
8996   (sbcl-package->cl-source-package sbcl-cl-ana.file-utils))
8997
8998 (define-public ecl-cl-ana.file-utils
8999   (sbcl-package->ecl-package sbcl-cl-ana.file-utils))
9000
9001 (define-public sbcl-cl-ana.statistics
9002   (package
9003     (inherit sbcl-cl-ana-boot0)
9004     (name "sbcl-cl-ana.statistics")
9005     (inputs
9006      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9007        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9008        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9009        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9010        ("cl-ana.map" ,sbcl-cl-ana.map)))
9011     (arguments
9012      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9013        ((#:asd-file _ "") "statistics/cl-ana.statistics.asd")
9014        ((#:asd-system-name _ #f) "cl-ana.statistics")))))
9015
9016 (define-public cl-ana.statistics
9017   (sbcl-package->cl-source-package sbcl-cl-ana.statistics))
9018
9019 (define-public sbcl-cl-ana.gnuplot-interface
9020   (package
9021     (inherit sbcl-cl-ana-boot0)
9022     (name "sbcl-cl-ana.gnuplot-interface")
9023     (inputs
9024      `(("external-program" ,sbcl-external-program)))
9025     (arguments
9026      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9027        ((#:asd-file _ "") "gnuplot-interface/cl-ana.gnuplot-interface.asd")
9028        ((#:asd-system-name _ #f) "cl-ana.gnuplot-interface")))))
9029
9030 (define-public cl-ana.gnuplot-interface
9031   (sbcl-package->cl-source-package sbcl-cl-ana.gnuplot-interface))
9032
9033 (define-public ecl-cl-ana.gnuplot-interface
9034   (sbcl-package->ecl-package sbcl-cl-ana.gnuplot-interface))
9035
9036 (define-public sbcl-cl-ana.plotting
9037   (package
9038     (inherit sbcl-cl-ana-boot0)
9039     (name "sbcl-cl-ana.plotting")
9040     (inputs
9041      `(("alexandria" ,sbcl-alexandria)
9042        ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
9043        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
9044        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9045        ("cl-ana.gnuplot-interface" ,sbcl-cl-ana.gnuplot-interface)
9046        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9047        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9048        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9049        ("cl-ana.map" ,sbcl-cl-ana.map)
9050        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
9051        ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
9052        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
9053        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
9054        ("external-program" ,sbcl-external-program)
9055        ("split-sequence" ,sbcl-split-sequence)))
9056     (arguments
9057      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9058        ((#:asd-file _ "") "plotting/cl-ana.plotting.asd")
9059        ((#:asd-system-name _ #f) "cl-ana.plotting")))))
9060
9061 (define-public cl-ana.plotting
9062   (sbcl-package->cl-source-package sbcl-cl-ana.plotting))
9063
9064 (define-public sbcl-cl-ana.table-viewing
9065   (package
9066     (inherit sbcl-cl-ana-boot0)
9067     (name "sbcl-cl-ana.table-viewing")
9068     (inputs
9069      `(("alexandria" ,sbcl-alexandria)
9070        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9071        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9072        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9073        ("cl-ana.plotting" ,sbcl-cl-ana.plotting)
9074        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
9075        ("cl-ana.table" ,sbcl-cl-ana.table)))
9076     (arguments
9077      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9078        ((#:asd-file _ "") "table-viewing/cl-ana.table-viewing.asd")
9079        ((#:asd-system-name _ #f) "cl-ana.table-viewing")))))
9080
9081 (define-public cl-ana.table-viewing
9082   (sbcl-package->cl-source-package sbcl-cl-ana.table-viewing))
9083
9084 (define-public sbcl-cl-ana.serialization
9085   (package
9086     (inherit sbcl-cl-ana-boot0)
9087     (name "sbcl-cl-ana.serialization")
9088     (inputs
9089      `(("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
9090        ("cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
9091        ("cl-ana.hdf-table" ,sbcl-cl-ana.hdf-table)
9092        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9093        ("cl-ana.int-char" ,sbcl-cl-ana.int-char)
9094        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9095        ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
9096     (arguments
9097      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9098        ((#:asd-file _ "") "serialization/cl-ana.serialization.asd")
9099        ((#:asd-system-name _ #f) "cl-ana.serialization")))))
9100
9101 (define-public cl-ana.serialization
9102   (sbcl-package->cl-source-package sbcl-cl-ana.serialization))
9103
9104 (define-public sbcl-cl-ana.makeres
9105   (package
9106     (inherit sbcl-cl-ana-boot0)
9107     (name "sbcl-cl-ana.makeres")
9108     (inputs
9109      `(("alexandria" ,sbcl-alexandria)
9110        ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
9111        ("cl-ana.file-utils" ,sbcl-cl-ana.file-utils)
9112        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
9113        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9114        ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
9115        ("cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
9116        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9117        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9118        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9119        ("cl-ana.map" ,sbcl-cl-ana.map)
9120        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
9121        ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
9122        ("cl-ana.plotting" ,sbcl-cl-ana.plotting)
9123        ("cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
9124        ("cl-ana.serialization" ,sbcl-cl-ana.serialization)
9125        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
9126        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
9127        ("cl-ana.table" ,sbcl-cl-ana.table)
9128        ("external-program" ,sbcl-external-program)))
9129     (native-inputs
9130      `(("cl-fad" ,sbcl-cl-fad)))
9131     (arguments
9132      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9133        ((#:asd-file _ "") "makeres/cl-ana.makeres.asd")
9134        ((#:asd-system-name _ #f) "cl-ana.makeres")))))
9135
9136 (define-public cl-ana.makeres
9137   (sbcl-package->cl-source-package sbcl-cl-ana.makeres))
9138
9139 (define-public sbcl-cl-ana.makeres-macro
9140   (package
9141     (inherit sbcl-cl-ana-boot0)
9142     (name "sbcl-cl-ana.makeres-macro")
9143     (inputs
9144      `(("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9145        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)))
9146     (arguments
9147      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9148        ((#:asd-file _ "") "makeres-macro/cl-ana.makeres-macro.asd")
9149        ((#:asd-system-name _ #f) "cl-ana.makeres-macro")))))
9150
9151 (define-public cl-ana.makeres-macro
9152   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-macro))
9153
9154 (define-public sbcl-cl-ana.makeres-block
9155   (package
9156     (inherit sbcl-cl-ana-boot0)
9157     (name "sbcl-cl-ana.makeres-block")
9158     (inputs
9159      `(("alexandria" ,sbcl-alexandria)
9160        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9161        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9162        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)))
9163     (arguments
9164      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9165        ((#:asd-file _ "") "makeres-block/cl-ana.makeres-block.asd")
9166        ((#:asd-system-name _ #f) "cl-ana.makeres-block")))))
9167
9168 (define-public cl-ana.makeres-block
9169   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-block))
9170
9171 (define-public sbcl-cl-ana.makeres-progress
9172   (package
9173     (inherit sbcl-cl-ana-boot0)
9174     (name "sbcl-cl-ana.makeres-progress")
9175     (inputs
9176      `(("alexandria" ,sbcl-alexandria)
9177        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9178        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)))
9179     (arguments
9180      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9181        ((#:asd-file _ "") "makeres-progress/cl-ana.makeres-progress.asd")
9182        ((#:asd-system-name _ #f) "cl-ana.makeres-progress")))))
9183
9184 (define-public cl-ana.makeres-progress
9185   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-progress))
9186
9187 (define-public sbcl-cl-ana.makeres-table
9188   (package
9189     (inherit sbcl-cl-ana-boot0)
9190     (name "sbcl-cl-ana.makeres-table")
9191     (inputs
9192      `(("cl-ana.csv-table" ,sbcl-cl-ana.csv-table)
9193        ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
9194        ("cl-ana.hdf-table" ,sbcl-cl-ana.hdf-table)
9195        ("cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
9196        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9197        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9198        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)
9199        ("cl-ana.makeres-macro" ,sbcl-cl-ana.makeres-macro)
9200        ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
9201        ("cl-ana.ntuple-table" ,sbcl-cl-ana.ntuple-table)
9202        ("cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
9203        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
9204        ("cl-ana.table" ,sbcl-cl-ana.table)))
9205     (native-inputs
9206      `(("cl-fad" ,sbcl-cl-fad)))
9207     (arguments
9208      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9209        ((#:asd-file _ "") "makeres-table/cl-ana.makeres-table.asd")
9210        ((#:asd-system-name _ #f) "cl-ana.makeres-table")))))
9211
9212 (define-public cl-ana.makeres-table
9213   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-table))
9214
9215 (define-public sbcl-cl-ana.makeres-graphviz
9216   (package
9217     (inherit sbcl-cl-ana-boot0)
9218     (name "sbcl-cl-ana.makeres-graphviz")
9219     (inputs
9220      `(("cl-ana.makeres" ,sbcl-cl-ana.makeres)
9221        ("external-program" ,sbcl-external-program)))
9222     (arguments
9223      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9224        ((#:asd-file _ "") "makeres-graphviz/cl-ana.makeres-graphviz.asd")
9225        ((#:asd-system-name _ #f) "cl-ana.makeres-graphviz")))))
9226
9227 (define-public cl-ana.makeres-graphviz
9228   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-graphviz))
9229
9230 (define-public sbcl-cl-ana.makeres-branch
9231   (package
9232     (inherit sbcl-cl-ana-boot0)
9233     (name "sbcl-cl-ana.makeres-branch")
9234     (inputs
9235      `(("alexandria" ,sbcl-alexandria)
9236        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9237        ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
9238        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9239        ("cl-ana.map" ,sbcl-cl-ana.map)
9240        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)))
9241     (arguments
9242      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9243        ((#:asd-file _ "") "makeres-branch/cl-ana.makeres-branch.asd")
9244        ((#:asd-system-name _ #f) "cl-ana.makeres-branch")))))
9245
9246 (define-public cl-ana.makeres-branch
9247   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-branch))
9248
9249 (define-public sbcl-cl-ana.makeres-utils
9250   (package
9251     (inherit sbcl-cl-ana-boot0)
9252     (name "sbcl-cl-ana.makeres-utils")
9253     (inputs
9254      `(("alexandria" ,sbcl-alexandria)
9255        ("cl-ana.file-utils" ,sbcl-cl-ana.file-utils)
9256        ("cl-ana.fitting" ,sbcl-cl-ana.fitting)
9257        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
9258        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9259        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9260        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9261        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9262        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)
9263        ("cl-ana.map" ,sbcl-cl-ana.map)
9264        ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
9265        ("cl-ana.plotting" ,sbcl-cl-ana.plotting)
9266        ("cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
9267        ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
9268        ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
9269        ("cl-ana.table" ,sbcl-cl-ana.table)))
9270     (native-inputs
9271      `(("cl-fad" ,sbcl-cl-fad)))
9272     (arguments
9273      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9274        ((#:asd-file _ "") "makeres-utils/cl-ana.makeres-utils.asd")
9275        ((#:asd-system-name _ #f) "cl-ana.makeres-utils")))))
9276
9277 (define-public cl-ana.makeres-utils
9278   (sbcl-package->cl-source-package sbcl-cl-ana.makeres-utils))
9279
9280 (define-public sbcl-cl-ana.statistical-learning
9281   (package
9282     (inherit sbcl-cl-ana-boot0)
9283     (name "sbcl-cl-ana.statistical-learning")
9284     (inputs
9285      `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9286        ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
9287        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9288        ("cl-ana.linear-algebra" ,sbcl-cl-ana.linear-algebra)
9289        ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9290        ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9291        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
9292        ("cl-ana.map" ,sbcl-cl-ana.map)
9293        ("cl-ana.statistics" ,sbcl-cl-ana.statistics)))
9294     (native-inputs
9295      `(("cl-fad" ,sbcl-cl-fad)))
9296     (arguments
9297      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9298        ((#:asd-file _ "")
9299         "statistical-learning/cl-ana.statistical-learning.asd")
9300        ((#:asd-system-name _ #f) "cl-ana.statistical-learning")))))
9301
9302 (define-public cl-ana.statistical-learning
9303   (sbcl-package->cl-source-package sbcl-cl-ana.statistical-learning))
9304
9305 (define-public sbcl-cl-ana
9306   (package
9307     (inherit sbcl-cl-ana-boot0)
9308     (name "sbcl-cl-ana")
9309     (inputs
9310      `(("cl-ana.binary-tree" ,sbcl-cl-ana.binary-tree)
9311        ("cl-ana.calculus" ,sbcl-cl-ana.calculus)
9312        ("cl-ana.clos-utils" ,sbcl-cl-ana.clos-utils)
9313        ("cl-ana.csv-table" ,sbcl-cl-ana.csv-table)
9314        ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
9315        ("cl-ana.file-utils" ,sbcl-cl-ana.file-utils)
9316        ("cl-ana.fitting" ,sbcl-cl-ana.fitting)
9317        ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9318        ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
9319        ("cl-ana.hdf-table" ,sbcl-cl-ana.hdf-table)
9320        ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9321        ("cl-ana.int-char" ,sbcl-cl-ana.int-char)
9322        ("cl-ana.linear-algebra" ,sbcl-cl-ana.linear-algebra)
9323        ("cl-ana.lorentz" ,sbcl-cl-ana.lorentz)
9324        ("cl-ana.map" ,sbcl-cl-ana.map)
9325        ("cl-ana.makeres" ,sbcl-cl-ana.makeres)
9326        ("cl-ana.makeres-block" ,sbcl-cl-ana.makeres-block)
9327        ("cl-ana.makeres-branch" ,sbcl-cl-ana.makeres-branch)
9328        ("cl-ana.makeres-graphviz" ,sbcl-cl-ana.makeres-graphviz)
9329        ("cl-ana.makeres-macro" ,sbcl-cl-ana.makeres-macro)
9330        ("cl-ana.makeres-progress" ,sbcl-cl-ana.makeres-progress)
9331        ("cl-ana.makeres-table" ,sbcl-cl-ana.makeres-table)
9332        ("cl-ana.makeres-utils" ,sbcl-cl-ana.makeres-utils)
9333        ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
9334        ("cl-ana.ntuple-table" ,sbcl-cl-ana.ntuple-table)
9335        ("cl-ana.package-utils" ,sbcl-cl-ana.package-utils)
9336        ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
9337        ("cl-ana.plotting" ,sbcl-cl-ana.plotting)
9338        ("cl-ana.quantity" ,sbcl-cl-ana.quantity)
9339        ("cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
9340        ("cl-ana.serialization" ,sbcl-cl-ana.serialization)
9341        ("cl-ana.statistics" ,sbcl-cl-ana.statistics)
9342        ("cl-ana.statistical-learning" ,sbcl-cl-ana.statistical-learning)
9343        ("cl-ana.table" ,sbcl-cl-ana.table)
9344        ("cl-ana.table-utils" ,sbcl-cl-ana.table-utils)
9345        ("cl-ana.table-viewing" ,sbcl-cl-ana.table-viewing)
9346        ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
9347        ("libffi" ,libffi)))
9348     (native-inputs
9349      `(("cl-fad" ,sbcl-cl-fad)))
9350     (arguments
9351      (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9352        ((#:asd-file _ "") "cl-ana.asd")
9353        ((#:asd-system-name _ #f) "cl-ana")))))
9354
9355 (define-public cl-ana
9356   (sbcl-package->cl-source-package sbcl-cl-ana))
9357
9358 (define-public sbcl-archive
9359   (let ((commit "631271c091ed02994bec3980cb288a2cf32c7cdc")
9360         (revision "1"))
9361     (package
9362       (name "sbcl-archive")
9363       (version (git-version "0.9" revision commit))
9364       (source (origin
9365                 (method git-fetch)
9366                 (uri (git-reference
9367                       (url "https://github.com/sharplispers/archive.git")
9368                       (commit commit)))
9369                 (file-name (git-file-name name version))
9370                 (sha256
9371                  (base32
9372                   "0pvsc9fmybx7rxd0kmzq4shi6hszdpwdc1sfy7jwyfxf8n3hnv4p"))))
9373       (build-system asdf-build-system/sbcl)
9374       (inputs
9375        `(("cl-fad" ,sbcl-cl-fad)
9376          ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
9377       (synopsis "Common Lisp library for tar and cpio archives")
9378       (description
9379        "This is a Common Lisp library to read and write disk-based file
9380 archives such as those generated by the tar and cpio programs on Unix.")
9381       (home-page "https://github.com/sharplispers/archive")
9382       (license license:bsd-3))))
9383
9384 (define-public cl-archive
9385   (sbcl-package->cl-source-package sbcl-archive))
9386
9387 (define-public ecl-archive
9388   (sbcl-package->ecl-package sbcl-archive))
9389
9390 (define-public sbcl-misc-extensions
9391   (let ((commit "101c05112bf2f1e1bbf527396822d2f50ca6327a")
9392         (revision "1"))
9393     (package
9394       (name "sbcl-misc-extensions")
9395       (version (git-version "3.3" revision commit))
9396       (source
9397        (origin
9398          (method git-fetch)
9399          (uri (git-reference
9400                (url "https://gitlab.common-lisp.net/misc-extensions/devel.git")
9401                (commit commit)))
9402          (file-name (git-file-name name version))
9403          (sha256
9404           (base32
9405            "0gz5f4p70qzilnxsnf5lih2n9m4wjcw8hlw4w8mpn9jyhyppyyv0"))))
9406       (build-system asdf-build-system/sbcl)
9407       (synopsis "Collection of small macros and extensions for Common Lisp")
9408       (description
9409        "This project is intended as a catchall for small, general-purpose
9410 extensions to Common Lisp.  It contains:
9411
9412 @itemize
9413 @item @code{new-let}, a macro that combines and generalizes @code{let},
9414 @code{let*} and @code{multiple-value-bind},
9415 @item @code{gmap}, an iteration macro that generalizes @code{map}.
9416 @end itemize\n")
9417       (home-page "https://common-lisp.net/project/misc-extensions/")
9418       (license license:public-domain))))
9419
9420 (define-public cl-misc-extensions
9421   (sbcl-package->cl-source-package sbcl-misc-extensions))
9422
9423 (define-public ecl-misc-extensions
9424   (sbcl-package->ecl-package sbcl-misc-extensions))
9425
9426 (define-public sbcl-mt19937
9427   (package
9428     (name "sbcl-mt19937")
9429     (version "1.1")
9430     (source
9431      (origin
9432        (method url-fetch)
9433        (uri (string-append "https://common-lisp.net/project/asdf-packaging/"
9434                            "mt19937-latest.tar.gz"))
9435        (sha256
9436         (base32
9437          "1iw636b0iw5ygkv02y8i41lh7xj0acglv0hg5agryn0zzi2nf1xv"))))
9438     (build-system asdf-build-system/sbcl)
9439     (synopsis "Mersenne Twister pseudo-random number generator")
9440     (description
9441      "MT19937 is a portable Mersenne Twister pseudo-random number generator
9442 for Common Lisp.")
9443     (home-page "https://www.cliki.net/mt19937")
9444     (license license:public-domain)))
9445
9446 (define-public cl-mt19937
9447   (sbcl-package->cl-source-package sbcl-mt19937))
9448
9449 (define-public ecl-mt19937
9450   (sbcl-package->ecl-package sbcl-mt19937))
9451
9452 (define-public sbcl-fset
9453   (let ((commit "6d2f9ded8934d2b42f2571a0ba5bda091037d852")
9454         (revision "1"))
9455     (package
9456       (name "sbcl-fset")
9457       (version (git-version "1.3.2" revision commit))
9458       (source
9459        (origin
9460          (method git-fetch)
9461          (uri (git-reference
9462                (url "https://github.com/slburson/fset")
9463                (commit commit)))
9464          (file-name (git-file-name name version))
9465          (sha256
9466           (base32
9467            "127acblwrbqicx47h6sgvknz1cqyfn8p4xkhkn1m7hxh8w5gk1zy"))
9468          (snippet '(begin
9469                      ;; Remove obsolete copy of system definition.
9470                      (delete-file "Code/fset.asd")
9471                      #t))))
9472       (build-system asdf-build-system/sbcl)
9473       (inputs
9474        `(("misc-extensions" ,sbcl-misc-extensions)
9475          ("mt19937" ,sbcl-mt19937)
9476          ("named-readtables" ,sbcl-named-readtables)))
9477       (synopsis "Functional set-theoretic collections library")
9478       (description
9479        "FSet is a functional set-theoretic collections library for Common Lisp.
9480 Functional means that all update operations return a new collection rather than
9481 modifying an existing one in place.  Set-theoretic means that collections may
9482 be nested arbitrarily with no additional programmer effort; for instance, sets
9483 may contain sets, maps may be keyed by sets, etc.")
9484       (home-page "https://common-lisp.net/project/fset/Site/index.html")
9485       (license license:llgpl))))
9486
9487 (define-public cl-fset
9488   (sbcl-package->cl-source-package sbcl-fset))
9489
9490 (define-public sbcl-cl-cont
9491   (let ((commit "fc1fa7e6eb64894fdca13e688e6015fad5290d2a")
9492         (revision "1"))
9493     (package
9494       (name "sbcl-cl-cont")
9495       (version (git-version "0.3.8" revision commit))
9496       (source
9497        (origin
9498          (method git-fetch)
9499          (uri (git-reference
9500                (url "https://gitlab.common-lisp.net/cl-cont/cl-cont.git")
9501                (commit commit)))
9502          (file-name (git-file-name name version))
9503          (sha256
9504           (base32
9505            "1zf8zvb0i6jm3hhfks4w74hibm6avgc6f9s1qwgjrn2bcik8lrvz"))))
9506       (build-system asdf-build-system/sbcl)
9507       (inputs
9508        `(("alexandria" ,sbcl-alexandria)
9509          ("closer-mop" ,sbcl-closer-mop)))
9510       (native-inputs
9511        `(("rt" ,sbcl-rt)))
9512       (synopsis "Delimited continuations for Common Lisp")
9513       (description
9514        "This is a library that implements delimited continuations by
9515 transforming Common Lisp code to continuation passing style.")
9516       (home-page "https://common-lisp.net/project/cl-cont/")
9517       (license license:llgpl))))
9518
9519 (define-public cl-cont
9520   (sbcl-package->cl-source-package sbcl-cl-cont))
9521
9522 (define-public ecl-cl-cont
9523   (sbcl-package->ecl-package sbcl-cl-cont))
9524
9525 (define-public sbcl-cl-coroutine
9526   (let ((commit "de098f8d5debd8b14ef6864b5bdcbbf5ddbcfd72")
9527         (revision "1"))
9528     (package
9529       (name "sbcl-cl-coroutine")
9530       (version (git-version "0.1" revision commit))
9531       (source
9532        (origin
9533          (method git-fetch)
9534          (uri (git-reference
9535                (url "https://github.com/takagi/cl-coroutine.git")
9536                (commit commit)))
9537          (file-name (git-file-name name version))
9538          (sha256
9539           (base32
9540            "1cqdhdjxffgfs116l1swjlsmcbly0xgcgrckvaajd566idj9yj4l"))))
9541       (build-system asdf-build-system/sbcl)
9542       (inputs
9543        `(("alexandria" ,sbcl-alexandria)
9544          ("cl-cont" ,sbcl-cl-cont)))
9545       (native-inputs
9546        `(("prove" ,sbcl-prove)))
9547       (arguments
9548        `(;; TODO: Fix the tests. They fail with:
9549          ;; "Component CL-COROUTINE-ASD::CL-COROUTINE-TEST not found"
9550          #:tests? #f
9551          #:phases
9552          (modify-phases %standard-phases
9553            (add-after 'unpack 'fix-tests
9554              (lambda _
9555                (substitute* "cl-coroutine-test.asd"
9556                  (("cl-test-more")
9557                   "prove"))
9558                #t)))))
9559       (synopsis "Coroutine library for Common Lisp")
9560       (description
9561        "This is a coroutine library for Common Lisp implemented using the
9562 continuations of the @code{cl-cont} library.")
9563       (home-page "https://github.com/takagi/cl-coroutine")
9564       (license license:llgpl))))
9565
9566 (define-public cl-coroutine
9567   (sbcl-package->cl-source-package sbcl-cl-coroutine))
9568
9569 (define-public ecl-cl-coroutine
9570   (sbcl-package->ecl-package sbcl-cl-coroutine))
9571
9572 (define-public sbcl-vom
9573   (let ((commit "1aeafeb5b74c53741b79497e0ef4acf85c92ff24")
9574         (revision "1"))
9575     (package
9576       (name "sbcl-vom")
9577       (version (git-version "0.1.4" revision commit))
9578       (source
9579        (origin
9580          (method git-fetch)
9581          (uri (git-reference
9582                (url "https://github.com/orthecreedence/vom.git")
9583                (commit commit)))
9584          (file-name (git-file-name name version))
9585          (sha256
9586           (base32
9587            "0536kppj76ax4lrxhv42npkfjsmx45km2g439vf9jmw3apinz9cy"))))
9588       (build-system asdf-build-system/sbcl)
9589       (synopsis "Tiny logging utility for Common Lisp")
9590       (description
9591        "Vom is a logging library for Common Lisp.  It's goal is to be useful
9592 and small.  It does not provide a lot of features as other loggers do, but
9593 has a small codebase that's easy to understand and use.")
9594       (home-page "https://github.com/orthecreedence/vom")
9595       (license license:expat))))
9596
9597 (define-public cl-vom
9598   (sbcl-package->cl-source-package sbcl-vom))
9599
9600 (define-public ecl-vom
9601   (sbcl-package->ecl-package sbcl-vom))
9602
9603 (define-public sbcl-cl-libuv
9604   (let ((commit "32100c023c518038d0670a103eaa4d50dd785d29")
9605         (revision "1"))
9606     (package
9607       (name "sbcl-cl-libuv")
9608       (version (git-version "0.1.6" revision commit))
9609       (source
9610        (origin
9611          (method git-fetch)
9612          (uri (git-reference
9613                (url "https://github.com/orthecreedence/cl-libuv.git")
9614                (commit commit)))
9615          (file-name (git-file-name name version))
9616          (sha256
9617           (base32
9618            "1kwix4si8a8hza34ab2k7whrh7z0yrmx39v2wc3qblv9m244jkh1"))))
9619       (build-system asdf-build-system/sbcl)
9620       (inputs
9621        `(("alexandria" ,sbcl-alexandria)
9622          ("cffi" ,sbcl-cffi)
9623          ("cffi-grovel" ,sbcl-cffi-grovel)
9624          ("libuv" ,libuv)))
9625       (arguments
9626        `(#:phases
9627          (modify-phases %standard-phases
9628            (add-after 'unpack 'fix-paths
9629              (lambda* (#:key inputs #:allow-other-keys)
9630                (substitute* "lib.lisp"
9631                  (("/usr/lib/libuv.so")
9632                   (string-append (assoc-ref inputs "libuv")
9633                                  "/lib/libuv.so")))
9634                #t))
9635            (add-after 'fix-paths 'fix-system-definition
9636              (lambda _
9637                (substitute* "cl-libuv.asd"
9638                  (("#:cffi #:alexandria")
9639                   "#:cffi #:cffi-grovel #:alexandria"))
9640                #t)))))
9641       (synopsis "Common Lisp bindings to libuv")
9642       (description
9643        "This library provides low-level libuv bindings for Common Lisp.")
9644       (home-page "https://github.com/orthecreedence/cl-libuv")
9645       (license license:expat))))
9646
9647 (define-public cl-libuv
9648   (sbcl-package->cl-source-package sbcl-cl-libuv))
9649
9650 (define-public ecl-cl-libuv
9651   (sbcl-package->ecl-package sbcl-cl-libuv))
9652
9653 (define-public sbcl-cl-async-base
9654   (let ((commit "f6423e44404a44434d803605e0d2e17199158e28")
9655         (revision "1"))
9656     (package
9657       (name "sbcl-cl-async-base")
9658       (version (git-version "0.6.1" revision commit))
9659       (source
9660        (origin
9661          (method git-fetch)
9662          (uri (git-reference
9663                (url "https://github.com/orthecreedence/cl-async.git")
9664                (commit commit)))
9665          (file-name (git-file-name name version))
9666          (sha256
9667           (base32
9668            "11xi9dxb8mjgwzrkj88i0xkgk26z9w9ddxzbv6xsvfc1d4x5cf4x"))))
9669       (build-system asdf-build-system/sbcl)
9670       (inputs
9671        `(("bordeaux-threads" ,sbcl-bordeaux-threads)
9672          ("cffi" ,sbcl-cffi)
9673          ("cl-libuv" ,sbcl-cl-libuv)))
9674       (arguments
9675        `(#:asd-file "cl-async.asd"))
9676       (synopsis "Base system for cl-async")
9677       (description
9678        "Cl-async is a library for general purpose, non-blocking programming in
9679 Common Lisp.  It uses the libuv library as backend.")
9680       (home-page "https://orthecreedence.github.io/cl-async/")
9681       (license license:expat))))
9682
9683 (define-public cl-async-base
9684   (sbcl-package->cl-source-package sbcl-cl-async-base))
9685
9686 (define-public ecl-cl-async-base
9687   (sbcl-package->ecl-package sbcl-cl-async-base))
9688
9689 (define-public sbcl-cl-async-util
9690   (package
9691     (inherit sbcl-cl-async-base)
9692     (name "sbcl-cl-async-util")
9693     (inputs
9694      `(("bordeaux-threads" ,sbcl-bordeaux-threads)
9695        ("cffi" ,sbcl-cffi)
9696        ("cl-async-base" ,sbcl-cl-async-base)
9697        ("cl-libuv" ,sbcl-cl-libuv)
9698        ("cl-ppcre" ,sbcl-cl-ppcre)
9699        ("fast-io" ,sbcl-fast-io)
9700        ("vom" ,sbcl-vom)))
9701     (synopsis "Internal utilities for cl-async")))
9702
9703 (define-public cl-async-util
9704   (sbcl-package->cl-source-package sbcl-cl-async-util))
9705
9706 (define-public ecl-cl-async-util
9707   (sbcl-package->ecl-package sbcl-cl-async-util))
9708
9709 (define-public sbcl-cl-async
9710   (package
9711     (inherit sbcl-cl-async-base)
9712     (name "sbcl-cl-async")
9713     (inputs
9714      `(("babel" ,sbcl-babel)
9715        ("cffi" ,sbcl-cffi)
9716        ("cl-async-base" ,sbcl-cl-async-base)
9717        ("cl-async-util" ,sbcl-cl-async-util)
9718        ("cl-libuv" ,sbcl-cl-libuv)
9719        ("cl-ppcre" ,sbcl-cl-ppcre)
9720        ("static-vectors" ,sbcl-static-vectors)
9721        ("trivial-features" ,sbcl-trivial-features)
9722        ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
9723     (synopsis "Asynchronous operations for Common Lisp")))
9724
9725 (define-public cl-async
9726   (sbcl-package->cl-source-package sbcl-cl-async))
9727
9728 (define-public ecl-cl-async
9729   (sbcl-package->ecl-package sbcl-cl-async))
9730
9731 (define-public sbcl-cl-async-repl
9732   (package
9733     (inherit sbcl-cl-async-base)
9734     (name "sbcl-cl-async-repl")
9735     (inputs
9736      `(("bordeaux-threads" ,sbcl-bordeaux-threads)
9737        ("cl-async" ,sbcl-cl-async)))
9738     (arguments
9739      (substitute-keyword-arguments (package-arguments sbcl-cl-async-base)
9740        ((#:asd-file _ "") "cl-async-repl.asd")))
9741     (synopsis "REPL integration for cl-async")))
9742
9743 (define-public cl-async-repl
9744   (sbcl-package->cl-source-package sbcl-cl-async-repl))
9745
9746 (define-public ecl-cl-async-repl
9747   (sbcl-package->ecl-package sbcl-cl-async-repl))
9748
9749 (define-public sbcl-cl-async-ssl
9750   (package
9751     (inherit sbcl-cl-async-base)
9752     (name "sbcl-cl-async-ssl")
9753     (inputs
9754      `(("cffi" ,sbcl-cffi)
9755        ("cl-async" ,sbcl-cl-async)
9756        ("openssl" ,openssl)
9757        ("vom" ,sbcl-vom)))
9758     (arguments
9759      (substitute-keyword-arguments (package-arguments sbcl-cl-async-base)
9760        ((#:asd-file _ "") "cl-async-ssl.asd")
9761        ((#:phases phases '%standard-phases)
9762         `(modify-phases ,phases
9763            (add-after 'unpack 'fix-paths
9764              (lambda* (#:key inputs #:allow-other-keys)
9765                (substitute* "src/ssl/package.lisp"
9766                  (("libcrypto\\.so")
9767                   (string-append (assoc-ref inputs "openssl")
9768                                  "/lib/libcrypto.so"))
9769                  (("libssl\\.so")
9770                   (string-append (assoc-ref inputs "openssl")
9771                                  "/lib/libssl.so")))
9772                #t))))))
9773     (synopsis "SSL wrapper around cl-async socket implementation")))
9774
9775 (define-public cl-async-ssl
9776   (sbcl-package->cl-source-package sbcl-cl-async-ssl))
9777
9778 (define-public ecl-cl-async-ssl
9779   (sbcl-package->ecl-package sbcl-cl-async-ssl))
9780
9781 (define-public sbcl-blackbird
9782   (let ((commit "d361f81c1411dec07f6c2dcb11c78f7aea9aaca8")
9783         (revision "1"))
9784     (package
9785       (name "sbcl-blackbird")
9786       (version (git-version "0.5.2" revision commit))
9787       (source
9788        (origin
9789          (method git-fetch)
9790          (uri (git-reference
9791                (url "https://github.com/orthecreedence/blackbird.git")
9792                (commit commit)))
9793          (file-name (git-file-name name version))
9794          (sha256
9795           (base32
9796            "0xfds5yaya64arzr7w1x38karyz11swzbhxx1afldpradj9dh19c"))))
9797       (build-system asdf-build-system/sbcl)
9798       (inputs
9799        `(("vom" ,sbcl-vom)))
9800       (native-inputs
9801        `(("cl-async" ,sbcl-cl-async)
9802          ("fiveam" ,sbcl-fiveam)))
9803       (synopsis "Promise implementation for Common Lisp")
9804       (description
9805        "This is a standalone promise implementation for Common Lisp.  It is
9806 the successor to the now-deprecated cl-async-future project.")
9807       (home-page "https://orthecreedence.github.io/blackbird/")
9808       (license license:expat))))
9809
9810 (define-public cl-blackbird
9811   (sbcl-package->cl-source-package sbcl-blackbird))
9812
9813 (define-public ecl-blackbird
9814   (sbcl-package->ecl-package sbcl-blackbird))
9815
9816 (define-public sbcl-cl-async-future
9817   (let ((commit "ee36c22a69a9516407458d2ed8b475f1fc473959")
9818         (revision "1"))
9819     (package
9820       (name "sbcl-cl-async-future")
9821       (version (git-version "0.4.4.1" revision commit))
9822       (source
9823        (origin
9824          (method git-fetch)
9825          (uri (git-reference
9826                (url "https://github.com/orthecreedence/cl-async-future.git")
9827                (commit commit)))
9828          (file-name (git-file-name name version))
9829          (sha256
9830           (base32
9831            "0z0sc7qlzzxk99f4l26zp6rai9kv0kj0f599sxai5s44p17zbbvh"))))
9832       (build-system asdf-build-system/sbcl)
9833       (inputs
9834        `(("blackbird" ,sbcl-blackbird)))
9835       (native-inputs
9836        `(("cl-async" ,sbcl-cl-async)
9837          ("eos" ,sbcl-eos)))
9838       (synopsis "Futures implementation for Common Lisp")
9839       (description
9840        "This is futures implementation for Common Lisp.  It plugs in nicely
9841 to cl-async.")
9842       (home-page "https://orthecreedence.github.io/cl-async/future")
9843       (license license:expat))))
9844
9845 (define-public cl-async-future
9846   (sbcl-package->cl-source-package sbcl-cl-async-future))
9847
9848 (define-public ecl-cl-async-future
9849   (sbcl-package->ecl-package sbcl-cl-async-future))
9850
9851 (define-public sbcl-green-threads
9852   (let ((commit "fff5ebecb441a37e5c511773716aafd84a3c5840")
9853         (revision "1"))
9854     (package
9855       (name "sbcl-green-threads")
9856       (version (git-version "0.3" revision commit))
9857       (source
9858        (origin
9859          (method git-fetch)
9860          (uri (git-reference
9861                (url "https://github.com/thezerobit/green-threads.git")
9862                (commit commit)))
9863          (file-name (git-file-name name version))
9864          (sha256
9865           (base32
9866            "1czw7nr0dwfps76h8hjvglk1wdh53yqbfbvv30whwbgqx33iippz"))))
9867       (build-system asdf-build-system/sbcl)
9868       (inputs
9869        `(("cl-async-future" ,sbcl-cl-async-future)
9870          ("cl-cont" ,sbcl-cl-cont)))
9871       (native-inputs
9872        `(("prove" ,sbcl-prove)))
9873       (arguments
9874        `(;; TODO: Fix the tests. They fail with:
9875          ;; "The function BLACKBIRD::PROMISE-VALUES is undefined"
9876          #:tests? #f
9877          #:phases
9878          (modify-phases %standard-phases
9879            (add-after 'unpack 'fix-tests
9880              (lambda _
9881                (substitute* "green-threads-test.asd"
9882                  (("cl-test-more")
9883                   "prove"))
9884                #t)))))
9885       (synopsis "Cooperative multitasking library for Common Lisp")
9886       (description
9887        "This library allows for cooperative multitasking with help of cl-cont
9888 for continuations.  It tries to mimic the API of bordeaux-threads as much as
9889 possible.")
9890       (home-page "https://github.com/thezerobit/green-threads")
9891       (license license:bsd-3))))
9892
9893 (define-public cl-green-threads
9894   (sbcl-package->cl-source-package sbcl-green-threads))
9895
9896 (define-public ecl-green-threads
9897   (sbcl-package->ecl-package sbcl-green-threads))
9898
9899 (define-public sbcl-cl-base32
9900   (let ((commit "8cdee06fab397f7b0a19583b57e7f0c98405be85")
9901         (revision "1"))
9902     (package
9903       (name "sbcl-cl-base32")
9904       (version (git-version "0.1" revision commit))
9905       (source
9906        (origin
9907          (method git-fetch)
9908          (uri (git-reference
9909                (url "https://github.com/hargettp/cl-base32.git")
9910                (commit commit)))
9911          (file-name (git-file-name name version))
9912          (sha256
9913           (base32 "17jrng8jb05d64ggyd11hp308c2fl5drvf9g175blgrkkl8l4mf8"))))
9914       (build-system asdf-build-system/sbcl)
9915       (native-inputs
9916        `(("lisp-unit" ,sbcl-lisp-unit)))
9917       (synopsis "Common Lisp library for base32 encoding and decoding")
9918       (description
9919        "This package provides functions for base32 encoding and decoding as
9920 defined in RFC4648.")
9921       (home-page "https://github.com/hargettp/cl-base32")
9922       (license license:expat))))
9923
9924 (define-public cl-base32
9925   (sbcl-package->cl-source-package sbcl-cl-base32))
9926
9927 (define-public ecl-cl-base32
9928   (sbcl-package->ecl-package sbcl-cl-base32))
9929
9930 (define-public sbcl-cl-z85
9931   (let ((commit "85b3951a9cfa2603acb6aee15567684f9a108098")
9932         (revision "1"))
9933     (package
9934       (name "sbcl-cl-z85")
9935       (version (git-version "1.0" revision commit))
9936       (source
9937        (origin
9938          (method git-fetch)
9939          (uri (git-reference
9940                (url "https://github.com/glv2/cl-z85.git")
9941                (commit commit)))
9942          (file-name (git-file-name name version))
9943          (sha256
9944           (base32 "0r27pidjaxbm7k1rr90nnajwl5xm2kp65g1fv0fva17lzy45z1mp"))))
9945       (build-system asdf-build-system/sbcl)
9946       (native-inputs
9947        `(("cl-octet-streams" ,sbcl-cl-octet-streams)
9948          ("fiveam" ,sbcl-fiveam)))
9949       (synopsis "Common Lisp library for Z85 encoding and decoding")
9950       (description
9951        "This package provides functions to encode or decode byte vectors or
9952 byte streams using the Z85 format, which is a base-85 encoding used by
9953 ZeroMQ.")
9954       (home-page "https://github.com/glv2/cl-z85")
9955       (license license:gpl3+))))
9956
9957 (define-public cl-z85
9958   (sbcl-package->cl-source-package sbcl-cl-z85))
9959
9960 (define-public ecl-cl-z85
9961   (sbcl-package->ecl-package sbcl-cl-z85))
9962
9963 (define-public sbcl-ltk
9964   (package
9965     (name "sbcl-ltk")
9966     (version "0.992")
9967     (source
9968      (origin
9969        (method git-fetch)
9970        (uri (git-reference
9971              (url "https://github.com/herth/ltk.git")
9972              (commit version)))
9973        (file-name (git-file-name name version))
9974        (sha256
9975         (base32 "13l2q4mskzilya9xh5wy2xvy30lwn104bd8wrq6ifds56r82iy3x"))))
9976     (build-system asdf-build-system/sbcl)
9977     (inputs
9978      `(("imagemagick" ,imagemagick)
9979        ("tk" ,tk)))
9980     (arguments
9981      `(#:asd-file "ltk/ltk.asd"
9982        #:tests? #f
9983        #:phases (modify-phases %standard-phases
9984                   (add-after 'unpack 'fix-paths
9985                     (lambda* (#:key inputs #:allow-other-keys)
9986                       (substitute* "ltk/ltk.lisp"
9987                         (("#-freebsd \"wish\"")
9988                          (string-append "#-freebsd \""
9989                                         (assoc-ref inputs "tk")
9990                                         "/bin/wish\""))
9991                         (("do-execute \"convert\"")
9992                          (string-append "do-execute \""
9993                                         (assoc-ref inputs "imagemagick")
9994                                         "/bin/convert\"")))
9995                       #t)))))
9996     (synopsis "Common Lisp bindings for the Tk GUI toolkit")
9997     (description
9998      "LTK is a Common Lisp binding for the Tk graphics toolkit.  It is written
9999 in pure Common Lisp and does not require any Tk knowledge for its usage.")
10000     (home-page "http://www.peter-herth.de/ltk/")
10001     (license license:llgpl)))
10002
10003 (define-public cl-ltk
10004   (sbcl-package->cl-source-package sbcl-ltk))
10005
10006 (define-public ecl-ltk
10007   (sbcl-package->ecl-package sbcl-ltk))
10008
10009 (define-public sbcl-ltk-mw
10010   (package
10011     (inherit sbcl-ltk)
10012     (name "sbcl-ltk-mw")
10013     (inputs
10014      `(("ltk" ,sbcl-ltk)))
10015     (arguments
10016      (substitute-keyword-arguments (package-arguments sbcl-ltk)
10017        ((#:asd-file _) "ltk/ltk-mw.asd")
10018        ((#:phases _) '%standard-phases)))
10019     (synopsis "Extra widgets for LTK")
10020     (description
10021      "This is a collection of higher-level widgets built on top of LTK.")))
10022
10023 (define-public cl-ltk-mw
10024   (sbcl-package->cl-source-package sbcl-ltk-mw))
10025
10026 (define-public ecl-ltk-mw
10027   (sbcl-package->ecl-package sbcl-ltk-mw))
10028
10029 (define-public sbcl-ltk-remote
10030   (package
10031     (inherit sbcl-ltk)
10032     (name "sbcl-ltk-remote")
10033     (inputs
10034      `(("ltk" ,sbcl-ltk)))
10035     (arguments
10036      (substitute-keyword-arguments (package-arguments sbcl-ltk)
10037        ((#:asd-file _) "ltk/ltk-remote.asd")
10038        ((#:phases _) '%standard-phases)))
10039     (synopsis "Remote GUI support for LTK")
10040     (description
10041      "This LTK extension allows the GUI to be displayed on a computer different
10042 from the one running the Lisp program by using a TCP connection.")))
10043
10044 (define-public cl-ltk-remote
10045   (sbcl-package->cl-source-package sbcl-ltk-remote))
10046
10047 (define-public sbcl-cl-lex
10048   (let ((commit "f2dbbe25ef553005fb402d9a6203180c3fa1093b")
10049         (revision "1"))
10050     (package
10051       (name "sbcl-cl-lex")
10052       (version (git-version "1.1.3" revision commit))
10053       (source
10054        (origin
10055          (method git-fetch)
10056          (uri (git-reference
10057                (url "https://github.com/djr7C4/cl-lex.git")
10058                (commit commit)))
10059          (file-name (git-file-name name version))
10060          (sha256
10061           (base32 "1kg50f76bfpfxcv4dfivq1n9a0xlsra2ajb0vd68lxwgbidgyc2y"))))
10062       (build-system asdf-build-system/sbcl)
10063       (inputs
10064        `(("cl-ppcre" ,sbcl-cl-ppcre)))
10065       (synopsis "Common Lisp macros for generating lexical analyzers")
10066       (description
10067        "This is a Common Lisp library providing a set of macros for generating
10068 lexical analyzers automatically.  The lexers generated using @code{cl-lex} can
10069 be used with @code{cl-yacc}.")
10070       (home-page "https://github.com/djr7C4/cl-lex")
10071       (license license:gpl3))))
10072
10073 (define-public cl-lex
10074   (sbcl-package->cl-source-package sbcl-cl-lex))
10075
10076 (define-public ecl-cl-lex
10077   (sbcl-package->ecl-package sbcl-cl-lex))
10078
10079 (define-public sbcl-clunit2
10080   (let ((commit "5e28343734eb9b7aee39306a614af92c1062d50b")
10081         (revision "1"))
10082     (package
10083       (name "sbcl-clunit2")
10084       (version (git-version "0.2.4" revision commit))
10085       (source
10086        (origin
10087          (method git-fetch)
10088          (uri (git-reference
10089                (url "https://notabug.org/cage/clunit2.git")
10090                (commit commit)))
10091          (file-name (git-file-name name version))
10092          (sha256
10093           (base32 "1ngiapfki6nm8a555mzhb5p7ch79i3w665za5bmb5j7q34fy80vw"))))
10094       (build-system asdf-build-system/sbcl)
10095       (synopsis "Unit testing framework for Common Lisp")
10096       (description
10097        "CLUnit is a Common Lisp unit testing framework.  It is designed to be
10098 easy to use so that you can quickly start testing.")
10099       (home-page "https://notabug.org/cage/clunit2")
10100       (license license:expat))))
10101
10102 (define-public cl-clunit2
10103   (sbcl-package->cl-source-package sbcl-clunit2))
10104
10105 (define-public ecl-clunit2
10106   (sbcl-package->ecl-package sbcl-clunit2))
10107
10108 (define-public sbcl-cl-colors2
10109   (let ((commit "795aedee593b095fecde574bd999b520dd03ed24")
10110         (revision "1"))
10111     (package
10112       (name "sbcl-cl-colors2")
10113       (version (git-version "0.2.1" revision commit))
10114       (source
10115        (origin
10116          (method git-fetch)
10117          (uri (git-reference
10118                (url "https://notabug.org/cage/cl-colors2.git")
10119                (commit commit)))
10120          (file-name (git-file-name name version))
10121          (sha256
10122           (base32 "0hlyf4h5chkjdp9armla5w4kw5acikk159sym7y8c4jbjp9x47ih"))))
10123       (build-system asdf-build-system/sbcl)
10124       (native-inputs
10125        `(("clunit2" ,sbcl-clunit2)))
10126       (inputs
10127        `(("alexandria" ,sbcl-alexandria)
10128          ("cl-ppcre" ,sbcl-cl-ppcre)))
10129       (synopsis "Color library for Common Lisp")
10130       (description
10131        "This is a very simple color library for Common Lisp, providing:
10132
10133 @itemize
10134 @item Types for representing colors in HSV and RGB spaces.
10135 @item Simple conversion functions between the above types (and also
10136 hexadecimal representation for RGB).
10137 @item Some predefined colors (currently X11 color names -- of course
10138 the library does not depend on X11).
10139 @end itemize\n")
10140       (home-page "https://notabug.org/cage/cl-colors2")
10141       (license license:boost1.0))))
10142
10143 (define-public cl-colors2
10144   (sbcl-package->cl-source-package sbcl-cl-colors2))
10145
10146 (define-public ecl-cl-colors2
10147   (sbcl-package->ecl-package sbcl-cl-colors2))
10148
10149 (define-public sbcl-cl-jpeg
10150   (let ((commit "ec557038128df6895fbfb743bfe8faf8ec2534af")
10151         (revision "1"))
10152     (package
10153       (name "sbcl-cl-jpeg")
10154       (version (git-version "2.8" revision commit))
10155       (source
10156        (origin
10157          (method git-fetch)
10158          (uri (git-reference
10159                (url "https://github.com/sharplispers/cl-jpeg.git")
10160                (commit commit)))
10161          (file-name (git-file-name name version))
10162          (sha256
10163           (base32 "1bkkiqz8fqldlj1wbmrccjsvxcwj98h6s4b6gslr3cg2wmdv5xmy"))))
10164       (build-system asdf-build-system/sbcl)
10165       (synopsis "JPEG image library for Common Lisp")
10166       (description
10167        "This is a baseline JPEG codec written in Common Lisp.  It can be used
10168 for reading and writing JPEG image files.")
10169       (home-page "https://github.com/sharplispers/cl-jpeg")
10170       (license license:bsd-3))))
10171
10172 (define-public cl-jpeg
10173   (sbcl-package->cl-source-package sbcl-cl-jpeg))
10174
10175 (define-public ecl-cl-jpeg
10176   (sbcl-package->ecl-package sbcl-cl-jpeg))
10177
10178 (define-public sbcl-nodgui
10179   (let ((commit "bc59ed9b787dfc9e68ae3bd7f7e8507c5c619212")
10180         (revision "1"))
10181     (package
10182       (name "sbcl-nodgui")
10183       (version (git-version "0.0.5" revision commit))
10184       (source
10185        (origin
10186          (method git-fetch)
10187          (uri (git-reference
10188                (url "https://notabug.org/cage/nodgui.git")
10189                (commit commit)))
10190          (file-name (git-file-name name version))
10191          (sha256
10192           (base32 "0xx0dk54d882i598ydnwmy7mnfk0b7vib3ddsgpqxhjck1rwq8l8"))))
10193       (build-system asdf-build-system/sbcl)
10194       (inputs
10195        `(("alexandria" ,sbcl-alexandria)
10196          ("bordeaux-threads" ,sbcl-bordeaux-threads)
10197          ("cl-colors2" ,sbcl-cl-colors2)
10198          ("cl-jpeg" ,sbcl-cl-jpeg)
10199          ("cl-lex" ,sbcl-cl-lex)
10200          ("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)
10201          ("cl-unicode" ,sbcl-cl-unicode)
10202          ("cl-yacc" ,sbcl-cl-yacc)
10203          ("clunit2" ,sbcl-clunit2)
10204          ("named-readtables" ,sbcl-named-readtables)
10205          ("parse-number" ,sbcl-parse-number)
10206          ("tk" ,tk)))
10207       (arguments
10208        `(#:phases (modify-phases %standard-phases
10209                     (add-after 'unpack 'fix-paths
10210                       (lambda* (#:key inputs #:allow-other-keys)
10211                         (substitute* "src/wish-communication.lisp"
10212                           (("#-freebsd \"wish\"")
10213                            (string-append "#-freebsd \""
10214                                           (assoc-ref inputs "tk")
10215                                           "/bin/wish\"")))
10216                         #t)))))
10217       (synopsis "Common Lisp bindings for the Tk GUI toolkit")
10218       (description
10219        "Nodgui (@emph{No Drama GUI}) is a Common Lisp binding for the Tk GUI
10220 toolkit.  It also provides a few additional widgets more than the standard Tk
10221 ones.")
10222       (home-page "https://www.autistici.org/interzona/nodgui.html")
10223       (license license:llgpl))))
10224
10225 (define-public cl-nodgui
10226   (sbcl-package->cl-source-package sbcl-nodgui))
10227
10228 (define-public ecl-nodgui
10229   (sbcl-package->ecl-package sbcl-nodgui))
10230
10231 (define-public sbcl-salza2
10232   (package
10233     (name "sbcl-salza2")
10234     (version "2.0.9")
10235     (source
10236      (origin
10237        (method git-fetch)
10238        (uri (git-reference
10239              (url "https://github.com/xach/salza2.git")
10240              (commit (string-append "release-" version))))
10241        (file-name (git-file-name name version))
10242        (sha256
10243         (base32 "0p38rj4gq7j5k807php7hrz7l2zyyfshv8i9yms7i8lkgg3433ki"))))
10244     (build-system asdf-build-system/sbcl)
10245     (synopsis "Common Lisp library for zlib, deflate and gzip compression")
10246     (description
10247      "Salza2 is a Common Lisp library for creating compressed data in the zlib,
10248 deflate, or gzip data formats, described in RFC 1950, RFC 1951, and RFC 1952,
10249 respectively.")
10250     (home-page "https://www.xach.com/lisp/salza2/")
10251     (license license:bsd-2)))
10252
10253 (define-public cl-salza2
10254   (sbcl-package->cl-source-package sbcl-salza2))
10255
10256 (define-public ecl-salza2
10257   (sbcl-package->ecl-package sbcl-salza2))
10258
10259 (define-public sbcl-png-read
10260   (let ((commit "ec29f38a689972b9f1373f13bbbcd6b05deada88")
10261         (revision "1"))
10262     (package
10263       (name "sbcl-png-read")
10264       (version (git-version "0.3.1" revision commit))
10265       (source
10266        (origin
10267          (method git-fetch)
10268          (uri (git-reference
10269                (url "https://github.com/Ramarren/png-read.git")
10270                (commit commit)))
10271          (file-name (git-file-name name version))
10272          (sha256
10273           (base32 "0vyczbcwskrygrf1hgrsnk0jil8skmvf1kiaalw5jps4fjrfdkw0"))))
10274       (build-system asdf-build-system/sbcl)
10275       (inputs
10276        `(("babel" ,sbcl-babel)
10277          ("chipz" ,sbcl-chipz)
10278          ("iterate" ,sbcl-iterate)))
10279       (synopsis "PNG decoder for Common Lisp")
10280       (description "This is a Common Lisp library for reading PNG images.")
10281       (home-page "https://github.com/Ramarren/png-read")
10282       (license license:bsd-3))))
10283
10284 (define-public cl-png-read
10285   (sbcl-package->cl-source-package sbcl-png-read))
10286
10287 (define-public ecl-png-read
10288   (sbcl-package->ecl-package sbcl-png-read))
10289
10290 (define-public sbcl-zpng
10291   (package
10292     (name "sbcl-zpng")
10293     (version "1.2.2")
10294     (source
10295      (origin
10296        (method git-fetch)
10297        (uri (git-reference
10298              (url "https://github.com/xach/zpng.git")
10299              (commit (string-append "release-" version))))
10300        (file-name (git-file-name name version))
10301        (sha256
10302         (base32 "0b3ag3jhl3z7kdls3ahdsdxsfhhw5qrizk769984f4wkxhb69rcm"))))
10303     (build-system asdf-build-system/sbcl)
10304     (inputs
10305      `(("salza2" ,sbcl-salza2)))
10306     (synopsis "PNG encoder for Common Lisp")
10307     (description "This is a Common Lisp library for creating PNG images.")
10308     (home-page "https://www.xach.com/lisp/zpng/")
10309     (license license:bsd-2)))
10310
10311 (define-public cl-zpng
10312   (sbcl-package->cl-source-package sbcl-zpng))
10313
10314 (define-public ecl-zpng
10315   (sbcl-package->ecl-package sbcl-zpng))
10316
10317 (define-public sbcl-cl-qrencode
10318   (package
10319     (name "sbcl-cl-qrencode")
10320     (version "0.1.2")
10321     (source
10322      (origin
10323        (method git-fetch)
10324        (uri (git-reference
10325              (url "https://github.com/jnjcc/cl-qrencode.git")
10326              (commit (string-append "v" version))))
10327        (file-name (git-file-name name version))
10328        (sha256
10329         (base32 "1l5k131dchbf6cj8a8xqa731790p01p3qa1kdy2wa9dawy3ymkxr"))))
10330     (build-system asdf-build-system/sbcl)
10331     (native-inputs
10332      `(("lisp-unit" ,sbcl-lisp-unit)))
10333     (inputs
10334      `(("zpng" ,sbcl-zpng)))
10335     (synopsis "QR code encoder for Common Lisp")
10336     (description
10337      "This Common Lisp library provides function to make QR codes and to save
10338 them as PNG files.")
10339     (home-page "https://github.com/jnjcc/cl-qrencode")
10340     (license license:gpl2+)))
10341
10342 (define-public cl-qrencode
10343   (sbcl-package->cl-source-package sbcl-cl-qrencode))
10344
10345 (define-public ecl-cl-qrencode
10346   (sbcl-package->ecl-package sbcl-cl-qrencode))
10347
10348 (define-public sbcl-hdf5-cffi
10349   (let ((commit "5b5c88f191e470e4fe96b462334e3ce0806eed5c")
10350         (revision "1"))
10351     (package
10352       (name "sbcl-hdf5-cffi")
10353       (version (git-version "1.8.18" revision commit))
10354       (source
10355        (origin
10356          (method git-fetch)
10357          (uri (git-reference
10358                (url "https://github.com/hdfgroup/hdf5-cffi.git")
10359                (commit commit)))
10360          (file-name (git-file-name name version))
10361          (sha256
10362           (base32
10363            "0vda3075423xz83qky998lpac5b04dwfv7bwgh9jq8cs5v0zrxjf"))))
10364       (build-system asdf-build-system/sbcl)
10365       (synopsis "Common Lisp bindings for the HDF5 library")
10366       (description
10367        "@code{hdf5-cffi} is a CFFI wrapper for the HDF5 library.")
10368       (home-page "https://github.com/hdfgroup/hdf5-cffi")
10369       (license (license:non-copyleft
10370                 (string-append "https://github.com/HDFGroup/hdf5-cffi/raw/"
10371                                commit
10372                                "/LICENSE")))
10373       (inputs
10374        `(("cffi" ,sbcl-cffi)
10375          ("cffi-grovel" ,sbcl-cffi-grovel)
10376          ("hdf5" ,hdf5-1.10)))
10377       (native-inputs
10378        `(("fiveam" ,sbcl-fiveam)))
10379       (arguments
10380        `(#:asd-system-name "hdf5-cffi"
10381          #:asd-file "hdf5-cffi.asd"
10382          #:test-asd-file "hdf5-cffi.test.asd"
10383          ;; Tests depend on hdf5-cffi.examples.asd in addition to hdf5-cffi.asd,
10384          ;; I don't know if there is a way to tell asdf-build-system to load
10385          ;; an additional system first, so tests are disabled.
10386          #:tests? #f
10387          #:phases
10388          (modify-phases %standard-phases
10389            (add-after 'unpack 'fix-paths
10390              (lambda* (#:key inputs #:allow-other-keys)
10391                (substitute* "src/library.lisp"
10392                  (("libhdf5.so")
10393                   (string-append
10394                    (assoc-ref inputs "hdf5")
10395                    "/lib/libhdf5.so")))))
10396            (add-after 'unpack 'fix-dependencies
10397              (lambda* (#:key inputs #:allow-other-keys)
10398                (substitute* "hdf5-cffi.asd"
10399                  ((":depends-on \\(:cffi\\)")
10400                   ":depends-on (:cffi :cffi-grovel)"))
10401                (substitute* "hdf5-cffi.test.asd"
10402                  ((":depends-on \\(:cffi :hdf5-cffi")
10403                   ":depends-on (:cffi :cffi-grovel :hdf5-cffi"))))))))))
10404
10405 (define-public cl-hdf5-cffi
10406   (sbcl-package->cl-source-package sbcl-hdf5-cffi))
10407
10408 (define-public ecl-hdf5-cffi
10409   (sbcl-package->ecl-package sbcl-hdf5-cffi))
10410
10411 (define-public sbcl-cl-randist
10412   (package
10413     (name "sbcl-cl-randist")
10414     (version "0.4.2")
10415     (source
10416      (origin
10417        (method git-fetch)
10418        (uri (git-reference
10419              (url "https://github.com/lvaruzza/cl-randist.git")
10420              (commit "f088a54b540a7adefab7c04094a6103f9edda3d0")))
10421        (file-name (git-file-name name version))
10422        (sha256
10423         (base32
10424          "0l8hyd6nbxb7f50vyxz3rbbm7kgr1fnadc40jywy4xj5vi5kpj5g"))))
10425     (build-system asdf-build-system/sbcl)
10426     (synopsis "Random distributions for Common Lisp")
10427     (description
10428      "Manual translation from C to Common Lisp of some random number
10429 generation functions from the GSL library.")
10430     (home-page "https://github.com/lvaruzza/cl-randist")
10431     (license license:bsd-2)
10432     (arguments
10433      `(#:asd-system-name "cl-randist"
10434        #:asd-file "cl-randist.asd"
10435        #:tests? #f))))
10436
10437 (define-public cl-randist
10438   (sbcl-package->cl-source-package sbcl-cl-randist))
10439
10440 (define-public ecl-cl-randist
10441   (sbcl-package->ecl-package sbcl-cl-randist))
10442
10443 (define-public sbcl-float-features
10444   (package
10445     (name "sbcl-float-features")
10446     (version "1.0.0")
10447     (source
10448      (origin
10449        (method git-fetch)
10450        (uri (git-reference
10451              (url "https://github.com/Shinmera/float-features.git")
10452              (commit "d3ef60181635b0849aa28cfc238053b7ca4644b0")))
10453        (file-name (git-file-name name version))
10454        (sha256
10455         (base32
10456          "0yj419k7n59x6rh3grwr6frgwwyria2il6f7wxpfazm8cskv4lzr"))))
10457     (build-system asdf-build-system/sbcl)
10458     (synopsis "Common Lisp IEEE float portability library")
10459     (description
10460      "Portability library for IEEE float features that are not
10461 covered by the Common Lisp standard.")
10462     (home-page "https://github.com/Shinmera/float-features")
10463     (license license:zlib)
10464     (inputs
10465      `(("documentation-utils" ,sbcl-documentation-utils)))
10466     (arguments
10467      `(#:asd-system-name "float-features"
10468        #:asd-file "float-features.asd"
10469        #:tests? #f))))
10470
10471 (define-public cl-float-features
10472   (sbcl-package->cl-source-package sbcl-float-features))
10473
10474 (define-public ecl-float-features
10475   (sbcl-package->ecl-package sbcl-float-features))
10476
10477 (define-public sbcl-function-cache
10478   (package
10479     (name "sbcl-function-cache")
10480     (version "1.0.3")
10481     (source
10482      (origin
10483        (method git-fetch)
10484        (uri (git-reference
10485              (url "https://github.com/AccelerationNet/function-cache.git")
10486              (commit "6a5ada401e57da2c8abf046f582029926e61fce8")))
10487        (file-name (git-file-name name version))
10488        (sha256
10489         (base32
10490          "000vmd3f5rx5hs9nvphfric0gkzaadns31c6mxaslpv0k7pkrmc6"))))
10491     (build-system asdf-build-system/sbcl)
10492     (synopsis "Function caching / memoization library for Common Lisp")
10493     (description
10494      "A common lisp library that provides extensible function result
10495 caching based on arguments (an expanded form of memoization).")
10496     (home-page "https://github.com/AccelerationNet/function-cache")
10497     (license
10498      (license:non-copyleft
10499       "https://github.com/AccelerationNet/function-cache/blob/master/README.md"))
10500     (inputs
10501      `(("alexandria" ,sbcl-alexandria)
10502        ("cl-interpol" ,sbcl-cl-interpol)
10503        ("iterate" ,sbcl-iterate)
10504        ("symbol-munger" ,sbcl-symbol-munger)
10505        ("closer-mop" ,sbcl-closer-mop)))
10506     (arguments
10507      `(#:asd-system-name "function-cache"
10508        #:asd-file "function-cache.asd"
10509        #:tests? #f))))
10510
10511 (define-public cl-function-cache
10512   (sbcl-package->cl-source-package sbcl-function-cache))
10513
10514 (define-public ecl-function-cache
10515   (sbcl-package->ecl-package sbcl-function-cache))
10516
10517 (define-public sbcl-type-r
10518   (let ((commit "83c89e38f2f7a7b16f1012777ecaf878cfa6a267")
10519         (revision "1"))
10520     (package
10521       (name "sbcl-type-r")
10522       (version (git-version "0.0.0" revision commit))
10523       (source
10524        (origin
10525          (method git-fetch)
10526          (uri (git-reference
10527                (url "https://github.com/guicho271828/type-r.git")
10528                (commit commit)))
10529          (file-name (git-file-name name version))
10530          (sha256
10531           (base32
10532            "1arsxc2539rg8vbrdirz4xxj1b06mc6g6rqndz7a02g127qvk2sm"))))
10533       (build-system asdf-build-system/sbcl)
10534       (synopsis "Parser interface for Common Lisp built-in compound types")
10535       (description
10536        "Collections of accessor functions and patterns to access
10537 the elements in compound type specifier, e.g. @code{dimensions} in
10538 @code{(array element-type dimensions)}")
10539       (home-page "https://github.com/guicho271828/type-r")
10540       (license license:lgpl3+)
10541       (inputs
10542        `(("trivia" ,sbcl-trivia)
10543          ("alexandria" ,sbcl-alexandria)))
10544       (native-inputs
10545        `(("fiveam" ,sbcl-fiveam)))
10546       (arguments
10547        `(#:asd-system-name "type-r"
10548          #:asd-file "type-r.asd"
10549          #:test-asd-file "type-r.test.asd")))))
10550
10551 (define-public cl-type-r
10552   (sbcl-package->cl-source-package sbcl-type-r))
10553
10554 (define-public sbcl-trivialib-type-unify
10555   (let ((commit "62492ebf04db567dcf435ae84c50b7b8202ecf99")
10556         (revision "1"))
10557     (package
10558       (name "sbcl-trivialib-type-unify")
10559       (version (git-version "0.1" revision commit))
10560       (source
10561        (origin
10562          (method git-fetch)
10563          (uri (git-reference
10564                (url "https://github.com/guicho271828/trivialib.type-unify.git")
10565                (commit commit)))
10566          (file-name (git-file-name name version))
10567          (sha256
10568           (base32
10569            "1bkyfzbwv75p50zp8n1n9rh2r29pw3vgz91gmn2gzzkyq3khj1vh"))))
10570       (build-system asdf-build-system/sbcl)
10571       (synopsis "Common Lisp type unification")
10572       (description
10573        "Unifies a parametrized type specifier against an actual type specifier.
10574 Importantly, it handles complicated array-subtypes and number-related types
10575 correctly.")
10576       (home-page "https://github.com/guicho271828/trivialib.type-unify")
10577       (license license:lgpl3+)
10578       (inputs
10579        `(("alexandria" ,sbcl-alexandria)
10580          ("trivia" ,sbcl-trivia)
10581          ("introspect-environment" ,sbcl-introspect-environment)
10582          ("type-r" ,sbcl-type-r)))
10583       (native-inputs
10584        `(("fiveam" ,sbcl-fiveam)))
10585       (arguments
10586        `(#:asd-system-name "trivialib.type-unify"
10587          #:asd-file "trivialib.type-unify.asd"
10588          #:test-asd-file "trivialib.type-unify.test.asd")))))
10589
10590 (define-public cl-trivialib-type-unify
10591   (sbcl-package->cl-source-package sbcl-trivialib-type-unify))
10592
10593 (define-public sbcl-specialized-function
10594   (let ((commit "b96b6afaf8358bf91cc0703e62a5a4ee20d2b7bc")
10595         (revision "1"))
10596     (package
10597       (name "sbcl-specialized-function")
10598       (version (git-version "0.0.0" revision commit))
10599       (source
10600        (origin
10601          (method git-fetch)
10602          (uri (git-reference
10603                (url "https://github.com/numcl/specialized-function.git")
10604                (commit commit)))
10605          (file-name (git-file-name name version))
10606          (sha256
10607           (base32
10608            "12j45ff0n26578vmfbhb9mfbdchw4wy023k0m2ppgl9s0z4bhjaj"))))
10609       (build-system asdf-build-system/sbcl)
10610       (synopsis "Julia-like dispatch for Common Lisp")
10611       (description
10612        "This library is part of NUMCL.  It provides a macro
10613 @code{SPECIALIZED} that performs a Julia-like dispatch on the arguments,
10614 lazily compiling a type-specific version of the function from the same
10615 code.  The main target of this macro is speed.")
10616       (home-page "https://github.com/numcl/specialized-function")
10617       (license license:lgpl3+)
10618       (inputs
10619        `(("trivia" ,sbcl-trivia)
10620          ("alexandria" ,sbcl-alexandria)
10621          ("iterate" ,sbcl-iterate)
10622          ("lisp-namespace" ,sbcl-lisp-namespace)
10623          ("type-r" ,sbcl-type-r)
10624          ("trivial-cltl2" ,sbcl-trivial-cltl2)))
10625       (native-inputs
10626        `(("fiveam" ,sbcl-fiveam)))
10627       (arguments
10628        `(#:asd-system-name "specialized-function"
10629          #:asd-file "specialized-function.asd"
10630          #:test-asd-file "specialized-function.test.asd")))))
10631
10632 (define-public cl-specialized-function
10633   (sbcl-package->cl-source-package sbcl-specialized-function))
10634
10635 (define-public sbcl-constantfold
10636   (let ((commit "0ff1d97a3fbcb89264f6a2af6ce62b73e7b421f4")
10637         (revision "1"))
10638     (package
10639       (name "sbcl-constantfold")
10640       (version (git-version "0.1" revision commit))
10641       (source
10642        (origin
10643          (method git-fetch)
10644          (uri (git-reference
10645                (url "https://github.com/numcl/constantfold.git")
10646                (commit commit)))
10647          (file-name (git-file-name name version))
10648          (sha256
10649           (base32
10650            "153h0569z6bff1qbad0bdssplwwny75l7ilqwcfqfdvzsxf9jh06"))))
10651       (build-system asdf-build-system/sbcl)
10652       (synopsis "Support library for numcl")
10653       (description
10654        "Support library for numcl.  Registers a function as an
10655 additional form that is considered as a candidate for a constant.")
10656       (home-page "https://github.com/numcl/constantfold")
10657       (license license:lgpl3+)
10658       (inputs
10659        `(("trivia" ,sbcl-trivia)
10660          ("alexandria" ,sbcl-alexandria)
10661          ("iterate" ,sbcl-iterate)
10662          ("lisp-namespace" ,sbcl-lisp-namespace)))
10663       (native-inputs
10664        `(("fiveam" ,sbcl-fiveam)))
10665       (arguments
10666        `(#:asd-system-name "constantfold"
10667          #:asd-file "constantfold.asd"
10668          #:test-asd-file "constantfold.test.asd")))))
10669
10670 (define-public cl-constantfold
10671   (sbcl-package->cl-source-package sbcl-constantfold))
10672
10673 (define-public sbcl-gtype
10674   (let ((commit "42275e3606242ae91e9c8dfa30c18ced50a35b66")
10675         (revision "1"))
10676     (package
10677       (name "sbcl-gtype")
10678       (version (git-version "0.1" revision commit))
10679       (source
10680        (origin
10681          (method git-fetch)
10682          (uri (git-reference
10683                (url "https://github.com/numcl/gtype.git")
10684                (commit commit)))
10685          (file-name (git-file-name name version))
10686          (sha256
10687           (base32
10688            "1f56dba998v945jcxhha391557n6md1ql25b7icfwwfivhmlaa9b"))))
10689       (build-system asdf-build-system/sbcl)
10690       (synopsis "C++/Julia-like parametric types in Common Lisp")
10691       (description
10692        "Support library for numcl that provides Julia-like runtime parametric
10693 type correctness in Common Lisp.  It is based on CLtL2 extensions.")
10694       (home-page "https://github.com/numcl/gtype")
10695       (license license:lgpl3+)
10696       (inputs
10697        `(("trivialib.type-unify" ,sbcl-trivialib-type-unify)
10698          ("trivial-cltl2" ,sbcl-trivial-cltl2)
10699          ("trivia" ,sbcl-trivia)
10700          ("alexandria" ,sbcl-alexandria)
10701          ("iterate" ,sbcl-iterate)
10702          ("type-r" ,sbcl-type-r)))
10703       (native-inputs
10704        `(("fiveam" ,sbcl-fiveam)))
10705       (arguments
10706        `(#:asd-system-name "gtype"
10707          #:asd-file "gtype.asd"
10708          #:test-asd-file "gtype.test.asd")))))
10709
10710 (define-public cl-gtype
10711   (sbcl-package->cl-source-package sbcl-gtype))
10712
10713 (define-public sbcl-numcl
10714   (let ((commit "1cf7dfa59f763a24a501092870e9c5ee745d0c17")
10715         (revision "1"))
10716     (package
10717       (name "sbcl-numcl")
10718       (version (git-version "0.1.0" revision commit))
10719       (source
10720        (origin
10721          (method git-fetch)
10722          (uri (git-reference
10723                (url "https://github.com/numcl/numcl.git")
10724                (commit commit)))
10725          (file-name (git-file-name name version))
10726          (sha256
10727           (base32
10728            "0i3jby9hf4ii7blivgyza80g0vmjfhk8537i5i7kqqk0i5sdnym2"))))
10729       (build-system asdf-build-system/sbcl)
10730       (synopsis "Numpy clone in Common Lisp")
10731       (description
10732        "This is a Numpy clone in Common Lisp.  At the moment the
10733 library is written in pure Common Lisp, focusing more on correctness
10734 and usefulness, not speed.  Track the progress at
10735 @url{https://github.com/numcl/numcl/projects/1}.")
10736       (home-page "https://github.com/numcl/numcl")
10737       (license license:lgpl3+)
10738       (inputs
10739        `(("trivia" ,sbcl-trivia)
10740          ("alexandria" ,sbcl-alexandria)
10741          ("iterate" ,sbcl-iterate)
10742          ("lisp-namespace" ,sbcl-lisp-namespace)
10743          ("type-r" ,sbcl-type-r)
10744          ("constantfold" ,sbcl-constantfold)
10745          ("cl-randist" ,sbcl-cl-randist)
10746          ("float-features" ,sbcl-float-features)
10747          ("function-cache" ,sbcl-function-cache)
10748          ("specialized-function" ,sbcl-specialized-function)
10749          ("gtype" ,sbcl-gtype)))
10750       (native-inputs
10751        `(("fiveam" ,sbcl-fiveam)))
10752       (arguments
10753        `(#:asd-system-name "numcl"
10754          #:asd-file "numcl.asd"
10755          #:test-asd-file "numcl.test.asd")))))
10756
10757 (define-public cl-numcl
10758   (sbcl-package->cl-source-package sbcl-numcl))
10759
10760 (define-public sbcl-pzmq
10761   (let ((commit "7c7390eedc469d033c72dc497984d1536ee75826")
10762         (revision "1"))
10763     (package
10764       (name "sbcl-pzmq")
10765       (version (git-version "0.0.0" revision commit))
10766       (source
10767        (origin
10768          (method git-fetch)
10769          (uri (git-reference
10770                (url "https://github.com/orivej/pzmq.git")
10771                (commit commit)))
10772          (file-name (git-file-name name version))
10773          (sha256
10774           (base32 "0gmwzf7h90wa7v4wnk49g0hv2mdalljpwhyigxcb967wzv8lqci9"))))
10775       (build-system asdf-build-system/sbcl)
10776       (native-inputs
10777        `(("bordeaux-threads" ,sbcl-bordeaux-threads)
10778          ("fiveam" ,sbcl-fiveam)
10779          ("let-plus" ,sbcl-let-plus)))
10780       (inputs
10781        `(("cffi" ,sbcl-cffi)
10782          ("cffi-grovel" ,sbcl-cffi-grovel)
10783          ("zeromq" ,zeromq)))
10784       (arguments
10785        `(#:phases (modify-phases %standard-phases
10786                     (add-after 'unpack 'fix-paths
10787                       (lambda* (#:key inputs #:allow-other-keys)
10788                         (substitute* "c-api.lisp"
10789                           (("\"libzmq")
10790                            (string-append "\""
10791                                           (assoc-ref inputs "zeromq")
10792                                           "/lib/libzmq")))
10793                         #t)))))
10794       (synopsis "Common Lisp bindings for the ZeroMQ library")
10795       (description "This Common Lisp library provides bindings for the ZeroMQ
10796 lightweight messaging kernel.")
10797       (home-page "https://github.com/orivej/pzmq")
10798       (license license:unlicense))))
10799
10800 (define-public cl-pzmq
10801   (sbcl-package->cl-source-package sbcl-pzmq))
10802
10803 (define-public ecl-pzmq
10804   (sbcl-package->ecl-package sbcl-pzmq))
10805
10806 (define-public sbcl-clss
10807   (let ((revision "1")
10808         (commit "2a8e8615ab55870d4ca01928f3ed3bbeb4e75c8d"))
10809     (package
10810       (name "sbcl-clss")
10811       (version (git-version "0.3.1" revision commit))
10812       (source
10813        (origin
10814          (method git-fetch)
10815          (uri
10816           (git-reference
10817            (url "https://github.com/Shinmera/clss.git")
10818            (commit commit)))
10819          (sha256
10820           (base32 "0la4dbcda78x29szanylccrsljqrn9d1mhh569sqkyp44ni5fv91"))
10821          (file-name (git-file-name name version))))
10822       (inputs
10823        `(("array-utils" ,sbcl-array-utils)
10824          ("plump" ,sbcl-plump)))
10825       (build-system asdf-build-system/sbcl)
10826       (synopsis "DOM tree searching engine based on CSS selectors")
10827       (description "CLSS is a DOM traversal engine based on CSS
10828 selectors.  It makes use of the Plump-DOM and is used by lQuery.")
10829       (home-page "https://github.com/Shinmera/clss")
10830       (license license:zlib))))
10831
10832 (define-public cl-clss
10833   (sbcl-package->cl-source-package sbcl-clss))
10834
10835 (define-public ecl-clss
10836   (sbcl-package->ecl-package sbcl-clss))
10837
10838 (define-public sbcl-lquery
10839   (let ((revision "1")
10840         (commit "8048111c6b83956daa632e7a3ffbd8c9c203bd8d"))
10841     (package
10842       (name "sbcl-lquery")
10843       (version (git-version "3.2.1" revision commit))
10844       (source
10845        (origin
10846          (method git-fetch)
10847          (uri
10848           (git-reference
10849            (url "https://github.com/Shinmera/lquery.git")
10850            (commit commit)))
10851          (sha256
10852           (base32 "0520mcpxc2d6fdm8z61arpgd2z38kan7cf06qs373n5r64rakz6w"))
10853          (file-name (git-file-name name version))))
10854       (native-inputs
10855        `(("fiveam" ,sbcl-fiveam)))
10856       (inputs
10857        `(("array-utils" ,sbcl-array-utils)
10858          ("form-fiddle" ,sbcl-form-fiddle)
10859          ("plump" ,sbcl-plump)
10860          ("clss" ,sbcl-clss)))
10861       (build-system asdf-build-system/sbcl)
10862       (synopsis "Library to allow jQuery-like HTML/DOM manipulation")
10863       (description "@code{lQuery} is a DOM manipulation library written in
10864 Common Lisp, inspired by and based on the jQuery syntax and
10865 functions.  It uses Plump and CLSS as DOM and selector engines.  The
10866 main idea behind lQuery is to provide a simple interface for crawling
10867 and modifying HTML sites, as well as to allow for an alternative
10868 approach to templating.")
10869       (home-page "https://github.com/Shinmera/lquery")
10870       (license license:zlib))))
10871
10872 (define-public cl-lquery
10873   (sbcl-package->cl-source-package sbcl-lquery))
10874
10875 (define-public ecl-lquery
10876   (sbcl-package->ecl-package sbcl-lquery))
10877
10878 (define-public sbcl-cl-mysql
10879   (let ((commit "ab56c279c1815aec6ca0bfe85164ff7e85cfb6f9")
10880         (revision "1"))
10881     (package
10882       (name "sbcl-cl-mysql")
10883       (version (git-version "0.1" revision commit))
10884       (source
10885        (origin
10886          (method git-fetch)
10887          (uri (git-reference
10888                (url "https://github.com/hackinghat/cl-mysql.git")
10889                (commit commit)))
10890          (file-name (git-file-name name version))
10891          (sha256
10892           (base32 "0dg5ynx2ww94d0qfwrdrm7plkn43h64hs4iiq9mj2s1s4ixnp3lr"))))
10893       (build-system asdf-build-system/sbcl)
10894       (native-inputs
10895        `(("stefil" ,sbcl-stefil)))
10896       (inputs
10897        `(("cffi" ,sbcl-cffi)
10898          ("mariadb-lib" ,mariadb "lib")))
10899       (arguments
10900        `(#:tests? #f ; TODO: Tests require a running server
10901          #:phases
10902          (modify-phases %standard-phases
10903            (add-after 'unpack 'fix-paths
10904              (lambda* (#:key inputs #:allow-other-keys)
10905                (substitute* "system.lisp"
10906                  (("libmysqlclient_r" all)
10907                   (string-append (assoc-ref inputs "mariadb-lib")
10908                                  "/lib/"
10909                                  all)))
10910                #t)))))
10911       (synopsis "Common Lisp wrapper for MySQL")
10912       (description
10913        "@code{cl-mysql} is a Common Lisp implementation of a MySQL wrapper.")
10914       (home-page "http://www.hackinghat.com/index.php/cl-mysql")
10915       (license license:expat))))
10916
10917 (define-public cl-mysql
10918   (sbcl-package->cl-source-package sbcl-cl-mysql))
10919
10920 (define-public sbcl-simple-date
10921   (let ((commit "74469b25bbda990ec9b77e0d0eccdba0cd7e721a")
10922         (revision "1"))
10923     (package
10924       (name "sbcl-simple-date")
10925       (version (git-version "1.19" revision commit))
10926       (source
10927        (origin
10928          (method git-fetch)
10929          (uri (git-reference
10930                (url "https://github.com/marijnh/Postmodern.git")
10931                (commit commit)))
10932          (file-name (git-file-name name version))
10933          (sha256
10934           (base32 "0im7ymnyxjhn2w74jfg76k5gpr0gl33n31akx33hl28722ljd0hd"))))
10935       (build-system asdf-build-system/sbcl)
10936       (native-inputs
10937        `(("fiveam" ,sbcl-fiveam)))
10938       (synopsis "Basic date and time objects for Common Lisp")
10939       (description
10940        "@code{simple-date} is a very basic implementation of date and time
10941 objects, used to support storing and retrieving time-related SQL types.")
10942       (home-page "https://marijnhaverbeke.nl/postmodern/")
10943       (license license:zlib))))
10944
10945 (define-public cl-simple-date
10946   (sbcl-package->cl-source-package sbcl-simple-date))
10947
10948 (define-public ecl-simple-date
10949   (sbcl-package->ecl-package sbcl-simple-date))
10950
10951 (define-public sbcl-cl-postgres
10952   (package
10953     (inherit sbcl-simple-date)
10954     (name "sbcl-cl-postgres")
10955     (native-inputs
10956      `(("fiveam" ,sbcl-fiveam)
10957        ("simple-date" ,sbcl-simple-date)))
10958     (inputs
10959      `(("md5" ,sbcl-md5)
10960        ("split-sequence" ,sbcl-split-sequence)
10961        ("usocket" ,sbcl-usocket)))
10962     (arguments
10963      `(#:tests? #f)) ; TODO: Break simple-date/postgres-glue circular dependency
10964     (synopsis "Common Lisp interface for PostgreSQL")
10965     (description
10966      "@code{cl-postgres} is a low-level library used for interfacing with
10967 a PostgreSQL server over a socket.")))
10968
10969 (define-public cl-postgres
10970   (sbcl-package->cl-source-package sbcl-cl-postgres))
10971
10972 (define-public sbcl-simple-date-postgres-glue
10973   (package
10974     (inherit sbcl-simple-date)
10975     (name "sbcl-simple-date-postgres-glue")
10976     (inputs
10977      `(("cl-postgres" ,sbcl-cl-postgres)
10978        ("simple-date" ,sbcl-simple-date)))
10979     (arguments
10980      `(#:asd-file "simple-date.asd"
10981        #:asd-system-name "simple-date/postgres-glue"))))
10982
10983 (define-public cl-simple-date-postgres-glue
10984   (sbcl-package->cl-source-package sbcl-simple-date-postgres-glue))
10985
10986 (define-public sbcl-s-sql
10987   (package
10988     (inherit sbcl-simple-date)
10989     (name "sbcl-s-sql")
10990     (inputs
10991      `(("alexandria" ,sbcl-alexandria)
10992        ("cl-postgres" ,sbcl-cl-postgres)))
10993     (arguments
10994      `(#:tests? #f)) ; TODO: Break postmodern circular dependency
10995     (synopsis "Lispy DSL for SQL")
10996     (description
10997      "@code{s-sql} is a Common Lisp library that can be used to compile
10998 s-expressions to strings of SQL code, escaping any Lisp values inside, and
10999 doing as much as possible of the work at compile time.")))
11000
11001 (define-public cl-s-sql
11002   (sbcl-package->cl-source-package sbcl-s-sql))
11003
11004 (define-public sbcl-postmodern
11005   (package
11006     (inherit sbcl-simple-date)
11007     (name "sbcl-postmodern")
11008     (native-inputs
11009      `(("fiveam" ,sbcl-fiveam)
11010        ("simple-date" ,sbcl-simple-date)
11011        ("simple-date-postgres-glue" ,sbcl-simple-date-postgres-glue)))
11012     (inputs
11013      `(("alexandria" ,sbcl-alexandria)
11014        ("bordeaux-threads" ,sbcl-bordeaux-threads)
11015        ("cl-postgres" ,sbcl-cl-postgres)
11016        ("closer-mop" ,sbcl-closer-mop)
11017        ("global-vars" ,sbcl-global-vars)
11018        ("s-sql" ,sbcl-s-sql)
11019        ("split-sequence" ,sbcl-split-sequence)))
11020     (arguments
11021      ;; TODO: Fix missing dependency errors for simple-date/postgres-glue,
11022      ;; cl-postgres/tests and s-sql/tests.
11023      `(#:tests? #f))
11024     (synopsis "Common Lisp library for interacting with PostgreSQL")
11025     (description
11026      "@code{postmodern} is a Common Lisp library for interacting with
11027 PostgreSQL databases.  It provides the following features:
11028
11029 @itemize
11030 @item Efficient communication with the database server without need for
11031 foreign libraries.
11032 @item Support for UTF-8 on Unicode-aware Lisp implementations.
11033 @item A syntax for mixing SQL and Lisp code.
11034 @item Convenient support for prepared statements and stored procedures.
11035 @item A metaclass for simple database-access objects.
11036 @end itemize\n")))
11037
11038 (define-public cl-postmodern
11039   (sbcl-package->cl-source-package sbcl-postmodern))
11040
11041 (define-public sbcl-dbi
11042   (package
11043     (name "sbcl-dbi")
11044     (version "0.9.4")
11045     (source
11046      (origin
11047        (method git-fetch)
11048        (uri (git-reference
11049              (url "https://github.com/fukamachi/cl-dbi.git")
11050              (commit version)))
11051        (file-name (git-file-name name version))
11052        (sha256
11053         (base32 "0m1fsravfaizamdak84adh3jxc4j91maqnrb4m08bfbmb04cdqhs"))))
11054     (build-system asdf-build-system/sbcl)
11055     (inputs
11056      `(("bordeaux-threads" ,sbcl-bordeaux-threads)
11057        ("closer-mop" ,sbcl-closer-mop)
11058        ("split-sequence" ,sbcl-split-sequence)))
11059     (arguments
11060      `(#:tests? #f)) ; TODO: Break circular dependency with dbd-*
11061     (synopsis "Database independent interface for Common Lisp")
11062     (description
11063      "@code{dbi} is a Common Lisp library providing a database independent
11064 interface for MySQL, PostgreSQL and SQLite.")
11065     (home-page "https://github.com/fukamachi/cl-dbi")
11066     (license license:llgpl)))
11067
11068 (define-public cl-dbi
11069   (sbcl-package->cl-source-package sbcl-dbi))
11070
11071 (define-public sbcl-dbd-mysql
11072   (package
11073    (inherit sbcl-dbi)
11074    (name "sbcl-dbd-mysql")
11075    (inputs
11076     `(("cl-mysql" ,sbcl-cl-mysql)
11077       ("dbi" ,sbcl-dbi)))
11078    (synopsis "Database driver for MySQL")))
11079
11080 (define-public cl-dbd-mysql
11081   (sbcl-package->cl-source-package sbcl-dbd-mysql))
11082
11083 (define-public sbcl-dbd-postgres
11084   (package
11085    (inherit sbcl-dbi)
11086    (name "sbcl-dbd-postgres")
11087    (inputs
11088     `(("cl-postgres" ,sbcl-cl-postgres)
11089       ("dbi" ,sbcl-dbi)
11090       ("trivial-garbage" ,sbcl-trivial-garbage)))
11091    (synopsis "Database driver for PostgreSQL")))
11092
11093 (define-public cl-dbd-postgres
11094   (sbcl-package->cl-source-package sbcl-dbd-postgres))
11095
11096 (define-public sbcl-dbd-sqlite3
11097   (package
11098    (inherit sbcl-dbi)
11099    (name "sbcl-dbd-sqlite3")
11100    (inputs
11101     `(("cl-sqlite" ,sbcl-cl-sqlite)
11102       ("dbi" ,sbcl-dbi)
11103       ("trivial-garbage" ,sbcl-trivial-garbage)))
11104    (synopsis "Database driver for SQLite3")))
11105
11106 (define-public cl-dbd-sqlite3
11107   (sbcl-package->cl-source-package sbcl-dbd-sqlite3))
11108
11109 (define-public sbcl-uffi
11110   (package
11111     (name "sbcl-uffi")
11112     (version "2.1.2")
11113     (source
11114      (origin
11115        (method git-fetch)
11116        (uri (git-reference
11117              (url "http://git.kpe.io/uffi.git")
11118              (commit (string-append "v" version))))
11119        (file-name (git-file-name name version))
11120        (sha256
11121         (base32 "1hqszvz0a3wk4s9faa83sc3vjxcb5rxmjclyr17yzwg55z733kry"))))
11122     (build-system asdf-build-system/sbcl)
11123     (arguments
11124      `(#:tests? #f ; TODO: Fix use of deprecated ASDF functions
11125        #:phases
11126        (modify-phases %standard-phases
11127          (add-after 'unpack 'fix-permissions
11128            (lambda _
11129              (make-file-writable "doc/html.tar.gz")
11130              #t)))))
11131     (synopsis "Universal foreign function library for Common Lisp")
11132     (description
11133      "UFFI provides a universal foreign function interface (FFI)
11134  for Common Lisp.")
11135     (home-page "http://quickdocs.org/uffi/")
11136     (license license:llgpl)))
11137
11138 (define-public cl-uffi
11139   (package
11140     (inherit (sbcl-package->cl-source-package sbcl-uffi))
11141     (arguments
11142      `(#:phases
11143        ;; asdf-build-system/source has its own phases and does not inherit
11144        ;; from asdf-build-system/sbcl phases.
11145        (modify-phases %standard-phases/source
11146          (add-after 'unpack 'fix-permissions
11147            (lambda _
11148              (make-file-writable "doc/html.tar.gz")
11149              #t)))))))
11150
11151 (define-public sbcl-clsql
11152   (package
11153     (name "sbcl-clsql")
11154     (version "6.7.0")
11155     (source
11156      (origin
11157        (method git-fetch)
11158        (uri (git-reference
11159              (url "http://git.kpe.io/clsql.git")
11160              (commit (string-append "v" version))))
11161        (file-name (git-file-name name version))
11162        (sha256
11163         (base32 "1v1k3s5bsy3lgd9gk459bzpb1r0kdjda25s29samxw4gsgf1fqvp"))
11164        (snippet
11165         '(begin
11166            ;; Remove precompiled libraries.
11167            (delete-file "db-mysql/clsql_mysql.dll")
11168            (delete-file "uffi/clsql_uffi.dll")
11169            (delete-file "uffi/clsql_uffi.lib")
11170            #t))))
11171     (build-system asdf-build-system/sbcl)
11172     (native-inputs
11173      `(("cffi-uffi-compat" ,sbcl-cffi-uffi-compat)
11174        ("rt" ,sbcl-rt)
11175        ("uffi" ,sbcl-uffi)))
11176     (arguments
11177      `(#:phases
11178        (modify-phases %standard-phases
11179          (add-after 'unpack 'fix-permissions
11180            (lambda _
11181              (make-file-writable "doc/html.tar.gz")
11182              #t))
11183          (add-after 'unpack 'fix-tests
11184            (lambda _
11185              (substitute* "clsql.asd"
11186                (("clsql-tests :force t")
11187                 "clsql-tests"))
11188              #t)))))
11189     (synopsis "Common Lisp SQL Interface library")
11190     (description
11191      "@code{clsql} is a Common Lisp interface to SQL RDBMS based on the
11192 Xanalys CommonSQL interface for Lispworks.  It provides low-level database
11193 interfaces as well as a functional and an object oriented interface.")
11194     (home-page "http://clsql.kpe.io/")
11195     (license license:llgpl)))
11196
11197 (define-public cl-clsql
11198   (package
11199     (inherit (sbcl-package->cl-source-package sbcl-clsql))
11200     (native-inputs
11201      `(("rt" ,cl-rt)))
11202     (inputs
11203      `(("mysql" ,mysql)
11204        ("postgresql" ,postgresql)
11205        ("sqlite" ,sqlite)
11206        ("zlib" ,zlib)))
11207     (propagated-inputs
11208      `(("cl-postgres" ,cl-postgres)
11209        ("cffi-uffi-compat" ,cl-cffi-uffi-compat)
11210        ("md5" ,cl-md5)
11211        ("uffi" ,cl-uffi)))
11212     (arguments
11213      `(#:phases
11214        ;; asdf-build-system/source has its own phases and does not inherit
11215        ;; from asdf-build-system/sbcl phases.
11216        (modify-phases %standard-phases/source
11217          (add-after 'unpack 'fix-permissions
11218            (lambda _
11219              (make-file-writable "doc/html.tar.gz")
11220              #t)))))))
11221
11222 (define-public sbcl-clsql-uffi
11223   (package
11224     (inherit sbcl-clsql)
11225     (name "sbcl-clsql-uffi")
11226     (inputs
11227      `(("cffi-uffi-compat" ,sbcl-cffi-uffi-compat)
11228        ("clsql" ,sbcl-clsql)
11229        ("uffi" ,sbcl-uffi)))
11230     (synopsis "UFFI helper functions for Common Lisp SQL interface library")))
11231
11232 (define-public sbcl-clsql-sqlite3
11233   (package
11234     (inherit sbcl-clsql)
11235     (name "sbcl-clsql-sqlite3")
11236     (inputs
11237      `(("clsql" ,sbcl-clsql)
11238        ("clsql-uffi" ,sbcl-clsql-uffi)
11239        ("sqlite" ,sqlite)))
11240     (arguments
11241      (substitute-keyword-arguments (package-arguments sbcl-clsql)
11242        ((#:phases phases '%standard-phases)
11243         `(modify-phases ,phases
11244            (add-after 'unpack 'fix-paths
11245              (lambda* (#:key inputs #:allow-other-keys)
11246                (substitute* "db-sqlite3/sqlite3-loader.lisp"
11247                  (("libsqlite3")
11248                   (string-append (assoc-ref inputs "sqlite")
11249                                  "/lib/libsqlite3")))
11250                #t))))))
11251     (synopsis "SQLite3 driver for Common Lisp SQL interface library")))
11252
11253 (define-public sbcl-clsql-postgresql
11254   (package
11255     (inherit sbcl-clsql)
11256     (name "sbcl-clsql-postgresql")
11257     (inputs
11258      `(("clsql" ,sbcl-clsql)
11259        ("clsql-uffi" ,sbcl-clsql-uffi)
11260        ("postgresql" ,postgresql)))
11261     (arguments
11262      (substitute-keyword-arguments (package-arguments sbcl-clsql)
11263        ((#:phases phases '%standard-phases)
11264         `(modify-phases ,phases
11265            (add-after 'unpack 'fix-paths
11266              (lambda* (#:key inputs #:allow-other-keys)
11267                (substitute* "db-postgresql/postgresql-loader.lisp"
11268                  (("libpq")
11269                   (string-append (assoc-ref inputs "postgresql")
11270                                  "/lib/libpq")))
11271                #t))))))
11272     (synopsis "PostgreSQL driver for Common Lisp SQL interface library")))
11273
11274 (define-public sbcl-clsql-postgresql-socket3
11275   (package
11276     (inherit sbcl-clsql)
11277     (name "sbcl-clsql-postgresql-socket3")
11278     (inputs
11279      `(("cl-postgres" ,sbcl-cl-postgres)
11280        ("clsql" ,sbcl-clsql)
11281        ("md5" ,sbcl-md5)))
11282     (arguments
11283      (substitute-keyword-arguments (package-arguments sbcl-clsql)
11284        ((#:phases phases '%standard-phases)
11285         `(modify-phases ,phases
11286            (add-after 'create-asd-file 'fix-asd-file
11287              (lambda* (#:key outputs #:allow-other-keys)
11288                (let* ((out (assoc-ref outputs "out"))
11289                       (lib (string-append out "/lib/" (%lisp-type)))
11290                       (asd (string-append lib "/clsql-postgresql-socket3.asd")))
11291                  (substitute* asd
11292                    (("CLSQL-POSTGRESQL-SOCKET-SYSTEM::")
11293                     "")))
11294                #t))))))
11295     (synopsis "PostgreSQL driver for Common Lisp SQL interface library")))
11296
11297 (define-public sbcl-clsql-mysql
11298   (package
11299     (inherit sbcl-clsql)
11300     (name "sbcl-clsql-mysql")
11301     (inputs
11302      `(("mysql" ,mysql)
11303        ("sbcl-clsql" ,sbcl-clsql)
11304        ("sbcl-clsql-uffi" ,sbcl-clsql-uffi)
11305        ("zlib" ,zlib)))
11306     (arguments
11307      (substitute-keyword-arguments (package-arguments sbcl-clsql)
11308        ((#:phases phases '%standard-phases)
11309         `(modify-phases ,phases
11310            (add-after 'unpack 'fix-paths
11311              (lambda* (#:key inputs outputs #:allow-other-keys)
11312                (let ((lib (string-append "#p\""
11313                                          (assoc-ref outputs "out")
11314                                          "/lib/\"")))
11315                  (substitute* "clsql-mysql.asd"
11316                    (("#p\"/usr/lib/clsql/clsql_mysql\\.so\"")
11317                     lib))
11318                  (substitute* "db-mysql/mysql-loader.lisp"
11319                    (("libmysqlclient" all)
11320                     (string-append (assoc-ref inputs "mysql") "/lib/" all))
11321                    (("clsql-mysql-system::\\*library-file-dir\\*")
11322                     lib)))
11323                #t))
11324            (add-before 'build 'build-helper-library
11325              (lambda* (#:key inputs outputs #:allow-other-keys)
11326                (let* ((mysql (assoc-ref inputs "mysql"))
11327                       (inc-dir (string-append mysql "/include/mysql"))
11328                       (lib-dir (string-append mysql "/lib"))
11329                       (shared-lib-dir (string-append (assoc-ref outputs "out")
11330                                                      "/lib"))
11331                       (shared-lib (string-append shared-lib-dir
11332                                                  "/clsql_mysql.so")))
11333                  (mkdir-p shared-lib-dir)
11334                  (invoke "gcc" "-fPIC" "-shared"
11335                          "-I" inc-dir
11336                          "db-mysql/clsql_mysql.c"
11337                          "-Wl,-soname=clsql_mysql"
11338                          "-L" lib-dir "-lmysqlclient" "-lz"
11339                          "-o" shared-lib)
11340                  #t)))))))
11341     (synopsis "MySQL driver for Common Lisp SQL interface library")))
11342
11343 (define-public sbcl-sycamore
11344   (let ((commit "fd2820fec165ad514493426dea209728f64e6d18"))
11345     (package
11346       (name "sbcl-sycamore")
11347       (version "0.0.20120604")
11348       (source
11349        (origin
11350          (method git-fetch)
11351          (uri (git-reference
11352                (url "https://github.com/ndantam/sycamore/")
11353                (commit commit)))
11354          (file-name (git-file-name name version))
11355          (sha256
11356           (base32 "00bv1aj89q5vldmq92zp2364jq312zjq2mbd3iyz1s2b4widzhl7"))))
11357       (build-system asdf-build-system/sbcl)
11358       (arguments
11359        `(#:asd-file "src/sycamore.asd"))
11360       (inputs
11361        `(("alexandria" ,sbcl-alexandria)
11362          ("cl-ppcre" ,sbcl-cl-ppcre)))
11363       (synopsis "Purely functional data structure library in Common Lisp")
11364       (description
11365        "Sycamore is a fast, purely functional data structure library in Common Lisp.
11366 If features:
11367
11368 @itemize
11369 @item Fast, purely functional weight-balanced binary trees.
11370 @item Leaf nodes are simple-vectors, greatly reducing tree height.
11371 @item Interfaces for tree Sets and Maps (dictionaries).
11372 @item Ropes.
11373 @item Purely functional pairing heaps.
11374 @item Purely functional amortized queue.
11375 @end itemize\n")
11376       (home-page "http://ndantam.github.io/sycamore/")
11377       (license license:bsd-3))))
11378
11379 (define-public cl-sycamore
11380   (sbcl-package->cl-source-package sbcl-sycamore))
11381
11382 (define-public sbcl-trivial-package-local-nicknames
11383   (package
11384     (name "sbcl-trivial-package-local-nicknames")
11385     (version "0.2")
11386     (home-page "https://github.com/phoe/trivial-package-local-nicknames")
11387     (source
11388      (origin
11389        (method git-fetch)
11390        (uri (git-reference
11391              (url home-page)
11392              (commit "16b7ad4c2b120f50da65154191f468ea5598460e")))
11393        (file-name (git-file-name name version))
11394        (sha256
11395         (base32 "18qc27xkjzdcqrilpk3pm7djldwq5rm3ggd5h9cr8hqcd54i2fqg"))))
11396     (build-system asdf-build-system/sbcl)
11397     (synopsis "Common Lisp compatibility library for package local nicknames")
11398     (description
11399      "This library is a portable compatibility layer around package local nicknames (PLN).
11400 This was done so there is a portability library for the PLN API not included
11401 in DEFPACKAGE.")
11402     (license license:unlicense)))
11403
11404 (define-public cl-trivial-package-local-nicknames
11405   (sbcl-package->cl-source-package sbcl-trivial-package-local-nicknames))
11406
11407 (define-public sbcl-enchant
11408   (let ((commit "6af162a7bf10541cbcfcfa6513894900329713fa"))
11409     (package
11410       (name "sbcl-enchant")
11411       (version (git-version "0.0.0" "1" commit))
11412       (home-page "https://github.com/tlikonen/cl-enchant")
11413       (source
11414        (origin
11415          (method git-fetch)
11416          (uri (git-reference
11417                (url home-page)
11418                (commit commit)))
11419          (file-name (git-file-name name version))
11420          (sha256
11421           (base32 "19yh5ihirzi1d8xqy1cjqipzd6ly3245cfxa5s9xx496rryz0s01"))))
11422       (build-system asdf-build-system/sbcl)
11423       (inputs
11424        `(("enchant" ,enchant)
11425          ("cffi" ,sbcl-cffi)))
11426       (arguments
11427        `(#:phases
11428          (modify-phases %standard-phases
11429            (add-after 'unpack 'fix-paths
11430              (lambda* (#:key inputs #:allow-other-keys)
11431                (substitute* "load-enchant.lisp"
11432                  (("libenchant")
11433                   (string-append
11434                    (assoc-ref inputs "enchant") "/lib/libenchant-2"))))))))
11435       (synopsis "Common Lisp interface for the Enchant spell-checker library")
11436       (description
11437        "Enchant is a Common Lisp interface for the Enchant spell-checker
11438 library.  The Enchant library is a generic spell-checker library which uses
11439 other spell-checkers transparently as back-end.  The library supports the
11440 multiple checkers, including Aspell and Hunspell.")
11441       (license license:public-domain))))
11442
11443 (define-public cl-enchant
11444   (sbcl-package->cl-source-package sbcl-enchant))
11445
11446 (define-public sbcl-cl-change-case
11447   (let ((commit "5ceff2a5f8bd845b6cb510c6364176b27a238fd3"))
11448     (package
11449       (name "sbcl-cl-change-case")
11450       (version (git-version "0.1.0" "1" commit))
11451       (home-page "https://github.com/rudolfochrist/cl-change-case")
11452       (source
11453        (origin
11454          (method git-fetch)
11455          (uri (git-reference
11456                (url home-page)
11457                (commit commit)))
11458          (file-name (git-file-name name version))
11459          (sha256
11460           (base32 "1afyglglk9z3yg8gylcl301bl2r8vq3sllyznzj9s5xi5gs6qyf2"))))
11461       (build-system asdf-build-system/sbcl)
11462       (inputs
11463        `(("cl-ppcre" ,sbcl-cl-ppcre)
11464          ("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)))
11465       (native-inputs
11466        `(("fiveam" ,sbcl-fiveam)))
11467       (arguments
11468        '(;; FIXME: Test pass but phase fails with 'Component
11469          ;; "cl-change-case-test" not found, required by'.
11470          #:tests? #f
11471          #:test-asd-file "cl-change-case-test.asd"))
11472       (synopsis "Convert Common Lisp strings between camelCase, PascalCase and more")
11473       (description
11474        "@code{cl-change-case} is library to convert strings between camelCase,
11475 PascalCase, snake_case, param-case, CONSTANT_CASE and more.")
11476       (license license:llgpl))))
11477
11478 (define-public cl-change-case
11479   (sbcl-package->cl-source-package sbcl-cl-change-case))
11480
11481 (define-public sbcl-moptilities
11482   (let ((commit "a436f16b357c96b82397ec018ea469574c10dd41"))
11483     (package
11484       (name "sbcl-moptilities")
11485       (version (git-version "0.3.13" "1" commit))
11486       (home-page "https://github.com/gwkkwg/moptilities/")
11487       (source
11488        (origin
11489          (method git-fetch)
11490          (uri (git-reference
11491                (url home-page)
11492                (commit commit)))
11493          (file-name (git-file-name name version))
11494          (sha256
11495           (base32 "1q12bqjbj47lx98yim1kfnnhgfhkl80102fkgp9pdqxg0fp6g5fc"))))
11496       (build-system asdf-build-system/sbcl)
11497       (inputs
11498        `(("closer-mop" ,sbcl-closer-mop)))
11499       (native-inputs
11500        `(("lift" ,sbcl-lift)))
11501       (synopsis "Compatibility layer for Common Lisp MOP implementation differences")
11502       (description
11503        "MOP utilities provide a common interface between Lisps and make the
11504 MOP easier to use.")
11505       (license license:expat))))
11506
11507 (define-public cl-moptilities
11508   (sbcl-package->cl-source-package sbcl-moptilities))
11509
11510 (define-public sbcl-osicat
11511   (let ((commit "de0c18a367eedc857e1902a7319828af072a0d97"))
11512     (package
11513       (name "sbcl-osicat")
11514       (version (git-version "0.7.0" "1" commit))
11515       (home-page "http://www.common-lisp.net/project/osicat/")
11516       (source
11517        (origin
11518          (method git-fetch)
11519          (uri (git-reference
11520                (url "https://github.com/osicat/osicat")
11521                (commit commit)))
11522          (file-name (git-file-name name version))
11523          (sha256
11524           (base32 "15viw5pi5sa7qq9b4n2rr3dj2jkqr180rh9z1lh8w3rgl42i2adc"))))
11525       (build-system asdf-build-system/sbcl)
11526       (arguments
11527        `(#:phases
11528          (modify-phases %standard-phases
11529            ;; The cleanup phase moves files around but we need to keep the
11530            ;; directory structure for the grovel-generated library.
11531            (replace 'cleanup
11532              (lambda* (#:key outputs #:allow-other-keys)
11533                (let* ((out (assoc-ref outputs "out"))
11534                       (lib (string-append out "/lib/sbcl/")))
11535                  (delete-file-recursively (string-append lib "src"))
11536                  (delete-file-recursively (string-append lib "tests"))
11537                  (for-each delete-file
11538                            (filter (lambda (file)
11539                                      (not (member (basename file) '("libosicat.so"))))
11540                                    (find-files (string-append lib "posix") ".*"))))
11541                #t)))))
11542       (inputs
11543        `(("alexandria" ,sbcl-alexandria)
11544          ("cffi" ,sbcl-cffi)
11545          ("trivial-features" ,sbcl-trivial-features)))
11546       (native-inputs
11547        `(("cffi-grovel" ,sbcl-cffi-grovel)
11548          ("rt" ,sbcl-rt)))
11549       (synopsis "Operating system interface for Common Lisp")
11550       (description
11551        "Osicat is a lightweight operating system interface for Common Lisp on
11552 Unix-platforms.  It is not a POSIX-style API, but rather a simple lispy
11553 accompaniment to the standard ANSI facilities.")
11554       (license license:expat))))
11555
11556 (define-public cl-osicat
11557   (sbcl-package->cl-source-package sbcl-osicat))
11558
11559 (define-public sbcl-quantile-estimator
11560   (package
11561     (name "sbcl-quantile-estimator")
11562     (version "0.0.1")
11563     (source
11564      (origin
11565        (method git-fetch)
11566        (uri (git-reference
11567              (url "https://github.com/deadtrickster/quantile-estimator.cl")
11568              (commit "84d0ea405d793f5e808c68c4ddaf25417b0ff8e5")))
11569        (file-name (git-file-name name version))
11570        (sha256
11571         (base32
11572          "0rlswkf0siaabsvvch3dgxmg45fw5w8pd9b7ri2w7a298aya52z9"))))
11573     (build-system asdf-build-system/sbcl)
11574     (arguments
11575      '(#:asd-system-name "quantile-estimator"))
11576     (inputs
11577      `(("alexandria" ,sbcl-alexandria)))
11578     (home-page "https://github.com/deadtrickster/quantile-estimator.cl")
11579     (synopsis
11580      "Effective computation of biased quantiles over data streams")
11581     (description
11582      "Common Lisp implementation of Graham Cormode and S.
11583 Muthukrishnan's Effective Computation of Biased Quantiles over Data
11584 Streams in ICDE’05.")
11585     (license license:expat)))
11586
11587 (define-public cl-quantile-estimator
11588   (sbcl-package->cl-source-package sbcl-quantile-estimator))
11589
11590 (define-public ecl-quantile-estimator
11591   (sbcl-package->ecl-package sbcl-quantile-estimator))
11592
11593 (define-public sbcl-prometheus
11594   (package
11595     (name "sbcl-prometheus")
11596     (version "0.4.1")
11597     (source
11598      (origin
11599        (method git-fetch)
11600        (uri (git-reference
11601              (url "https://github.com/deadtrickster/prometheus.cl.git")
11602              (commit "7352b92296996ff383503e19bdd3bcea30409a15")))
11603        (file-name (git-file-name name version))
11604        (sha256
11605         (base32
11606          "0fzczls2kfgdx18pja4lqxjrz72i583185d8nq0pb3s331hhzh0z"))))
11607     (build-system asdf-build-system/sbcl)
11608     (inputs
11609      `(("alexandria" ,sbcl-alexandria)
11610        ("bordeaux-threads" ,sbcl-bordeaux-threads)
11611        ("cl-ppcre" ,sbcl-cl-ppcre)
11612        ("local-time" ,sbcl-local-time)
11613        ("quantile-estimator" ,sbcl-quantile-estimator)))
11614     (home-page "https://github.com/deadtrickster/prometheus.cl")
11615     (synopsis "Prometheus.io Common Lisp client")
11616     (description "Prometheus.io Common Lisp client.")
11617     (license license:expat)))
11618
11619 (define-public cl-prometheus
11620   (sbcl-package->cl-source-package sbcl-prometheus))
11621
11622 (define-public ecl-prometheus
11623   (sbcl-package->ecl-package sbcl-prometheus))
11624
11625 (define-public sbcl-prometheus.collectors.sbcl
11626   (package
11627     (inherit sbcl-prometheus)
11628     (name "sbcl-prometheus.collectors.sbcl")
11629     (inputs `(("prometheus" ,sbcl-prometheus)))
11630     (synopsis "Prometheus collector for SBCL metrics")
11631     (description "Prometheus collector for SBCL metrics.")))
11632
11633 (define-public cl-prometheus.collectors.sbcl
11634   (sbcl-package->cl-source-package sbcl-prometheus.collectors.sbcl))
11635
11636 (define-public sbcl-prometheus.collectors.process
11637   (package
11638     (inherit sbcl-prometheus)
11639     (name "sbcl-prometheus.collectors.process")
11640     (inputs
11641      `(("cffi" ,sbcl-cffi)
11642        ("cffi-grovel" ,sbcl-cffi-grovel)
11643        ("cl-fad" ,sbcl-cl-fad)
11644        ("prometheus" ,sbcl-prometheus)
11645        ("split-sequence" ,sbcl-split-sequence)))
11646     (synopsis "Prometheus collector for process metrics")
11647     (description "Prometheus collector for process metrics.")))
11648
11649 (define-public cl-prometheus.collectors.process
11650   (sbcl-package->cl-source-package sbcl-prometheus.collectors.process))
11651
11652 (define-public ecl-prometheus.collectors.process
11653   (sbcl-package->ecl-package sbcl-prometheus.collectors.process))
11654
11655 (define-public sbcl-prometheus.formats.text
11656   (package
11657     (inherit sbcl-prometheus)
11658     (name "sbcl-prometheus.formats.text")
11659     (inputs
11660      `(("alexandria" ,sbcl-alexandria)
11661        ("prometheus" ,sbcl-prometheus)))
11662     (synopsis "Prometheus client text format")
11663     (description "Prometheus client text format.")))
11664
11665 (define-public cl-prometheus.formats.text
11666   (sbcl-package->cl-source-package sbcl-prometheus.formats.text))
11667
11668 (define-public ecl-prometheus.formats.text
11669   (sbcl-package->ecl-package sbcl-prometheus.formats.text))
11670
11671 (define-public sbcl-prometheus.exposers.hunchentoot
11672   (package
11673     (inherit sbcl-prometheus)
11674     (name "sbcl-prometheus.exposers.hunchentoot")
11675     (inputs
11676      `(("hunchentoot" ,sbcl-hunchentoot)
11677        ("prometheus" ,sbcl-prometheus)
11678        ("prometheus.formats.text" ,sbcl-prometheus.formats.text)
11679        ("salza2" ,sbcl-salza2)
11680        ("trivial-utf-8" ,sbcl-trivial-utf-8)))
11681     (synopsis "Prometheus collector for Hunchentoot metrics")
11682     (description "Prometheus collector for Hunchentoot metrics")))
11683
11684 (define-public cl-prometheus.exposers.hunchentoot
11685   (sbcl-package->cl-source-package sbcl-prometheus.exposers.hunchentoot))
11686
11687 (define-public sbcl-prometheus.pushgateway
11688   (package
11689     (inherit sbcl-prometheus)
11690     (name "sbcl-prometheus.pushgateway")
11691     (inputs
11692      `(("drakma" ,sbcl-drakma)
11693        ("prometheus" ,sbcl-prometheus)
11694        ("prometheus.formats.text" ,sbcl-prometheus.formats.text)))
11695     (synopsis "Prometheus Pushgateway client")
11696     (description "Prometheus Pushgateway client.")))
11697
11698 (define-public cl-prometheus.pushgateway
11699   (sbcl-package->cl-source-package sbcl-prometheus.pushgateway))
11700
11701 (define-public ecl-prometheus.pushgateway
11702   (sbcl-package->ecl-package sbcl-prometheus.pushgateway))
11703
11704 (define-public sbcl-uuid
11705   (let ((commit "e7d6680c3138385c0708f7aaf0c96622eeb140e8"))
11706     (package
11707       (name "sbcl-uuid")
11708       (version (git-version "2012.12.26" "1" commit))
11709       (source
11710        (origin
11711          (method git-fetch)
11712          (uri (git-reference
11713                (url "https://github.com/dardoria/uuid.git")
11714                (commit commit)))
11715          (file-name (git-file-name name version))
11716          (sha256
11717           (base32
11718            "0jnyp2kibcf5cwi60l6grjrj8wws9chasjvsw7xzwyym2lyid46f"))))
11719       (build-system asdf-build-system/sbcl)
11720       (inputs
11721        `(("ironclad" ,sbcl-ironclad)
11722          ("trivial-utf-8" ,sbcl-trivial-utf-8)))
11723       (home-page "https://github.com/dardoria/uuid")
11724       (synopsis
11725        "Common Lisp implementation of UUIDs according to RFC4122")
11726       (description
11727        "Common Lisp implementation of UUIDs according to RFC4122.")
11728       (license license:llgpl))))
11729
11730 (define-public cl-uuid
11731   (sbcl-package->cl-source-package sbcl-uuid))
11732
11733 (define-public ecl-uuid
11734   (sbcl-package->ecl-package sbcl-uuid))