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 ;;; Copyright © 2020 Adam Kandur <rndd@tuta.io>
  23 ;;;
  24 ;;; This file is part of GNU Guix.
  25 ;;;
  26 ;;; GNU Guix is free software; you can redistribute it and/or modify it
  27 ;;; under the terms of the GNU General Public License as published by
  28 ;;; the Free Software Foundation; either version 3 of the License, or (at
  29 ;;; your option) any later version.
  30 ;;;
  31 ;;; GNU Guix is distributed in the hope that it will be useful, but
  32 ;;; WITHOUT ANY WARRANTY; without even the implied warranty of
  33 ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  34 ;;; GNU General Public License for more details.
  35 ;;;
  36 ;;; You should have received a copy of the GNU General Public License
  37 ;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.
  38
  39 ;;; This file only contains Common Lisp libraries.
  40 ;;; Common Lisp compilers and tooling go to lisp.scm.
  41 ;;; Common Lisp applications should go to the most appropriate file,
  42 ;;; e.g. StumpWM is in wm.scm.
  43
  44 (define-module (gnu packages lisp-xyz)
  45   #:use-module (gnu packages)
  46   #:use-module ((guix licenses) #:prefix license:)
  47   #:use-module (guix packages)
  48   #:use-module (guix download)
  49   #:use-module (guix git-download)
  50   #:use-module (guix hg-download)
  51   #:use-module (guix utils)
  52   #:use-module (guix build-system asdf)
  53   #:use-module (guix build-system trivial)
  54   #:use-module (gnu packages c)
  55   #:use-module (gnu packages compression)
  56   #:use-module (gnu packages databases)
  57   #:use-module (gnu packages enchant)
  58   #:use-module (gnu packages fonts)
  59   #:use-module (gnu packages fontutils)
  60   #:use-module (gnu packages glib)
  61   #:use-module (gnu packages gtk)
  62   #:use-module (gnu packages imagemagick)
  63   #:use-module (gnu packages libevent)
  64   #:use-module (gnu packages libffi)
  65   #:use-module (gnu packages lisp)
  66   #:use-module (gnu packages maths)
  67   #:use-module (gnu packages networking)
  68   #:use-module (gnu packages pkg-config)
  69   #:use-module (gnu packages python)
  70   #:use-module (gnu packages python-xyz)
  71   #:use-module (gnu packages sqlite)
  72   #:use-module (gnu packages tcl)
  73   #:use-module (gnu packages tls)
  74   #:use-module (gnu packages web)
  75   #:use-module (gnu packages webkit)
  76   #:use-module (gnu packages xdisorg)
  77   #:use-module (ice-9 match)
  78   #:use-module (srfi srfi-1)
  79   #:use-module (srfi srfi-19))
  80
  81 (define-public sbcl-alexandria
  82   (package
  83    (name "sbcl-alexandria")
  84    (version "1.1")
  85    (source
  86     (origin
  87      (method git-fetch)
  88      (uri (git-reference
  89            (url "https://gitlab.common-lisp.net/alexandria/alexandria.git")
  90            (commit (string-append "v" version))))
  91      (sha256
  92       (base32
  93        "1zanb3xa98js0i66iqcmx3gp123p1m2d1fxn8d7bfzyfad5f6xn2"))
  94      (file-name (git-file-name name version))))
  95    (build-system asdf-build-system/sbcl)
  96    (native-inputs
  97     `(("rt" ,sbcl-rt)))
  98    (synopsis "Collection of portable utilities for Common Lisp")
  99    (description
 100     "Alexandria is a collection of portable utilities.  It does not contain
 101 conceptual extensions to Common Lisp.  It is conservative in scope, and
 102 portable between implementations.")
 103    (home-page "https://common-lisp.net/project/alexandria/")
 104    (license license:public-domain)))
 105
 106 (define-public cl-alexandria
 107   (sbcl-package->cl-source-package sbcl-alexandria))
 108
 109 (define-public ecl-alexandria
 110   (sbcl-package->ecl-package sbcl-alexandria))
 111
 112 (define-public sbcl-net.didierverna.asdf-flv
 113   (package
 114     (name "sbcl-net.didierverna.asdf-flv")
 115     (version "2.1")
 116     (source
 117      (origin
 118        (method git-fetch)
 119        (uri (git-reference
 120              (url "https://github.com/didierverna/asdf-flv")
 121              (commit (string-append "version-" version))))
 122        (file-name (git-file-name "asdf-flv" version))
 123        (sha256
 124         (base32 "1fi2y4baxan103jbg4idjddzihy03kwnj2mzbwrknw4d4x7xlgwj"))))
 125     (build-system asdf-build-system/sbcl)
 126     (synopsis "Common Lisp ASDF extension to provide support for file-local variables")
 127     (description "ASDF-FLV provides support for file-local variables through
 128 ASDF.  A file-local variable behaves like @code{*PACKAGE*} and
 129 @code{*READTABLE*} with respect to @code{LOAD} and @code{COMPILE-FILE}: a new
 130 dynamic binding is created before processing the file, so that any
 131 modification to the variable becomes essentially file-local.
 132
 133 In order to make one or several variables file-local, use the macros
 134 @code{SET-FILE-LOCAL-VARIABLE(S)}.")
 135     (home-page "https://www.lrde.epita.fr/~didier/software/lisp/misc.php#asdf-flv")
 136     (license (license:non-copyleft
 137               "https://www.gnu.org/prep/maintain/html_node/License-Notices-for-Other-Files.html"
 138               "GNU All-Permissive License"))))
 139
 140 (define-public cl-net.didierverna.asdf-flv
 141   (sbcl-package->cl-source-package sbcl-net.didierverna.asdf-flv))
 142
 143 (define-public ecl-net.didierverna.asdf-flv
 144   (sbcl-package->ecl-package sbcl-net.didierverna.asdf-flv))
 145
 146 (define-public sbcl-fiveam
 147   (package
 148     (name "sbcl-fiveam")
 149     (version "1.4.1")
 150     (source
 151      (origin
 152        (method git-fetch)
 153        (uri (git-reference
 154              (url "https://github.com/sionescu/fiveam")
 155              (commit (string-append "v" version))))
 156        (file-name (git-file-name "fiveam" version))
 157        (sha256
 158         (base32 "1q3d38pwafnwnw42clq0f8g5xw7pbzr287jl9jsqmb1vb0n1vrli"))))
 159     (inputs
 160      `(("alexandria" ,sbcl-alexandria)
 161        ("net.didierverna.asdf-flv" ,sbcl-net.didierverna.asdf-flv)
 162        ("trivial-backtrace" ,sbcl-trivial-backtrace)))
 163     (build-system asdf-build-system/sbcl)
 164     (synopsis "Common Lisp testing framework")
 165     (description "FiveAM is a simple (as far as writing and running tests
 166 goes) regression testing framework.  It has been designed with Common Lisp's
 167 interactive development model in mind.")
 168     (home-page "https://common-lisp.net/project/fiveam/")
 169     (license license:bsd-3)))
 170
 171 (define-public cl-fiveam
 172   (sbcl-package->cl-source-package sbcl-fiveam))
 173
 174 (define-public ecl-fiveam
 175   (sbcl-package->ecl-package sbcl-fiveam))
 176
 177 (define-public sbcl-bordeaux-threads
 178   (package
 179     (name "sbcl-bordeaux-threads")
 180     (version "0.8.8")
 181     (source (origin
 182               (method git-fetch)
 183               (uri (git-reference
 184                     (url "https://github.com/sionescu/bordeaux-threads")
 185                     (commit (string-append "v" version))))
 186               (sha256
 187                (base32 "19i443fz3488v1pbbr9x24y8h8vlyhny9vj6c9jk5prm702awrp6"))
 188               (file-name
 189                (git-file-name "bordeaux-threads" version))))
 190     (inputs `(("alexandria" ,sbcl-alexandria)))
 191     (native-inputs `(("fiveam" ,sbcl-fiveam)))
 192     (build-system asdf-build-system/sbcl)
 193     (synopsis "Portable shared-state concurrency library for Common Lisp")
 194     (description "BORDEAUX-THREADS is a proposed standard for a minimal
 195 MP/Threading interface.  It is similar to the CLIM-SYS threading and lock
 196 support.")
 197     (home-page "https://common-lisp.net/project/bordeaux-threads/")
 198     (license license:x11)))
 199
 200 (define-public cl-bordeaux-threads
 201   (sbcl-package->cl-source-package sbcl-bordeaux-threads))
 202
 203 (define-public ecl-bordeaux-threads
 204   (sbcl-package->ecl-package sbcl-bordeaux-threads))
 205
 206 (define-public sbcl-trivial-gray-streams
 207   (let ((revision "1")
 208         (commit "ebd59b1afed03b9dc8544320f8f432fdf92ab010"))
 209     (package
 210       (name "sbcl-trivial-gray-streams")
 211       (version (string-append "0.0.0-" revision "." (string-take commit 7)))
 212       (source
 213        (origin
 214          (method git-fetch)
 215          (uri
 216           (git-reference
 217            (url "https://github.com/trivial-gray-streams/trivial-gray-streams")
 218            (commit commit)))
 219          (sha256
 220           (base32 "0b1pxlccmnagk9cbh4cy8s5k66g3x0gwib5shjwr24xvrji6lp94"))
 221          (file-name
 222           (string-append "trivial-gray-streams-" version "-checkout"))))
 223       (build-system asdf-build-system/sbcl)
 224       (synopsis "Compatibility layer for Gray streams implementations")
 225       (description "Gray streams is an interface proposed for inclusion with
 226 ANSI CL by David N. Gray.  The proposal did not make it into ANSI CL, but most
 227 popular CL implementations implement it.  This package provides an extremely
 228 thin compatibility layer for gray streams.")
 229       (home-page "https://www.cliki.net/trivial-gray-streams")
 230       (license license:x11))))
 231
 232 (define-public cl-trivial-gray-streams
 233   (sbcl-package->cl-source-package sbcl-trivial-gray-streams))
 234
 235 (define-public ecl-trivial-gray-streams
 236   (sbcl-package->ecl-package sbcl-trivial-gray-streams))
 237
 238 (define-public sbcl-fiasco
 239   (let ((commit "d62f7558b21addc89f87e306f65d7f760632655f")
 240         (revision "1"))
 241     (package
 242       (name "sbcl-fiasco")
 243       (version (git-version "0.0.1" revision commit))
 244       (source
 245        (origin
 246          (method git-fetch)
 247          (uri (git-reference
 248                (url "https://github.com/joaotavora/fiasco")
 249                (commit commit)))
 250          (file-name (git-file-name "fiasco" version))
 251          (sha256
 252           (base32
 253            "1zwxs3d6iswayavcmb49z2892xhym7n556d8dnmvalc32pm9bkjh"))))
 254       (build-system asdf-build-system/sbcl)
 255       (inputs
 256        `(("alexandria" ,sbcl-alexandria)
 257          ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
 258       (synopsis "Simple and powerful test framework for Common Lisp")
 259       (description "A Common Lisp test framework that treasures your failures,
 260 logical continuation of Stefil.  It focuses on interactive debugging.")
 261       (home-page "https://github.com/joaotavora/fiasco")
 262       ;; LICENCE specifies this is public-domain unless the legislation
 263       ;; doesn't allow or recognize it.  In that case it falls back to a
 264       ;; permissive licence.
 265       (license (list license:public-domain
 266                      (license:x11-style "file://LICENCE"))))))
 267
 268 (define-public cl-fiasco
 269   (sbcl-package->cl-source-package sbcl-fiasco))
 270
 271 (define-public ecl-fiasco
 272   (sbcl-package->ecl-package sbcl-fiasco))
 273
 274 (define-public sbcl-flexi-streams
 275   (package
 276     (name "sbcl-flexi-streams")
 277     (version "1.0.18")
 278     (source
 279      (origin
 280        (method git-fetch)
 281        (uri (git-reference
 282              (url "https://github.com/edicl/flexi-streams")
 283              (commit (string-append "v" version))))
 284        (file-name (git-file-name "flexi-streams" version))
 285        (sha256
 286         (base32 "0bjv7fd2acknidc5dyi3h85pn10krxv5jyxs1xg8jya2rlfv7f1j"))))
 287     (build-system asdf-build-system/sbcl)
 288     (arguments
 289      `(#:phases
 290        (modify-phases %standard-phases
 291          (add-after 'unpack 'make-git-checkout-writable
 292            (lambda _
 293              (for-each make-file-writable (find-files "."))
 294              #t)))))
 295     (inputs `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
 296     (synopsis "Implementation of virtual bivalent streams for Common Lisp")
 297     (description "Flexi-streams is an implementation of \"virtual\" bivalent
 298 streams that can be layered atop real binary or bivalent streams and that can
 299 be used to read and write character data in various single- or multi-octet
 300 encodings which can be changed on the fly.  It also supplies in-memory binary
 301 streams which are similar to string streams.")
 302     (home-page "http://weitz.de/flexi-streams/")
 303     (license license:bsd-3)))
 304
 305 (define-public cl-flexi-streams
 306   (sbcl-package->cl-source-package sbcl-flexi-streams))
 307
 308 (define-public ecl-flexi-streams
 309   (sbcl-package->ecl-package sbcl-flexi-streams))
 310
 311 (define-public sbcl-cl-ppcre
 312   (package
 313     (name "sbcl-cl-ppcre")
 314     (version "2.1.1")
 315     (source
 316      (origin
 317        (method git-fetch)
 318        (uri (git-reference
 319              (url "https://github.com/edicl/cl-ppcre")
 320              (commit (string-append "v" version))))
 321        (file-name (git-file-name "cl-ppcre" version))
 322        (sha256
 323         (base32 "0dwvr29diqzcg5n6jvbk2rnd90i05l7n828hhw99khmqd0kz7xsi"))))
 324     (build-system asdf-build-system/sbcl)
 325     (native-inputs
 326      `(("flexi-streams" ,sbcl-flexi-streams)))
 327     (arguments
 328      `(#:phases
 329        (modify-phases %standard-phases
 330          (add-after 'unpack 'disable-ppcre-unicode
 331            ;; cl-ppcre and cl-ppcre-unicode are put in different packages
 332            ;; to work around the circular dependency between edicl/cl-ppcre
 333            ;; and edicl/cl-unicode.
 334            (lambda _
 335              (delete-file "cl-ppcre-unicode.asd")
 336              #t)))))
 337     (synopsis "Portable regular expression library for Common Lisp")
 338     (description "CL-PPCRE is a portable regular expression library for Common
 339 Lisp, which is compatible with perl.  It is pretty fast, thread-safe, and
 340 compatible with ANSI-compliant Common Lisp implementations.")
 341     (home-page "http://weitz.de/cl-ppcre/")
 342     (license license:bsd-2)))
 343
 344 (define-public cl-ppcre
 345   (sbcl-package->cl-source-package sbcl-cl-ppcre))
 346
 347 (define-public ecl-cl-ppcre
 348   (sbcl-package->ecl-package sbcl-cl-ppcre))
 349
 350 (define-public sbcl-cl-unicode
 351   (package
 352     (name "sbcl-cl-unicode")
 353     (version "0.1.6")
 354     (source (origin
 355               (method git-fetch)
 356               (uri (git-reference
 357                     (url "https://github.com/edicl/cl-unicode")
 358                     (commit (string-append "v" version))))
 359               (file-name (git-file-name name version))
 360               (sha256
 361                (base32
 362                 "0ykx2s9lqfl74p1px0ik3l2izd1fc9jd1b4ra68s5x34rvjy0hza"))))
 363     (build-system asdf-build-system/sbcl)
 364     (native-inputs
 365      `(("flexi-streams" ,sbcl-flexi-streams)))
 366     (inputs
 367      `(("cl-ppcre" ,sbcl-cl-ppcre)))
 368     (home-page "http://weitz.de/cl-unicode/")
 369     (synopsis "Portable Unicode library for Common Lisp")
 370     (description "CL-UNICODE is a portable Unicode library Common Lisp, which
 371 is compatible with perl.  It is pretty fast, thread-safe, and compatible with
 372 ANSI-compliant Common Lisp implementations.")
 373     (license license:bsd-2)))
 374
 375 (define-public ecl-cl-unicode
 376   (sbcl-package->ecl-package sbcl-cl-unicode))
 377
 378 (define-public cl-unicode
 379   (sbcl-package->cl-source-package sbcl-cl-unicode))
 380
 381 (define-public sbcl-cl-ppcre-unicode
 382   (package (inherit sbcl-cl-ppcre)
 383     (name "sbcl-cl-ppcre-unicode")
 384     (inputs
 385      `(("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
 386        ("sbcl-cl-unicode" ,sbcl-cl-unicode)))
 387     (arguments
 388      `(#:tests? #f ; tests fail with "Component :CL-PPCRE-TEST not found"
 389        #:phases
 390        (modify-phases %standard-phases
 391          (add-after 'unpack 'disable-ppcre
 392            ;; cl-ppcre and cl-ppcre-unicode are put in different packages
 393            ;; to work around the circular dependency between edicl/cl-ppcre
 394            ;; and edicl/cl-unicode.
 395            (lambda _
 396              (delete-file "cl-ppcre.asd")
 397              #t)))))))
 398
 399 (define-public cl-ppcre-unicode
 400   (sbcl-package->cl-source-package sbcl-cl-ppcre-unicode))
 401
 402 (define-public ecl-cl-ppcre-unicode
 403   (sbcl-package->ecl-package sbcl-cl-ppcre-unicode))
 404
 405 (define-public sbcl-zpb-ttf
 406   (package
 407     (name "sbcl-zpb-ttf")
 408     (version "1.0.3")
 409     (source
 410      (origin
 411        (method git-fetch)
 412        (uri (git-reference
 413              (url "https://github.com/xach/zpb-ttf")
 414              (commit (string-append "release-" version))))
 415        (file-name (git-file-name name version))
 416        (sha256
 417         (base32
 418          "1wh66vjijzqlydnrihynpwp6796917xwrh0i9li93c17kyxa74ih"))))
 419     (build-system asdf-build-system/sbcl)
 420     (home-page "https://github.com/xach/zpb-ttf")
 421     (synopsis "TrueType font file access for Common Lisp")
 422     (description
 423      "ZPB-TTF is a TrueType font file parser that provides an interface for
 424 reading typographic metrics, glyph outlines, and other information from the
 425 file.")
 426     (license license:bsd-2)))
 427
 428 (define-public ecl-zpb-ttf
 429   (sbcl-package->ecl-package sbcl-zpb-ttf))
 430
 431 (define-public cl-zpb-ttf
 432   (sbcl-package->cl-source-package sbcl-zpb-ttf))
 433
 434 (define-public sbcl-cl-vectors
 435   (package
 436     (name "sbcl-cl-vectors")
 437     (version "0.1.5")
 438     (source
 439      (origin
 440        (method url-fetch)
 441        (uri (string-append "http://projects.tuxee.net/cl-vectors/"
 442                            "files/cl-vectors-" version ".tar.gz"))
 443        (sha256
 444         (base32
 445          "04lhwi0kq8pkwhgd885pk80m1cp9sfvjjn5zj70s1dnckibhdmqh"))))
 446     (build-system asdf-build-system/sbcl)
 447     (inputs
 448      `(("zpb-ttf" ,sbcl-zpb-ttf)))
 449     (arguments
 450      '(#:asd-systems '("cl-vectors"
 451                        "cl-paths-ttf")))
 452     (home-page "http://projects.tuxee.net/cl-vectors/")
 453     (synopsis "Create, transform and render anti-aliased vectorial paths")
 454     (description
 455      "This is a pure Common Lisp library to create, transform and render
 456 anti-aliased vectorial paths.")
 457     (license license:expat)))
 458
 459 (define-public ecl-cl-vectors
 460   (sbcl-package->ecl-package sbcl-cl-vectors))
 461
 462 (define-public cl-vectors
 463   (sbcl-package->cl-source-package sbcl-cl-vectors))
 464
 465 (define-public sbcl-spatial-trees
 466   ;; There have been no releases.
 467   (let ((commit "81fdad0a0bf109c80a53cc96eca2e093823400ba")
 468         (revision "1"))
 469     (package
 470       (name "sbcl-spatial-trees")
 471       (version (git-version "0" revision commit))
 472       (source
 473        (origin
 474          (method git-fetch)
 475          (uri (git-reference
 476                (url "https://github.com/rpav/spatial-trees")
 477                (commit commit)))
 478          (file-name (git-file-name name version))
 479          (sha256
 480           (base32
 481            "11rhc6h501dwcik2igkszz7b9n515cr99m5pjh4r2qfwgiri6ysa"))))
 482       (build-system asdf-build-system/sbcl)
 483       (arguments
 484        '(#:tests? #f           ; spatial-trees.test requires spatial-trees.nns
 485          #:test-asd-file "spatial-trees.test.asd"))
 486       (native-inputs
 487        `(("fiveam" ,sbcl-fiveam)))
 488       (home-page "https://github.com/rpav/spatial-trees")
 489       (synopsis "Dynamic index data structures for spatially-extended data")
 490       (description
 491        "Spatial-trees is a set of dynamic index data structures for
 492 spatially-extended data.")
 493       (license license:bsd-3))))
 494
 495 (define-public ecl-spatial-trees
 496   (sbcl-package->ecl-package sbcl-spatial-trees))
 497
 498 (define-public cl-spatial-trees
 499   (sbcl-package->cl-source-package sbcl-spatial-trees))
 500
 501 (define-public sbcl-flexichain
 502   ;; There are no releases.
 503   (let ((commit "13d2a6c505ed0abfcd4c4ec7d7145059b06855d6")
 504         (revision "1"))
 505     (package
 506       (name "sbcl-flexichain")
 507       (version "1.5.1")
 508       (source
 509        (origin
 510          (method git-fetch)
 511          (uri (git-reference
 512                (url "https://github.com/robert-strandh/Flexichain")
 513                (commit commit)))
 514          (file-name (git-file-name name version))
 515          (sha256
 516           (base32
 517            "0pfyvhsfbjd2sjb30grfs52r51a428xglv7bwydvpg2lc117qimg"))))
 518       (build-system asdf-build-system/sbcl)
 519       (home-page "https://github.com/robert-strandh/Flexichain.git")
 520       (synopsis "Dynamically add elements to or remove them from sequences")
 521       (description
 522        "This package provides an implementation of the flexichain protocol,
 523 allowing client code to dynamically add elements to, and delete elements from
 524 a sequence (or chain) of such elements.")
 525       (license license:lgpl2.1+))))
 526
 527 (define-public ecl-flexichain
 528   (sbcl-package->ecl-package sbcl-flexichain))
 529
 530 (define-public cl-flexichain
 531   (sbcl-package->cl-source-package sbcl-flexichain))
 532
 533 (define-public sbcl-cl-pdf
 534   ;; There are no releases
 535   (let ((commit "752e337e6d6fc206f09d091a982e7f8e5c404e4e")
 536         (revision "1"))
 537     (package
 538       (name "sbcl-cl-pdf")
 539       (version (git-version "0" revision commit))
 540       (source
 541        (origin
 542          (method git-fetch)
 543          (uri (git-reference
 544                (url "https://github.com/mbattyani/cl-pdf")
 545                (commit commit)))
 546          (file-name (git-file-name name version))
 547          (sha256
 548           (base32
 549            "1cg3k3m3r11ipb8j008y8ipynj97l3xjlpi2knqc9ndmx4r3kb1r"))))
 550       (build-system asdf-build-system/sbcl)
 551       (inputs
 552        `(("iterate" ,sbcl-iterate)
 553          ("zpb-ttf" ,sbcl-zpb-ttf)))
 554       (home-page "https://github.com/mbattyani/cl-pdf")
 555       (synopsis "Common Lisp library for generating PDF files")
 556       (description
 557        "CL-PDF is a cross-platform Common Lisp library for generating PDF
 558 files.")
 559       (license license:bsd-2))))
 560
 561 (define-public ecl-cl-pdf
 562   (sbcl-package->ecl-package sbcl-cl-pdf))
 563
 564 (define-public cl-pdf
 565   (sbcl-package->cl-source-package sbcl-cl-pdf))
 566
 567 (define-public sbcl-clx
 568   (package
 569     (name "sbcl-clx")
 570     (version "0.7.5")
 571     (source
 572      (origin
 573        (method git-fetch)
 574        (uri
 575         (git-reference
 576          (url "https://github.com/sharplispers/clx")
 577          (commit version)))
 578        (sha256
 579         (base32
 580          "1vi67z9hpj5rr4xcmfbfwzmlcc0ah7hzhrmfid6lqdkva238v2wf"))
 581        (file-name (string-append "clx-" version))))
 582     (build-system asdf-build-system/sbcl)
 583     (native-inputs
 584      `(("fiasco" ,sbcl-fiasco)))
 585     (home-page "https://www.cliki.net/portable-clx")
 586     (synopsis "X11 client library for Common Lisp")
 587     (description "CLX is an X11 client library for Common Lisp.  The code was
 588 originally taken from a CMUCL distribution, was modified somewhat in order to
 589 make it compile and run under SBCL, then a selection of patches were added
 590 from other CLXes around the net.")
 591     (license license:x11)))
 592
 593 (define-public cl-clx
 594   (sbcl-package->cl-source-package sbcl-clx))
 595
 596 (define-public ecl-clx
 597   (sbcl-package->ecl-package sbcl-clx))
 598
 599 (define-public sbcl-clx-truetype
 600   (let ((commit "c6e10a918d46632324d5863a8ed067a83fc26de8")
 601         (revision "1"))
 602     (package
 603       (name "sbcl-clx-truetype")
 604       (version (git-version "0.0.1" revision commit))
 605       (source
 606        (origin
 607          (method git-fetch)
 608          (uri (git-reference
 609                (url "https://github.com/l04m33/clx-truetype")
 610                (commit commit)))
 611          (file-name (git-file-name name version))
 612          (sha256
 613           (base32
 614            "079hyp92cjkdfn6bhkxsrwnibiqbz4y4af6nl31lzw6nm91j5j37"))
 615          (modules '((guix build utils)))
 616          (snippet
 617           '(begin
 618              (substitute* "package.lisp"
 619                ((":export") ":export\n   :+font-cache-filename+"))
 620              #t))))
 621       (build-system asdf-build-system/sbcl)
 622       (inputs
 623        `(("clx" ,sbcl-clx)
 624          ("zpb-ttf" ,sbcl-zpb-ttf)
 625          ("cl-vectors" ,sbcl-cl-vectors)
 626          ("cl-fad" ,sbcl-cl-fad)
 627          ("cl-store" ,sbcl-cl-store)
 628          ("trivial-features" ,sbcl-trivial-features)))
 629       (home-page "https://github.com/l04m33/clx-truetype")
 630       (synopsis "Antialiased TrueType font rendering using CLX and XRender")
 631       (description "CLX-TrueType is pure common lisp solution for
 632 antialiased TrueType font rendering using CLX and XRender extension.")
 633       (license license:expat))))
 634
 635 (define-public cl-clx-truetype
 636   (sbcl-package->cl-source-package sbcl-clx-truetype))
 637
 638 (define-public ecl-clx-truetype
 639   (sbcl-package->ecl-package sbcl-clx-truetype))
 640
 641 (define-public sbcl-slynk
 642   (let ((revision "3")
 643         ;; Update together with emacs-sly.
 644         (commit "6a2f543cb21f14104c2253af5a1427b884a987ae"))
 645     (package
 646       (name "sbcl-slynk")
 647       (version (git-version "1.0.0-beta" revision commit))
 648       (source
 649        (origin
 650          (method git-fetch)
 651          (uri
 652           (git-reference
 653            (url "https://github.com/joaotavora/sly")
 654            (commit commit)))
 655          (sha256
 656           (base32 "0wbpg9p9yg2hd62l15pvy50fk3hndq5zzyqlyyf04g368s895144"))
 657          (file-name (git-file-name "slynk" version))
 658          (modules '((guix build utils)
 659                     (ice-9 ftw)))
 660          (snippet
 661           '(begin
 662              ;; Move the contribs into the main source directory for easier
 663              ;; access
 664              (substitute* "slynk/slynk.asd"
 665                (("\\.\\./contrib")
 666                 "contrib")
 667                (("\\(defsystem :slynk/util")
 668                 "(defsystem :slynk/util :depends-on (:slynk)"))
 669              (substitute* "contrib/slynk-trace-dialog.lisp"
 670                (("\\(slynk::reset-inspector\\)") ; Causes problems on load
 671                 "nil"))
 672              (substitute* "contrib/slynk-profiler.lisp"
 673                (("slynk:to-line")
 674                 "slynk-pprint-to-line"))
 675              (substitute* "contrib/slynk-fancy-inspector.lisp"
 676                (("slynk/util") "slynk-util")
 677                ((":compile-toplevel :load-toplevel") ""))
 678              (rename-file "contrib" "slynk/contrib")
 679              ;; Move slynk's contents into the base directory for easier
 680              ;; access
 681              (for-each (lambda (file)
 682                          (unless (string-prefix? "." file)
 683                            (rename-file (string-append "slynk/" file)
 684                                         (string-append "./" (basename file)))))
 685                        (scandir "slynk"))
 686              #t))))
 687       (build-system asdf-build-system/sbcl)
 688       (outputs '("out" "image"))
 689       (arguments
 690        `(#:tests? #f ; No test suite
 691          #:asd-systems '("slynk"
 692                          "slynk/arglists"
 693                          "slynk/util"
 694                          "slynk/fancy-inspector"
 695                          "slynk/package-fu"
 696                          "slynk/mrepl"
 697                          "slynk/trace-dialog"
 698                          "slynk/profiler"
 699                          "slynk/stickers"
 700                          "slynk/indentation"
 701                          "slynk/retro")
 702          #:phases
 703          (modify-phases %standard-phases
 704            (add-after 'create-asdf-configuration 'build-image
 705              (lambda* (#:key outputs #:allow-other-keys)
 706                (build-image (string-append
 707                              (assoc-ref %outputs "image")
 708                              "/bin/slynk")
 709                             %outputs
 710                             #:dependencies '("slynk"
 711                                              "slynk/arglists"
 712                                              "slynk/util"
 713                                              "slynk/fancy-inspector"
 714                                              "slynk/package-fu"
 715                                              "slynk/mrepl"
 716                                              "slynk/trace-dialog"
 717                                              "slynk/profiler"
 718                                              "slynk/stickers"
 719                                              "slynk/indentation"
 720                                              "slynk/retro"))
 721                #t)))))
 722       (synopsis "Common Lisp IDE for Emacs")
 723       (description "SLY is a fork of SLIME, an IDE backend for Common Lisp.
 724 It also features a completely redesigned REPL based on Emacs's own
 725 full-featured @code{comint-mode}, live code annotations, and a consistent interactive
 726 button interface.  Everything can be copied to the REPL.  One can create
 727 multiple inspectors with independent history.")
 728       (home-page "https://github.com/joaotavora/sly")
 729       (license license:public-domain)
 730       (properties `((cl-source-variant . ,(delay cl-slynk)))))))
 731
 732 (define-public cl-slynk
 733   (package
 734     (inherit (sbcl-package->cl-source-package sbcl-slynk))
 735     (name "cl-slynk")))
 736
 737 (define-public ecl-slynk
 738   (package
 739     (inherit sbcl-slynk)
 740     (name "ecl-slynk")
 741     (inputs
 742      (map (match-lambda
 743             ((name pkg . _)
 744              (list name (sbcl-package->ecl-package pkg))))
 745           (package-inputs sbcl-slynk)))
 746     (native-inputs '())
 747     (outputs '("out"))
 748     (arguments
 749      '(#:modules ((guix build union))
 750        #:builder
 751        (begin
 752          (use-modules (ice-9 match)
 753                       (guix build union))
 754          (match %build-inputs
 755            (((names . paths) ...)
 756             (union-build (assoc-ref %outputs "out")
 757                          paths)
 758             #t)))))))
 759
 760 (define-public sbcl-parse-js
 761   (let ((commit "fbadc6029bec7039602abfc06c73bb52970998f6")
 762         (revision "1"))
 763     (package
 764       (name "sbcl-parse-js")
 765       (version (string-append "0.0.0-" revision "." (string-take commit 9)))
 766       (source
 767        (origin
 768          (method git-fetch)
 769          (uri (git-reference
 770                (url "http://marijn.haverbeke.nl/git/parse-js")
 771                (commit commit)))
 772          (file-name (string-append name "-" commit "-checkout"))
 773          (sha256
 774           (base32
 775            "1wddrnr5kiya5s3gp4cdq6crbfy9fqcz7fr44p81502sj3bvdv39"))))
 776       (build-system asdf-build-system/sbcl)
 777       (home-page "https://marijnhaverbeke.nl/parse-js/")
 778       (synopsis "Parse JavaScript")
 779       (description "Parse-js is a Common Lisp package for parsing
 780 JavaScript (ECMAScript 3).  It has basic support for ECMAScript 5.")
 781       (license license:zlib))))
 782
 783 (define-public cl-parse-js
 784   (sbcl-package->cl-source-package sbcl-parse-js))
 785
 786 (define-public ecl-parse-js
 787   (sbcl-package->ecl-package sbcl-parse-js))
 788
 789 (define-public sbcl-parse-number
 790   (package
 791     (name "sbcl-parse-number")
 792     (version "1.7")
 793     (source
 794      (origin
 795        (method git-fetch)
 796        (uri (git-reference
 797               (url "https://github.com/sharplispers/parse-number/")
 798               (commit (string-append "v" version))))
 799        (file-name (git-file-name name version))
 800        (sha256
 801         (base32
 802          "0sk06ib1bhqv9y39vwnnw44vmbc4b0kvqm37xxmkxd4dwchq82d7"))))
 803     (build-system asdf-build-system/sbcl)
 804     (home-page "https://www.cliki.net/PARSE-NUMBER")
 805     (synopsis "Parse numbers")
 806     (description "@code{parse-number} is a library of functions for parsing
 807 strings into one of the standard Common Lisp number types without using the
 808 reader.  @code{parse-number} accepts an arbitrary string and attempts to parse
 809 the string into one of the standard Common Lisp number types, if possible, or
 810 else @code{parse-number} signals an error of type @code{invalid-number}.")
 811     (license license:bsd-3)))
 812
 813 (define-public cl-parse-number
 814   (sbcl-package->cl-source-package sbcl-parse-number))
 815
 816 (define-public ecl-parse-number
 817   (sbcl-package->ecl-package sbcl-parse-number))
 818
 819 (define-public sbcl-iterate
 820   (package
 821     (name "sbcl-iterate")
 822     (version "1.5")
 823     (source
 824      (origin
 825        (method url-fetch)
 826        (uri (string-append "https://common-lisp.net/project/iterate/releases/"
 827                            "iterate-" version ".tar.gz"))
 828        (sha256
 829         (base32
 830          "1lqsbhrkfl0yif46aymvb7l3nb9wdcmj4jyw485blj32jb4famzn"))))
 831     (build-system asdf-build-system/sbcl)
 832     (native-inputs
 833      `(("rt" ,sbcl-rt)))
 834     (home-page "https://common-lisp.net/project/iterate/")
 835     (synopsis "Iteration construct for Common Lisp")
 836     (description "@code{iterate} is an iteration construct for Common Lisp.
 837 It is similar to the @code{CL:LOOP} macro, with these distinguishing marks:
 838
 839 @itemize
 840 @item it is extensible,
 841 @item it helps editors like Emacs indent iterate forms by having a more
 842   lisp-like syntax, and
 843 @item it isn't part of the ANSI standard for Common Lisp.
 844 @end itemize\n")
 845     (license license:expat)))
 846
 847 (define-public cl-iterate
 848   (sbcl-package->cl-source-package sbcl-iterate))
 849
 850 (define-public ecl-iterate
 851   (sbcl-package->ecl-package sbcl-iterate))
 852
 853 (define-public sbcl-cl-uglify-js
 854   ;; There have been many bug fixes since the 2010 release.
 855   (let ((commit "429c5e1d844e2f96b44db8fccc92d6e8e28afdd5")
 856         (revision "1"))
 857     (package
 858       (name "sbcl-cl-uglify-js")
 859       (version (string-append "0.1-" revision "." (string-take commit 9)))
 860       (source
 861        (origin
 862          (method git-fetch)
 863          (uri (git-reference
 864                (url "https://github.com/mishoo/cl-uglify-js")
 865                (commit commit)))
 866          (file-name (git-file-name name version))
 867          (sha256
 868           (base32
 869            "0k39y3c93jgxpr7gwz7w0d8yknn1fdnxrjhd03057lvk5w8js27a"))))
 870       (build-system asdf-build-system/sbcl)
 871       (inputs
 872        `(("sbcl-parse-js" ,sbcl-parse-js)
 873          ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
 874          ("sbcl-cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)
 875          ("sbcl-parse-number" ,sbcl-parse-number)
 876          ("sbcl-iterate" ,sbcl-iterate)))
 877       (home-page "https://github.com/mishoo/cl-uglify-js")
 878       (synopsis "JavaScript compressor library for Common Lisp")
 879       (description "This is a Common Lisp version of UglifyJS, a JavaScript
 880 compressor.  It works on data produced by @code{parse-js} to generate a
 881 @dfn{minified} version of the code.  Currently it can:
 882
 883 @itemize
 884 @item reduce variable names (usually to single letters)
 885 @item join consecutive @code{var} statements
 886 @item resolve simple binary expressions
 887 @item group most consecutive statements using the @code{sequence} operator (comma)
 888 @item remove unnecessary blocks
 889 @item convert @code{IF} expressions in various ways that result in smaller code
 890 @item remove some unreachable code
 891 @end itemize\n")
 892       (license license:zlib))))
 893
 894 (define-public cl-uglify-js
 895   (sbcl-package->cl-source-package sbcl-cl-uglify-js))
 896
 897 (define-public ecl-cl-uglify-js
 898   (sbcl-package->ecl-package sbcl-cl-uglify-js))
 899
 900 (define-public uglify-js
 901   (package
 902     (inherit sbcl-cl-uglify-js)
 903     (name "uglify-js")
 904     (build-system trivial-build-system)
 905     (arguments
 906      `(#:modules ((guix build utils))
 907        #:builder
 908        (let* ((bin    (string-append (assoc-ref %outputs "out") "/bin/"))
 909               (script (string-append bin "uglify-js")))
 910          (use-modules (guix build utils))
 911          (mkdir-p bin)
 912          (with-output-to-file script
 913            (lambda _
 914              (format #t "#!~a/bin/sbcl --script
 915
 916  (require :asdf)
 917  (asdf:initialize-source-registry
 918   #p\"~a/etc/common-lisp/source-registry.conf.d/\")
 919  (asdf:initialize-output-translations
 920   #p\"~a/etc/common-lisp/asdf-output-translations.conf.d/\")"
 921                      (assoc-ref %build-inputs "sbcl")
 922                      (assoc-ref %build-inputs "sbcl-cl-uglify-js")
 923                      (assoc-ref %build-inputs "sbcl-cl-uglify-js"))
 924              ;; FIXME: cannot use progn here because otherwise it fails to
 925              ;; find cl-uglify-js.
 926              (for-each
 927               write
 928               '(;; Quiet, please!
 929                 (let ((*standard-output* (make-broadcast-stream))
 930                       (*error-output* (make-broadcast-stream)))
 931                   (asdf:load-system :cl-uglify-js))
 932                 (let ((file (cadr *posix-argv*)))
 933                   (if file
 934                       (format t "~a"
 935                               (cl-uglify-js:ast-gen-code
 936                                (cl-uglify-js:ast-mangle
 937                                 (cl-uglify-js:ast-squeeze
 938                                  (with-open-file (in file)
 939                                                  (parse-js:parse-js in))))
 940                                :beautify nil))
 941                       (progn
 942                        (format *error-output*
 943                                "Please provide a JavaScript file.~%")
 944                        (sb-ext:exit :code 1))))))))
 945          (chmod script #o755)
 946          #t)))
 947     (inputs
 948      `(("sbcl" ,sbcl)
 949        ("sbcl-cl-uglify-js" ,sbcl-cl-uglify-js)))
 950     (synopsis "JavaScript compressor")))
 951
 952 (define-public sbcl-cl-strings
 953   (let ((revision "1")
 954         (commit "c5c5cbafbf3e6181d03c354d66e41a4f063f00ae"))
 955     (package
 956       (name "sbcl-cl-strings")
 957       (version (git-version "0.0.0" revision commit))
 958       (source
 959        (origin
 960          (method git-fetch)
 961          (uri (git-reference
 962                (url "https://github.com/diogoalexandrefranco/cl-strings")
 963                (commit commit)))
 964          (sha256
 965           (base32
 966            "00754mfaqallj480lwd346nkfb6ra8pa8xcxcylf4baqn604zlmv"))
 967          (file-name (string-append "cl-strings-" version "-checkout"))))
 968       (build-system asdf-build-system/sbcl)
 969       (synopsis "Portable, dependency-free set of utilities to manipulate strings in Common Lisp")
 970       (description
 971        "@command{cl-strings} is a small, portable, dependency-free set of
 972 utilities that make it even easier to manipulate text in Common Lisp.  It has
 973 100% test coverage and works at least on sbcl, ecl, ccl, abcl and clisp.")
 974       (home-page "https://github.com/diogoalexandrefranco/cl-strings")
 975       (license license:expat))))
 976
 977 (define-public cl-strings
 978   (sbcl-package->cl-source-package sbcl-cl-strings))
 979
 980 (define-public ecl-cl-strings
 981   (sbcl-package->ecl-package sbcl-cl-strings))
 982
 983 (define-public sbcl-trivial-features
 984   ;; No release since 2014.
 985   (let ((commit "870d03de0ed44067963350936856e17ee725153e"))
 986     (package
 987       (name "sbcl-trivial-features")
 988       (version (git-version "0.8" "1" commit))
 989       (source
 990        (origin
 991          (method git-fetch)
 992          (uri (git-reference
 993                (url "https://github.com/trivial-features/trivial-features")
 994                (commit commit)))
 995          (file-name (git-file-name "trivial-features" version))
 996          (sha256
 997           (base32 "14pcahr8r2j3idhyy216zyw8jnj1dnrx0qbkkbdqkvwzign1ah4j"))))
 998       (build-system asdf-build-system/sbcl)
 999       (arguments
1000        '(#:asd-files '("trivial-features.asd")
1001          #:tests? #f))
1002       (home-page "https://cliki.net/trivial-features")
1003       (synopsis "Ensures consistency of @code{*FEATURES*} in Common Lisp")
1004       (description "Trivial-features ensures that @code{*FEATURES*} is
1005 consistent across multiple Common Lisp implementations.")
1006       (license license:expat))))
1007
1008 (define-public cl-trivial-features
1009   (sbcl-package->cl-source-package sbcl-trivial-features))
1010
1011 (define-public ecl-trivial-features
1012   (sbcl-package->ecl-package sbcl-trivial-features))
1013
1014 (define-public sbcl-hu.dwim.asdf
1015   (package
1016     (name "sbcl-hu.dwim.asdf")
1017     (version "20190521")
1018     (source
1019      (origin
1020        (method url-fetch)
1021        (uri (string-append "http://beta.quicklisp.org/archive/hu.dwim.asdf/"
1022                            "2019-05-21/hu.dwim.asdf-" version "-darcs.tgz"))
1023        (sha256
1024         (base32
1025          "0rsbv71vyszy8w35yjwb5h6zcmknjq223hkzir79y72qdsc6sabn"))))
1026     (build-system asdf-build-system/sbcl)
1027     (home-page "https://hub.darcs.net/hu.dwim/hu.dwim.asdf")
1028     (synopsis "Extensions to ASDF")
1029     (description "Various ASDF extensions such as attached test and
1030 documentation system, explicit development support, etc.")
1031     (license license:public-domain)))
1032
1033 (define-public cl-hu.dwim.asdf
1034   (sbcl-package->cl-source-package sbcl-hu.dwim.asdf))
1035
1036 (define-public ecl-hu.dwim.asdf
1037   (sbcl-package->ecl-package sbcl-hu.dwim.asdf))
1038
1039 (define-public sbcl-hu.dwim.stefil
1040   (let ((commit "ab6d1aa8995878a1b66d745dfd0ba021090bbcf9"))
1041     (package
1042       (name "sbcl-hu.dwim.stefil")
1043       (version (git-version "0.0.0" "1" commit))
1044       (source
1045        (origin
1046          (method git-fetch)
1047          (uri
1048           (git-reference
1049            (url "https://gitlab.common-lisp.net/xcvb/hu.dwim.stefil.git")
1050            (commit commit)))
1051          (sha256
1052           (base32 "1d8yccw65zj3zh46cbi3x6nmn1dwdb76s9d0av035077mvyirqqp"))
1053          (file-name (git-file-name "hu.dwim.stefil" version))))
1054       (build-system asdf-build-system/sbcl)
1055       (native-inputs
1056        `(("asdf:cl-hu.dwim.asdf" ,sbcl-hu.dwim.asdf)))
1057       (inputs
1058        `(("sbcl-alexandria" ,sbcl-alexandria)))
1059       (home-page "https://hub.darcs.net/hu.dwim/hu.dwim.stefil")
1060       (synopsis "Simple test framework")
1061       (description "Stefil is a simple test framework for Common Lisp,
1062 with a focus on interactive development.")
1063       (license license:public-domain))))
1064
1065 (define-public cl-hu.dwim.stefil
1066   (sbcl-package->cl-source-package sbcl-hu.dwim.stefil))
1067
1068 (define-public ecl-hu.dwim.stefil
1069   (sbcl-package->ecl-package sbcl-hu.dwim.stefil))
1070
1071 (define-public sbcl-babel
1072   ;; No release since 2014.
1073   (let ((commit "aeed2d1b76358db48e6b70a64399c05678a6b9ea"))
1074     (package
1075       (name "sbcl-babel")
1076       (version (git-version "0.5.0" "1" commit))
1077       (source
1078        (origin
1079          (method git-fetch)
1080          (uri (git-reference
1081                (url "https://github.com/cl-babel/babel")
1082                (commit commit)))
1083          (file-name (git-file-name "babel" version))
1084          (sha256
1085           (base32 "0lkvv4xdpv4cv1y2bqillmabx8sdb2y4l6pbinq6mjh33w2brpvb"))))
1086       (build-system asdf-build-system/sbcl)
1087       (native-inputs
1088        `(("tests:cl-hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
1089       (inputs
1090        `(("sbcl-alexandria" ,sbcl-alexandria)
1091          ("sbcl-trivial-features" ,sbcl-trivial-features)))
1092       (home-page "https://common-lisp.net/project/babel/")
1093       (synopsis "Charset encoding and decoding library")
1094       (description "Babel is a charset encoding and decoding library, not unlike
1095 GNU libiconv, but completely written in Common Lisp.")
1096       (license license:expat))))
1097
1098 (define-public cl-babel
1099   (sbcl-package->cl-source-package sbcl-babel))
1100
1101 (define-public ecl-babel
1102   (sbcl-package->ecl-package sbcl-babel))
1103
1104 (define-public sbcl-cl-yacc
1105   (package
1106     (name "sbcl-cl-yacc")
1107     (version "0.3")
1108     (source
1109      (origin
1110        (method git-fetch)
1111        (uri (git-reference
1112              (url "https://github.com/jech/cl-yacc")
1113              (commit (string-append "cl-yacc-" version))))
1114        (sha256
1115         (base32
1116          "16946pzf8vvadnyfayvj8rbh4zjzw90h0azz2qk1mxrvhh5wklib"))
1117        (file-name (string-append "cl-yacc-" version "-checkout"))))
1118     (build-system asdf-build-system/sbcl)
1119     (arguments
1120      `(#:asd-systems '("yacc")))
1121     (synopsis "LALR(1) parser generator for Common Lisp, similar in spirit to Yacc")
1122     (description
1123      "CL-Yacc is a LALR(1) parser generator for Common Lisp, similar in spirit
1124 to AT&T Yacc, Berkeley Yacc, GNU Bison, Zebu, lalr.cl or lalr.scm.
1125
1126 CL-Yacc uses the algorithm due to Aho and Ullman, which is the one also used
1127 by AT&T Yacc, Berkeley Yacc and Zebu.  It does not use the faster algorithm due
1128 to DeRemer and Pennello, which is used by Bison and lalr.scm (not lalr.cl).")
1129     (home-page "https://www.irif.fr/~jch//software/cl-yacc/")
1130     (license license:expat)))
1131
1132 (define-public cl-yacc
1133   (sbcl-package->cl-source-package sbcl-cl-yacc))
1134
1135 (define-public ecl-cl-yacc
1136   (sbcl-package->ecl-package sbcl-cl-yacc))
1137
1138 (define-public sbcl-jpl-util
1139   (let ((commit "0311ed374e19a49d43318064d729fe3abd9a3b62"))
1140     (package
1141       (name "sbcl-jpl-util")
1142       (version "20151005")
1143       (source
1144        (origin
1145          (method git-fetch)
1146          (uri (git-reference
1147                ;; Quicklisp uses this fork.
1148                (url "https://github.com/hawkir/cl-jpl-util")
1149                (commit commit)))
1150          (file-name
1151           (git-file-name "jpl-util" version))
1152          (sha256
1153           (base32
1154            "0nc0rk9n8grkg3045xsw34whmcmddn2sfrxki4268g7kpgz0d2yz"))))
1155       (build-system asdf-build-system/sbcl)
1156       (synopsis "Collection of Common Lisp utility functions and macros")
1157       (description
1158        "@command{cl-jpl-util} is a collection of Common Lisp utility functions
1159 and macros, primarily for software projects written in CL by the author.")
1160       (home-page "https://www.thoughtcrime.us/software/cl-jpl-util/")
1161       (license license:isc))))
1162
1163 (define-public cl-jpl-util
1164   (sbcl-package->cl-source-package sbcl-jpl-util))
1165
1166 (define-public ecl-jpl-util
1167   (sbcl-package->ecl-package sbcl-jpl-util))
1168
1169 (define-public sbcl-jpl-queues
1170   (package
1171     (name "sbcl-jpl-queues")
1172     (version "0.1")
1173     (source
1174      (origin
1175        (method url-fetch)
1176        (uri (string-append
1177              "http://www.thoughtcrime.us/software/jpl-queues/jpl-queues-"
1178              version
1179              ".tar.gz"))
1180        (sha256
1181         (base32
1182          "1wvvv7j117h9a42qaj1g4fh4mji28xqs7s60rn6d11gk9jl76h96"))))
1183     (build-system asdf-build-system/sbcl)
1184     (inputs
1185      `(("jpl-util" ,sbcl-jpl-util)
1186        ("bordeaux-threads" ,sbcl-bordeaux-threads)))
1187     (arguments
1188      ;; Tests seem to be broken.
1189      `(#:tests? #f))
1190     (synopsis "Common Lisp library implementing a few different kinds of queues")
1191     (description
1192      "A Common Lisp library implementing a few different kinds of queues:
1193
1194 @itemize
1195 @item Bounded and unbounded FIFO queues.
1196 @item Lossy bounded FIFO queues that drop elements when full.
1197 @item Unbounded random-order queues that use less memory than unbounded FIFO queues.
1198 @end itemize
1199
1200 Additionally, a synchronization wrapper is provided to make any queue
1201 conforming to the @command{jpl-queues} API thread-safe for lightweight
1202 multithreading applications.  (See Calispel for a more sophisticated CL
1203 multithreaded message-passing library with timeouts and alternation among
1204 several blockable channels.)")
1205     (home-page "https://www.thoughtcrime.us/software/jpl-queues/")
1206     (license license:isc)))
1207
1208 (define-public cl-jpl-queues
1209   (sbcl-package->cl-source-package sbcl-jpl-queues))
1210
1211 (define-public ecl-jpl-queues
1212   (sbcl-package->ecl-package sbcl-jpl-queues))
1213
1214 (define-public sbcl-eos
1215   (let ((commit "b4413bccc4d142cbe1bf49516c3a0a22c9d99243")
1216         (revision "2"))
1217     (package
1218       (name "sbcl-eos")
1219       (version (git-version "0.0.0" revision commit))
1220       (source
1221        (origin
1222          (method git-fetch)
1223          (uri (git-reference
1224                (url "https://github.com/adlai/Eos")
1225                (commit commit)))
1226          (sha256
1227           (base32 "1afllvmlnx97yzz404gycl3pa3kwx427k3hrbf37rpmjlv47knhk"))
1228          (file-name (git-file-name "eos" version))))
1229       (build-system asdf-build-system/sbcl)
1230       (synopsis "Unit Testing for Common Lisp")
1231       (description
1232        "Eos was a unit testing library for Common Lisp.
1233 It began as a fork of FiveAM; however, FiveAM development has continued, while
1234 that of Eos has not.  Thus, Eos is now deprecated in favor of FiveAM.")
1235       (home-page "https://github.com/adlai/Eos")
1236       (license license:expat))))
1237
1238 (define-public cl-eos
1239   (sbcl-package->cl-source-package sbcl-eos))
1240
1241 (define-public ecl-eos
1242   (sbcl-package->ecl-package sbcl-eos))
1243
1244 (define-public sbcl-esrap
1245   (let ((commit "133be8b05c2aae48696fe5b739eea2fa573fa48d"))
1246     (package
1247       (name "sbcl-esrap")
1248       (version (git-version "0.0.0" "1" commit))
1249       (source
1250        (origin
1251          (method git-fetch)
1252          (uri (git-reference
1253                (url "https://github.com/nikodemus/esrap")
1254                (commit commit)))
1255          (sha256
1256           (base32
1257            "02d5clihsdryhf7pix8c5di2571fdsffh75d40fkzhws90r5mksl"))
1258          (file-name (git-file-name "esrap" version))))
1259       (build-system asdf-build-system/sbcl)
1260       (native-inputs
1261        `(("eos" ,sbcl-eos)))            ;For testing only.
1262       (inputs
1263        `(("alexandria" ,sbcl-alexandria)))
1264       (synopsis "Common Lisp packrat parser")
1265       (description
1266        "A packrat parser for Common Lisp.
1267 In addition to regular Packrat / Parsing Grammar / TDPL features ESRAP supports:
1268
1269 @itemize
1270 @item dynamic redefinition of nonterminals
1271 @item inline grammars
1272 @item semantic predicates
1273 @item introspective facilities (describing grammars, tracing, setting breaks)
1274 @end itemize\n")
1275       (home-page "https://nikodemus.github.io/esrap/")
1276       (license license:expat))))
1277
1278 (define-public cl-esrap
1279   (sbcl-package->cl-source-package sbcl-esrap))
1280
1281 (define-public ecl-esrap
1282   (sbcl-package->ecl-package sbcl-esrap))
1283
1284 (define-public sbcl-split-sequence
1285   (package
1286     (name "sbcl-split-sequence")
1287     (version "2.0.0")
1288     (source
1289      (origin
1290        (method git-fetch)
1291        (uri (git-reference
1292              (url "https://github.com/sharplispers/split-sequence")
1293              (commit (string-append "v" version))))
1294        (sha256
1295         (base32
1296          "0jcpnx21hkfwqj5fvp7kc6pn1qcz9hk7g2s5x8h0349x1j2irln0"))
1297        (file-name (git-file-name "split-sequence" version))))
1298     (build-system asdf-build-system/sbcl)
1299     (native-inputs
1300      `(("fiveam" ,sbcl-fiveam)))
1301     (synopsis "Member of the Common Lisp Utilities family of programs")
1302     (description
1303      "Splits sequence into a list of subsequences delimited by objects
1304 satisfying the test.")
1305     (home-page "https://cliki.net/split-sequence")
1306     (license license:expat)))
1307
1308 (define-public cl-split-sequence
1309   (sbcl-package->cl-source-package sbcl-split-sequence))
1310
1311 (define-public ecl-split-sequence
1312   (sbcl-package->ecl-package sbcl-split-sequence))
1313
1314 (define-public sbcl-html-encode
1315   (package
1316     (name "sbcl-html-encode")
1317     (version "1.2")
1318     (source
1319      (origin
1320        (method url-fetch)
1321        (uri (string-append
1322              "http://beta.quicklisp.org/archive/html-encode/2010-10-06/html-encode-"
1323              version ".tgz"))
1324        (sha256
1325         (base32
1326          "06mf8wn95yf5swhmzk4vp0xr4ylfl33dgfknkabbkd8n6jns8gcf"))
1327        (file-name (string-append "colorize" version "-checkout"))))
1328     (build-system asdf-build-system/sbcl)
1329     (synopsis "Common Lisp library for encoding text in various web-savvy encodings")
1330     (description
1331      "A library for encoding text in various web-savvy encodings.")
1332     (home-page "http://quickdocs.org/html-encode/")
1333     (license license:expat)))
1334
1335 (define-public cl-html-encode
1336   (sbcl-package->cl-source-package sbcl-html-encode))
1337
1338 (define-public ecl-html-encode
1339   (sbcl-package->ecl-package sbcl-html-encode))
1340
1341 (define-public sbcl-colorize
1342   (let ((commit "ea676b584e0899cec82f21a9e6871172fe3c0eb5"))
1343     (package
1344       (name "sbcl-colorize")
1345       (version (git-version "0.0.0" "1" commit))
1346       (source
1347        (origin
1348          (method git-fetch)
1349          (uri (git-reference
1350                (url "https://github.com/kingcons/colorize")
1351                (commit commit)))
1352          (sha256
1353           (base32
1354            "1pdg4kiaczmr3ivffhirp7m3lbr1q27rn7dhaay0vwghmi31zcw9"))
1355          (file-name (git-file-name "colorize" version))))
1356       (build-system asdf-build-system/sbcl)
1357       (inputs
1358        `(("alexandria" ,sbcl-alexandria)
1359          ("split-sequence" ,sbcl-split-sequence)
1360          ("html-encode" ,sbcl-html-encode)))
1361       (synopsis "Common Lisp for syntax highlighting")
1362       (description
1363        "@command{colorize} is a Lisp library for syntax highlighting
1364 supporting the following languages: Common Lisp, Emacs Lisp, Scheme, Clojure,
1365 C, C++, Java, Python, Erlang, Haskell, Objective-C, Diff, Webkit.")
1366       (home-page "https://github.com/kingcons/colorize")
1367       ;; TODO: Missing license?
1368       (license license:expat))))
1369
1370 (define-public cl-colorize
1371   (sbcl-package->cl-source-package sbcl-colorize))
1372
1373 (define-public ecl-colorize
1374   (sbcl-package->ecl-package sbcl-colorize))
1375
1376 (define-public sbcl-3bmd
1377   (let ((commit "192ea13435b605a96ef607df51317056914cabbd"))
1378     (package
1379       (name "sbcl-3bmd")
1380       (version (git-version "0.0.0" "1" commit))
1381       (source
1382        (origin
1383          (method git-fetch)
1384          (uri (git-reference
1385                (url "https://github.com/3b/3bmd")
1386                (commit commit)))
1387          (sha256
1388           (base32
1389            "1rgv3gi7wf963ikmmpk132wgn0icddf226gq3bmcnk1fr3v9gf2f"))
1390          (file-name (git-file-name "3bmd" version))))
1391       (build-system asdf-build-system/sbcl)
1392       (arguments
1393        ;; FIXME: We need to specify the name because the build-system thinks
1394        ;; "3" is a version marker.
1395        `(#:asd-systems '("3bmd"
1396                          "3bmd-ext-code-blocks")))
1397       (inputs
1398        `(("colorize" ,sbcl-colorize)
1399          ("esrap" ,sbcl-esrap)
1400          ("split-sequence" ,sbcl-split-sequence)))
1401       (synopsis "Markdown processor in Command Lisp using esrap parser")
1402       (description
1403        "Common Lisp Markdown -> HTML converter, using @command{esrap} for
1404 parsing, and grammar based on @command{peg-markdown}.")
1405       (home-page "https://github.com/3b/3bmd")
1406       (license license:expat))))
1407
1408 (define-public cl-3bmd
1409   (sbcl-package->cl-source-package sbcl-3bmd))
1410
1411 (define-public ecl-3bmd
1412   (sbcl-package->ecl-package sbcl-3bmd))
1413
1414 (define-public sbcl-cl-fad
1415   (package
1416     (name "sbcl-cl-fad")
1417     (version "0.7.6")
1418     (source
1419      (origin
1420        (method git-fetch)
1421        (uri (git-reference
1422              (url "https://github.com/edicl/cl-fad/")
1423              (commit (string-append "v" version))))
1424        (sha256
1425         (base32
1426          "1gc8i82v6gks7g0lnm54r4prk2mklidv2flm5fvbr0a7rsys0vpa"))
1427        (file-name (string-append "cl-fad" version "-checkout"))))
1428     (build-system asdf-build-system/sbcl)
1429     (inputs
1430      `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
1431     (synopsis "Portable pathname library for Common Lisp")
1432     (description
1433      "CL-FAD (for \"Files and Directories\") is a thin layer atop Common
1434 Lisp's standard pathname functions.  It is intended to provide some
1435 unification between current CL implementations on Windows, OS X, Linux, and
1436 Unix.  Most of the code was written by Peter Seibel for his book Practical
1437 Common Lisp.")
1438     (home-page "https://edicl.github.io/cl-fad/")
1439     (license license:bsd-2)))
1440
1441 (define-public cl-fad
1442   (sbcl-package->cl-source-package sbcl-cl-fad))
1443
1444 (define-public ecl-cl-fad
1445   (sbcl-package->ecl-package sbcl-cl-fad))
1446
1447 (define-public sbcl-rt
1448   (let ((commit "a6a7503a0b47953bc7579c90f02a6dba1f6e4c5a")
1449         (revision "1"))
1450     (package
1451       (name "sbcl-rt")
1452       (version (git-version "1990.12.19" revision commit))
1453       (source
1454        (origin
1455          (method git-fetch)
1456          (uri (git-reference
1457                (url "http://git.kpe.io/rt.git")
1458                (commit commit)))
1459          (file-name (git-file-name name version))
1460          (sha256
1461           (base32 "13si2rrxaagbr0bkvg6sqicxxpyshabx6ad6byc9n2ik5ysna69b"))))
1462       (build-system asdf-build-system/sbcl)
1463       (synopsis "MIT Regression Tester")
1464       (description
1465        "RT provides a framework for writing regression test suites.")
1466       (home-page "https://www.cliki.net/rt")
1467       (license license:expat))))
1468
1469 (define-public cl-rt
1470   (sbcl-package->cl-source-package sbcl-rt))
1471
1472 (define-public ecl-rt
1473   (sbcl-package->ecl-package sbcl-rt))
1474
1475 (define-public sbcl-nibbles
1476   (package
1477     (name "sbcl-nibbles")
1478     (version "0.14")
1479     (source
1480      (origin
1481        (method git-fetch)
1482        (uri (git-reference
1483              (url "https://github.com/sharplispers/nibbles/")
1484              (commit (string-append "v" version))))
1485        (sha256
1486         (base32
1487          "1v7qfgpvdr6nz7v63dj69d26dis0kff3rd8xamr1llfdvza2pm8f"))
1488        (file-name (git-file-name "nibbles" version))))
1489     (build-system asdf-build-system/sbcl)
1490     (native-inputs
1491      ;; Tests only.
1492      `(("rt" ,sbcl-rt)))
1493     (synopsis "Common Lisp library for accessing octet-addressed blocks of data")
1494     (description
1495      "When dealing with network protocols and file formats, it's common to
1496 have to read or write 16-, 32-, or 64-bit datatypes in signed or unsigned
1497 flavors.  Common Lisp sort of supports this by specifying :element-type for
1498 streams, but that facility is underspecified and there's nothing similar for
1499 read/write from octet vectors.  What most people wind up doing is rolling their
1500 own small facility for their particular needs and calling it a day.
1501
1502 This library attempts to be comprehensive and centralize such
1503 facilities.  Functions to read 16-, 32-, and 64-bit quantities from octet
1504 vectors in signed or unsigned flavors are provided; these functions are also
1505 SETFable.  Since it's sometimes desirable to read/write directly from streams,
1506 functions for doing so are also provided.  On some implementations,
1507 reading/writing IEEE singles/doubles (i.e. single-float and double-float) will
1508 also be supported.")
1509     (home-page "https://github.com/sharplispers/nibbles")
1510     (license license:bsd-3)))
1511
1512 (define-public cl-nibbles
1513   (sbcl-package->cl-source-package sbcl-nibbles))
1514
1515 (define-public ecl-nibbles
1516   (sbcl-package->ecl-package sbcl-nibbles))
1517
1518 (define-public sbcl-ironclad
1519   (package
1520     (name "sbcl-ironclad")
1521     (version "0.51")
1522     (source
1523      (origin
1524        (method git-fetch)
1525        (uri (git-reference
1526              (url "https://github.com/sharplispers/ironclad/")
1527              (commit (string-append "v" version))))
1528        (sha256
1529         (base32 "1zxkzbxsfb83bb87rhp4h75cc1h5f6ziyfa5lvaa30zgix9l2d7v"))
1530        (file-name (git-file-name name version))))
1531     (build-system asdf-build-system/sbcl)
1532     (native-inputs
1533      ;; Tests only.
1534      `(("rt" ,sbcl-rt)))
1535     (inputs
1536      `(("bordeaux-threads" ,sbcl-bordeaux-threads)
1537        ("flexi-streams" ,sbcl-flexi-streams)))
1538     (synopsis "Cryptographic toolkit written in Common Lisp")
1539     (description
1540      "Ironclad is a cryptography library written entirely in Common Lisp.
1541 It includes support for several popular ciphers, digests, MACs and public key
1542 cryptography algorithms.  For several implementations that support Gray
1543 streams, support is included for convenient stream wrappers.")
1544     (home-page "https://github.com/sharplispers/ironclad")
1545     (license license:bsd-3)))
1546
1547 (define-public cl-ironclad
1548   (sbcl-package->cl-source-package sbcl-ironclad))
1549
1550 (define-public ecl-ironclad
1551   (sbcl-package->ecl-package sbcl-ironclad))
1552
1553 (define-public sbcl-named-readtables
1554   (let ((commit "64bd53f37a1694cfde48fc38b8f03901f6f0c05b")
1555         (revision "2"))
1556     (package
1557       (name "sbcl-named-readtables")
1558       (version (git-version "0.9" revision commit))
1559       (source
1560        (origin
1561          (method git-fetch)
1562          (uri (git-reference
1563                (url "https://github.com/melisgl/named-readtables")
1564                (commit commit)))
1565          (sha256
1566           (base32 "01l4831m7k84qvhzyx0qgdl50isr4zmp40qf6dfq2iqcaj8y4h3n"))
1567          (file-name (git-file-name "named-readtables" version))))
1568       (build-system asdf-build-system/sbcl)
1569       (arguments
1570        ;; Tests seem to be broken.
1571        `(#:tests? #f))
1572       (home-page "https://github.com/melisgl/named-readtables/")
1573       (synopsis "Library that creates a namespace for named readtables")
1574       (description "Named readtables is a library that creates a namespace for
1575 named readtables, which is akin to package namespacing in Common Lisp.")
1576       (license license:bsd-3))))
1577
1578 (define-public cl-named-readtables
1579   (sbcl-package->cl-source-package sbcl-named-readtables))
1580
1581 (define-public ecl-named-readtables
1582   (sbcl-package->ecl-package sbcl-named-readtables))
1583
1584 (define-public sbcl-pythonic-string-reader
1585   (let ((commit "47a70ba1e32362e03dad6ef8e6f36180b560f86a"))
1586     (package
1587       (name "sbcl-pythonic-string-reader")
1588       (version (git-version "0.0.0" "1" commit))
1589       (source
1590        (origin
1591          (method git-fetch)
1592          (uri (git-reference
1593                (url "https://github.com/smithzvk/pythonic-string-reader/")
1594                (commit commit)))
1595          (sha256
1596           (base32 "1b5iryqw8xsh36swckmz8rrngmc39k92si33fgy5pml3n9l5rq3j"))
1597          (file-name (git-file-name "pythonic-string-reader" version))))
1598       (build-system asdf-build-system/sbcl)
1599       (inputs
1600        `(("named-readtables" ,sbcl-named-readtables)))
1601       (home-page "https://github.com/smithzvk/pythonic-string-reader")
1602       (synopsis "Read table modification inspired by Python's three quote strings")
1603       (description "This piece of code sets up some reader macros that make it
1604 simpler to input string literals which contain backslashes and double quotes
1605 This is very useful for writing complicated docstrings and, as it turns out,
1606 writing code that contains string literals that contain code themselves.")
1607       (license license:bsd-3))))
1608
1609 (define-public cl-pythonic-string-reader
1610   (sbcl-package->cl-source-package sbcl-pythonic-string-reader))
1611
1612 (define-public ecl-pythonic-string-reader
1613   (sbcl-package->ecl-package sbcl-pythonic-string-reader))
1614
1615 (define-public sbcl-slime-swank
1616   (package
1617     (name "sbcl-slime-swank")
1618     (version "2.24")
1619     (source
1620      (origin
1621        (file-name (git-file-name "slime-swank" version))
1622        (method git-fetch)
1623        (uri (git-reference
1624              (url "https://github.com/slime/slime/")
1625              (commit (string-append "v" version))))
1626        (sha256
1627         (base32
1628          "0js24x42m7b5iymb4rxz501dff19vav5pywnzv50b673rbkaaqvh"))))
1629     (build-system asdf-build-system/sbcl)
1630     (arguments
1631      '(#:asd-systems '("swank")))
1632     (home-page "https://github.com/slime/slime")
1633     (synopsis "Common Lisp Swank server")
1634     (description
1635      "This is only useful if you want to start a Swank server in a Lisp
1636 processes that doesn't run under Emacs.  Lisp processes created by
1637 @command{M-x slime} automatically start the server.")
1638     (license (list license:gpl2+ license:public-domain))))
1639
1640 (define-public cl-slime-swank
1641   (sbcl-package->cl-source-package sbcl-slime-swank))
1642
1643 (define-public ecl-slime-swank
1644   (sbcl-package->ecl-package sbcl-slime-swank))
1645
1646 (define-public sbcl-mgl-pax
1647   (let ((commit "818448418d6b9de74620f606f5b23033c6082769"))
1648     (package
1649       (name "sbcl-mgl-pax")
1650       (version (git-version "0.0.0" "1" commit))
1651       (source
1652        (origin
1653          (method git-fetch)
1654          (uri (git-reference
1655                (url "https://github.com/melisgl/mgl-pax")
1656                (commit commit)))
1657          (sha256
1658           (base32
1659            "1p97zfkh130bdxqqxwaw2j9psv58751wakx7czbfpq410lg7dd7i"))
1660          (file-name (git-file-name "mgl-pax" version))))
1661       (build-system asdf-build-system/sbcl)
1662       (inputs
1663        `(("3bmd" ,sbcl-3bmd)
1664          ("babel" ,sbcl-babel)
1665          ("cl-fad" ,sbcl-cl-fad)
1666          ("ironclad" ,sbcl-ironclad)
1667          ("named-readtables" ,sbcl-named-readtables)
1668          ("pythonic-string-reader" ,sbcl-pythonic-string-reader)
1669          ("swank" ,sbcl-slime-swank)))
1670       (synopsis "Exploratory programming environment and documentation generator")
1671       (description
1672        "PAX provides an extremely poor man's Explorable Programming
1673 environment.  Narrative primarily lives in so called sections that mix markdown
1674 docstrings with references to functions, variables, etc, all of which should
1675 probably have their own docstrings.
1676
1677 The primary focus is on making code easily explorable by using SLIME's
1678 @command{M-.} (@command{slime-edit-definition}).  See how to enable some
1679 fanciness in Emacs Integration.  Generating documentation from sections and all
1680 the referenced items in Markdown or HTML format is also implemented.
1681
1682 With the simplistic tools provided, one may accomplish similar effects as with
1683 Literate Programming, but documentation is generated from code, not vice versa
1684 and there is no support for chunking yet.  Code is first, code must look
1685 pretty, documentation is code.")
1686       (home-page "http://quotenil.com/")
1687       (license license:expat))))
1688
1689 (define-public cl-mgl-pax
1690   (sbcl-package->cl-source-package sbcl-mgl-pax))
1691
1692 (define-public ecl-mgl-pax
1693   (sbcl-package->ecl-package sbcl-mgl-pax))
1694
1695 (define-public sbcl-lisp-unit
1696   (let ((commit "89653a232626b67400bf9a941f9b367da38d3815"))
1697     (package
1698       (name "sbcl-lisp-unit")
1699       (version (git-version "0.0.0" "1" commit))
1700       (source
1701        (origin
1702          (method git-fetch)
1703          (uri (git-reference
1704                (url "https://github.com/OdonataResearchLLC/lisp-unit")
1705                (commit commit)))
1706          (sha256
1707           (base32
1708            "0p6gdmgr7p383nvd66c9y9fp2bjk4jx1lpa5p09g43hr9y9pp9ry"))
1709          (file-name (git-file-name "lisp-unit" version))))
1710       (build-system asdf-build-system/sbcl)
1711       (synopsis "Common Lisp Test framework inspired by JUnit to be simple of use")
1712       (description
1713        "@command{lisp-unit} is a Common Lisp library that supports unit
1714 testing.  It is an extension of the library written by Chris Riesbeck.")
1715       (home-page "https://github.com/OdonataResearchLLC/lisp-unit")
1716       (license license:expat))))
1717
1718 (define-public cl-lisp-unit
1719   (sbcl-package->cl-source-package sbcl-lisp-unit))
1720
1721 (define-public ecl-lisp-unit
1722   (sbcl-package->ecl-package sbcl-lisp-unit))
1723
1724 (define-public sbcl-anaphora
1725   (package
1726     (name "sbcl-anaphora")
1727     (version "0.9.6")
1728     (source
1729      (origin
1730        (method git-fetch)
1731        (uri (git-reference
1732              (url "https://github.com/tokenrove/anaphora")
1733              (commit version)))
1734        (sha256
1735         (base32
1736          "19wfrk3asimznkli0x2rfy637hwpdgqyvwj3vhq9x7vjvyf5vv6x"))
1737        (file-name (git-file-name "anaphora" version))))
1738     (build-system asdf-build-system/sbcl)
1739     (native-inputs
1740      `(("rt" ,sbcl-rt)))
1741     (synopsis "The anaphoric macro collection from Hell")
1742     (description
1743      "Anaphora is the anaphoric macro collection from Hell: it includes many
1744 new fiends in addition to old friends like @command{aif} and
1745 @command{awhen}.")
1746     (home-page "https://github.com/tokenrove/anaphora")
1747     (license license:public-domain)))
1748
1749 (define-public cl-anaphora
1750   (sbcl-package->cl-source-package sbcl-anaphora))
1751
1752 (define-public ecl-anaphora
1753   (sbcl-package->ecl-package sbcl-anaphora))
1754
1755 (define-public sbcl-lift
1756   (let ((commit "7d49a66c62759535624037826891152223d4206c"))
1757     (package
1758       (name "sbcl-lift")
1759       (version (git-version "1.7.1" "1" commit))
1760       (source
1761        (origin
1762          (method git-fetch)
1763          (uri (git-reference
1764                (url "https://github.com/gwkkwg/lift")
1765                (commit commit)))
1766          (sha256
1767           (base32
1768            "127v5avpz1i4m0lkaxqrq8hrl69rdazqaxf6s8awf0nd7wj2g4dp"))
1769          (file-name (git-file-name "lift" version))
1770          (modules '((guix build utils)))
1771          (snippet
1772           ;; Don't keep the bundled website
1773           `(begin
1774              (delete-file-recursively "website")
1775              #t))))
1776       (build-system asdf-build-system/sbcl)
1777       (arguments
1778        ;; The tests require a debugger, but we run with the debugger disabled.
1779        '(#:tests? #f))
1780       (synopsis "LIsp Framework for Testing")
1781       (description
1782        "The LIsp Framework for Testing (LIFT) is a unit and system test tool for LISP.
1783 Though inspired by SUnit and JUnit, it's built with Lisp in mind.  In LIFT,
1784 testcases are organized into hierarchical testsuites each of which can have
1785 its own fixture.  When run, a testcase can succeed, fail, or error.  LIFT
1786 supports randomized testing, benchmarking, profiling, and reporting.")
1787       (home-page "https://github.com/gwkkwg/lift")
1788       (license license:expat))))
1789
1790 (define-public cl-lift
1791   (sbcl-package->cl-source-package sbcl-lift))
1792
1793 (define-public ecl-lift
1794   (sbcl-package->ecl-package sbcl-lift))
1795
1796 (define-public sbcl-let-plus
1797   (let ((commit "5f14af61d501ecead02ec6b5a5c810efc0c9fdbb"))
1798     (package
1799       (name "sbcl-let-plus")
1800       (version (git-version "0.0.0" "1" commit))
1801       (source
1802        (origin
1803          (method git-fetch)
1804          (uri (git-reference
1805                (url "https://github.com/sharplispers/let-plus")
1806                (commit commit)))
1807          (sha256
1808           (base32
1809            "0i050ca2iys9f5mb7dgqgqdxfnc3b0rnjdwv95sqd490vkiwrsaj"))
1810          (file-name (git-file-name "let-plus" version))))
1811       (build-system asdf-build-system/sbcl)
1812       (inputs
1813        `(("alexandria" ,sbcl-alexandria)
1814          ("anaphora" ,sbcl-anaphora)))
1815       (native-inputs
1816        `(("lift" ,sbcl-lift)))
1817       (synopsis "Destructuring extension of let*")
1818       (description
1819        "This library implements the let+ macro, which is a dectructuring
1820 extension of let*.  It features:
1821
1822 @itemize
1823 @item Clean, consistent syntax and small implementation (less than 300 LOC,
1824 not counting tests)
1825 @item Placeholder macros allow editor hints and syntax highlighting
1826 @item @command{&ign} for ignored values (in forms where that makes sense)
1827 @item Very easy to extend
1828 @end itemize\n")
1829       (home-page "https://github.com/sharplispers/let-plus")
1830       (license license:boost1.0))))
1831
1832 (define-public cl-let-plus
1833   (sbcl-package->cl-source-package sbcl-let-plus))
1834
1835 (define-public ecl-let-plus
1836   (sbcl-package->ecl-package sbcl-let-plus))
1837
1838 (define-public sbcl-cl-colors
1839   (let ((commit "827410584553f5c717eec6182343b7605f707f75"))
1840     (package
1841       (name "sbcl-cl-colors")
1842       (version (git-version "0.0.0" "1" commit))
1843       (source
1844        (origin
1845          (method git-fetch)
1846          (uri (git-reference
1847                (url "https://github.com/tpapp/cl-colors")
1848                (commit commit)))
1849          (sha256
1850           (base32
1851            "0l446lday4hybsm9bq3jli97fvv8jb1d33abg79vbylpwjmf3y9a"))
1852          (file-name (git-file-name "cl-colors" version))))
1853       (build-system asdf-build-system/sbcl)
1854       (inputs
1855        `(("alexandria" ,sbcl-alexandria)
1856          ("let-plus" ,sbcl-let-plus)))
1857       (synopsis "Simple color library for Common Lisp")
1858       (description
1859        "This is a very simple color library for Common Lisp, providing
1860
1861 @itemize
1862 @item Types for representing colors in HSV and RGB spaces.
1863 @item Simple conversion functions between the above types (and also
1864 hexadecimal representation for RGB).
1865 @item Some predefined colors (currently X11 color names – of course the
1866 library does not depend on X11).Because color in your terminal is nice.
1867 @end itemize
1868
1869 This library is no longer supported by its author.")
1870       (home-page "https://github.com/tpapp/cl-colors")
1871       (license license:boost1.0))))
1872
1873 (define-public cl-colors
1874   (sbcl-package->cl-source-package sbcl-cl-colors))
1875
1876 (define-public ecl-cl-colors
1877   (sbcl-package->ecl-package sbcl-cl-colors))
1878
1879 (define-public sbcl-cl-ansi-text
1880   (let ((commit "53badf7878f27f22f2d4a2a43e6df458e43acbe9"))
1881     (package
1882       (name "sbcl-cl-ansi-text")
1883       (version (git-version "1.0.0" "1" commit))
1884       (source
1885        (origin
1886          (method git-fetch)
1887          (uri (git-reference
1888                (url "https://github.com/pnathan/cl-ansi-text")
1889                (commit commit)))
1890          (sha256
1891           (base32
1892            "11i27n0dbz5lmygiw65zzr8lx0rac6b6yysqranphn31wls6ja3v"))
1893          (file-name (git-file-name "cl-ansi-text" version))))
1894       (build-system asdf-build-system/sbcl)
1895       (inputs
1896        `(("alexandria" ,sbcl-alexandria)
1897          ("cl-colors" ,sbcl-cl-colors)))
1898       (native-inputs
1899        `(("fiveam" ,sbcl-fiveam)))
1900       (synopsis "ANSI terminal color implementation for Common Lisp")
1901       (description
1902        "@command{cl-ansi-text} provides utilities which enable printing to an
1903 ANSI terminal with colored text.  It provides the macro @command{with-color}
1904 which causes everything printed in the body to be displayed with the provided
1905 color.  It further provides functions which will print the argument with the
1906 named color.")
1907       (home-page "https://github.com/pnathan/cl-ansi-text")
1908       (license license:llgpl))))
1909
1910 (define-public cl-ansi-text
1911   (sbcl-package->cl-source-package sbcl-cl-ansi-text))
1912
1913 (define-public ecl-cl-ansi-text
1914   (sbcl-package->ecl-package sbcl-cl-ansi-text))
1915
1916 (define-public sbcl-prove
1917   (let ((commit "4f9122bd393e63c5c70c1fba23070622317cfaa0"))
1918     (package
1919       (name "sbcl-prove")
1920       (version (git-version "1.0.0" "1" commit))
1921       (source
1922        (origin
1923          (method git-fetch)
1924          (uri (git-reference
1925                (url "https://github.com/fukamachi/prove")
1926                (commit commit)))
1927          (sha256
1928           (base32
1929            "07sbfw459z8bbjvx1qlmfa8qk2mvbjnnzi2mi0x72blaj8bkl4vc"))
1930          (file-name (git-file-name "prove" version))))
1931       (build-system asdf-build-system/sbcl)
1932       (inputs
1933        `(("alexandria" ,sbcl-alexandria)
1934          ("cl-ppcre" ,sbcl-cl-ppcre)
1935          ("cl-ansi-text" ,sbcl-cl-ansi-text)))
1936       (synopsis "Yet another unit testing framework for Common Lisp")
1937       (description
1938        "This project was originally called @command{cl-test-more}.
1939 @command{prove} is yet another unit testing framework for Common Lisp.  The
1940 advantages of @command{prove} are:
1941
1942 @itemize
1943 @item Various simple functions for testing and informative error messages
1944 @item ASDF integration
1945 @item Extensible test reporters
1946 @item Colorizes the report if it's available (note for SLIME)
1947 @item Reports test durations
1948 @end itemize\n")
1949       (home-page "https://github.com/fukamachi/prove")
1950       (license license:expat))))
1951
1952 (define-public cl-prove
1953   (sbcl-package->cl-source-package sbcl-prove))
1954
1955 (define-public ecl-prove
1956   (sbcl-package->ecl-package sbcl-prove))
1957
1958 (define-public sbcl-proc-parse
1959   (let ((commit "ac3636834d561bdc2686c956dbd82494537285fd"))
1960     (package
1961       (name "sbcl-proc-parse")
1962       (version (git-version "0.0.0" "1" commit))
1963       (source
1964        (origin
1965          (method git-fetch)
1966          (uri (git-reference
1967                (url "https://github.com/fukamachi/proc-parse")
1968                (commit commit)))
1969          (sha256
1970           (base32
1971            "06rnl0h4cx6xv2wj3jczmmcxqn2703inmmvg1s4npbghmijsybfh"))
1972          (file-name (git-file-name "proc-parse" version))))
1973       (build-system asdf-build-system/sbcl)
1974       (inputs
1975        `(("alexandria" ,sbcl-alexandria)
1976          ("babel" ,sbcl-babel)))
1977       (native-inputs
1978        `(("prove" ,sbcl-prove)))
1979       (arguments
1980        ;; TODO: Tests don't find "proc-parse-test", why?
1981        `(#:tests? #f))
1982       (synopsis "Procedural vector parser")
1983       (description
1984        "This is a string/octets parser library for Common Lisp with speed and
1985 readability in mind.  Unlike other libraries, the code is not a
1986 pattern-matching-like, but a char-by-char procedural parser.")
1987       (home-page "https://github.com/fukamachi/proc-parse")
1988       (license license:bsd-2))))
1989
1990 (define-public cl-proc-parse
1991   (sbcl-package->cl-source-package sbcl-proc-parse))
1992
1993 (define-public ecl-proc-parse
1994   (sbcl-package->ecl-package sbcl-proc-parse))
1995
1996 (define-public sbcl-parse-float
1997   (let ((commit "2aae569f2a4b2eb3bfb5401a959425dcf151b09c"))
1998     (package
1999       (name "sbcl-parse-float")
2000       (version (git-version "0.0.0" "1" commit))
2001       (source
2002        (origin
2003          (method git-fetch)
2004          (uri (git-reference
2005                (url "https://github.com/soemraws/parse-float")
2006                (commit commit)))
2007          (sha256
2008           (base32
2009            "08xw8cchhmqcc0byng69m3f5a2izc9y2290jzz2k0qrbibp1fdk7"))
2010          (file-name (git-file-name "proc-parse" version))))
2011       (build-system asdf-build-system/sbcl)
2012       (inputs
2013        `(("alexandria" ,sbcl-alexandria)
2014          ("babel" ,sbcl-babel)))
2015       (native-inputs
2016        `(("prove" ,sbcl-prove)))
2017       (arguments
2018        ;; TODO: Tests don't find "proc-parse-test", why?
2019        `(#:tests? #f))
2020       (synopsis "Parse a floating point value from a string in Common Lisp")
2021       (description
2022        "This package exports the following function to parse floating-point
2023 values from a string in Common Lisp.")
2024       (home-page "https://github.com/soemraws/parse-float")
2025       (license license:public-domain))))
2026
2027 (define-public cl-parse-float
2028   (sbcl-package->cl-source-package sbcl-parse-float))
2029
2030 (define-public ecl-parse-float
2031   (sbcl-package->ecl-package sbcl-parse-float))
2032
2033 (define-public sbcl-cl-string-match
2034   (let ((revision "1")
2035         (changeset "5048480a61243e6f1b02884012c8f25cdbee6d97"))
2036     (package
2037       (name "sbcl-cl-string-match")
2038       (version (git-version "0" revision changeset))
2039       (source
2040        (origin
2041          (method hg-fetch)
2042          (uri (hg-reference
2043                (url "https://bitbucket.org/vityok/cl-string-match/")
2044                (changeset changeset)))
2045          (sha256
2046           (base32
2047            "01wn5qx562w43ssy92xlfgv79w7p0nv0wbl76mpmba131n9ziq2y"))
2048          (file-name (git-file-name "cl-string-match" version))))
2049       (build-system asdf-build-system/sbcl)
2050       (inputs
2051        `(("alexandria" ,sbcl-alexandria)
2052          ("babel" ,sbcl-babel)
2053          ("iterate" ,sbcl-iterate)
2054          ("jpl-queues" ,sbcl-jpl-queues)
2055          ("jpl-util" ,sbcl-jpl-util)
2056          ("mgl-pax" ,sbcl-mgl-pax)
2057          ("parse-float" ,sbcl-parse-float)
2058          ("proc-parse" ,sbcl-proc-parse)
2059          ("yacc" ,sbcl-cl-yacc)))
2060       ;; TODO: Tests are not evaluated properly.
2061       (native-inputs
2062        ;; For testing:
2063        `(("lisp-unit" ,sbcl-lisp-unit)))
2064       (arguments
2065        `(#:tests? #f))
2066       (synopsis "Set of utilities to manipulate strings in Common Lisp")
2067       (description
2068        "@command{cl-strings} is a small, portable, dependency-free set of
2069 utilities that make it even easier to manipulate text in Common Lisp.  It has
2070 100% test coverage and works at least on sbcl, ecl, ccl, abcl and clisp.")
2071       (home-page "https://bitbucket.org/vityok/cl-string-match/")
2072       (license license:bsd-3))))
2073
2074 (define-public cl-string-match
2075   (sbcl-package->cl-source-package sbcl-cl-string-match))
2076
2077 (define-public ecl-cl-string-match
2078   (sbcl-package->ecl-package sbcl-cl-string-match))
2079
2080 (define-public sbcl-ptester
2081   (let ((commit "fe69fde54f4bce00ce577feb918796c293fc7253")
2082         (revision "1"))
2083     (package
2084       (name "sbcl-ptester")
2085       (version (git-version "2.1.3" revision commit))
2086       (source
2087        (origin
2088          (method git-fetch)
2089          (uri (git-reference
2090                (url "http://git.kpe.io/ptester.git")
2091                (commit commit)))
2092          (file-name (git-file-name name version))
2093          (sha256
2094           (base32 "1l0lfl7cdnr2qf4zh38hi4llxg22c49zkm639bdkmvlkzwj3ndwf"))))
2095       (build-system asdf-build-system/sbcl)
2096       (home-page "http://quickdocs.org/ptester/")
2097       (synopsis "Portable test harness package")
2098       (description
2099        "@command{ptester} is a portable testing framework based on Franz's
2100 tester module.")
2101       (license license:llgpl))))
2102
2103 (define-public cl-ptester
2104   (sbcl-package->cl-source-package sbcl-ptester))
2105
2106 (define-public ecl-ptester
2107   (sbcl-package->ecl-package sbcl-ptester))
2108
2109 (define-public sbcl-puri
2110   (let ((commit "ef5afb9e5286c8e952d4344f019c1a636a717b97")
2111         (revision "1"))
2112     (package
2113       (name "sbcl-puri")
2114       (version (git-version "1.5.7" revision commit))
2115       (source
2116        (origin
2117          (method git-fetch)
2118          (uri (git-reference
2119                (url "http://git.kpe.io/puri.git")
2120                (commit commit)))
2121          (file-name (git-file-name name version))
2122          (sha256
2123           (base32 "1vm25pdl92laj72p5vyd538kf3cjy2655z6bdc99h20ana2p231s"))))
2124       (build-system asdf-build-system/sbcl)
2125       (native-inputs
2126        `(("ptester" ,sbcl-ptester)))
2127       (home-page "http://quickdocs.org/puri/")
2128       (synopsis "Portable URI Library")
2129       (description
2130        "This is a portable Universal Resource Identifier library for Common
2131 Lisp programs.  It parses URI according to the RFC 2396 specification.")
2132       (license license:llgpl))))
2133
2134 (define-public cl-puri
2135   (sbcl-package->cl-source-package sbcl-puri))
2136
2137 (define-public ecl-puri
2138   (sbcl-package->ecl-package sbcl-puri))
2139
2140 (define-public sbcl-queues
2141   (let ((commit "47d4da65e9ea20953b74aeeab7e89a831b66bc94"))
2142     (package
2143       (name "sbcl-queues")
2144       (version (git-version "0.0.0" "1" commit))
2145       (source
2146        (origin
2147          (method git-fetch)
2148          (uri (git-reference
2149                (url "https://github.com/oconnore/queues")
2150                (commit commit)))
2151          (file-name (git-file-name "queues" version))
2152          (sha256
2153           (base32
2154            "0wdhfnzi4v6d97pggzj2aw55si94w4327br94jrmyvwf351wqjvv"))))
2155       (build-system asdf-build-system/sbcl)
2156       (inputs
2157        `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
2158       (arguments
2159        '(#:asd-systems '("queues"
2160                          "queues.simple-queue"
2161                          "queues.simple-cqueue"
2162                          "queues.priority-queue"
2163                          "queues.priority-cqueue")))
2164       (home-page "https://github.com/oconnore/queues")
2165       (synopsis "Common Lisp queue library")
2166       (description
2167        "This is a simple queue library for Common Lisp with features such as
2168 non-consing thread safe queues and fibonacci priority queues.")
2169       (license license:expat))))
2170
2171 (define-public cl-queues
2172   (sbcl-package->cl-source-package sbcl-queues))
2173
2174 (define-public ecl-queues
2175   (sbcl-package->ecl-package sbcl-queues))
2176
2177 (define-public sbcl-cffi
2178   (package
2179     (name "sbcl-cffi")
2180     (version "0.21.0")
2181     (source
2182      (origin
2183        (method git-fetch)
2184        (uri (git-reference
2185              (url "https://github.com/cffi/cffi")
2186              (commit (string-append "v" version))))
2187        (file-name (git-file-name "cffi-bootstrap" version))
2188        (sha256
2189         (base32 "1qalargz9bhp850qv60ffwpdqi4xirzar4l3g6qcg8yc6xqf2cjk"))))
2190     (build-system asdf-build-system/sbcl)
2191     (inputs
2192      `(("alexandria" ,sbcl-alexandria)
2193        ("babel" ,sbcl-babel)
2194        ("libffi" ,libffi)
2195        ("trivial-features" ,sbcl-trivial-features)))
2196     (native-inputs
2197      `(("bordeaux-threads" ,sbcl-bordeaux-threads)
2198        ("pkg-config" ,pkg-config)
2199        ("rt" ,sbcl-rt)))
2200     (arguments
2201      '(#:phases
2202        (modify-phases %standard-phases
2203          (add-after 'unpack 'fix-paths
2204            (lambda* (#:key inputs #:allow-other-keys)
2205              (substitute* "libffi/libffi.lisp"
2206                (("libffi.so.7" all) (string-append
2207                                      (assoc-ref inputs "libffi")
2208                                      "/lib/" all)))
2209              (substitute* "toolchain/c-toolchain.lisp"
2210                (("\"cc\"") (format #f "~S" (which "gcc"))))))
2211          (add-after 'build 'install-headers
2212            (lambda* (#:key outputs #:allow-other-keys)
2213              (install-file "grovel/common.h"
2214                            (string-append
2215                             (assoc-ref outputs "out")
2216                             "/include/grovel")))))
2217        #:asd-files '("cffi.asd"
2218                      "cffi-toolchain.asd"
2219                      "cffi-grovel.asd"
2220                      "cffi-libffi.asd"
2221                      "cffi-uffi-compat.asd")
2222        #:asd-systems '("cffi"
2223                        "cffi-libffi"
2224                        "cffi-uffi-compat")))
2225     (home-page "https://common-lisp.net/project/cffi/")
2226     (synopsis "Common Foreign Function Interface for Common Lisp")
2227     (description "The Common Foreign Function Interface (CFFI)
2228 purports to be a portable foreign function interface for Common Lisp.
2229 The CFFI library is composed of a Lisp-implementation-specific backend
2230 in the CFFI-SYS package, and a portable frontend in the CFFI
2231 package.")
2232     (license license:expat)))
2233
2234 (define-public cl-cffi
2235   (sbcl-package->cl-source-package sbcl-cffi))
2236
2237 (define-public ecl-cffi
2238   (sbcl-package->ecl-package sbcl-cffi))
2239
2240 (define-public sbcl-cl-sqlite
2241   (package
2242     (name "sbcl-cl-sqlite")
2243     (version "0.2.1")
2244     (source
2245      (origin
2246        (method git-fetch)
2247        (uri (git-reference
2248              (url "https://github.com/dmitryvk/cl-sqlite")
2249              (commit version)))
2250        (file-name (git-file-name "cl-sqlite" version))
2251        (sha256
2252         (base32
2253          "08iv7b4m0hh7qx2cvq4f510nrgdld0vicnvmqsh9w0fgrcgmyg4k"))))
2254     (build-system asdf-build-system/sbcl)
2255     (inputs
2256      `(("iterate" ,sbcl-iterate)
2257        ("cffi" ,sbcl-cffi)
2258        ("sqlite" ,sqlite)))
2259     (native-inputs
2260      `(("fiveam" ,sbcl-fiveam)
2261        ("bordeaux-threads" ,sbcl-bordeaux-threads)))
2262     (arguments
2263      `(#:asd-systems '("sqlite")
2264        #:phases
2265        (modify-phases %standard-phases
2266          (add-after 'unpack 'fix-paths
2267            (lambda* (#:key inputs #:allow-other-keys)
2268              (substitute* "sqlite-ffi.lisp"
2269                (("libsqlite3" all) (string-append
2270                                     (assoc-ref inputs "sqlite")"/lib/" all))))))))
2271     (home-page "https://common-lisp.net/project/cl-sqlite/")
2272     (synopsis "Common Lisp binding for SQLite")
2273     (description
2274      "The @command{cl-sqlite} package is an interface to the SQLite embedded
2275 relational database engine.")
2276     (license license:public-domain)))
2277
2278 (define-public cl-sqlite
2279   (sbcl-package->cl-source-package sbcl-cl-sqlite))
2280
2281 (define-public ecl-cl-sqlite
2282   (sbcl-package->ecl-package sbcl-cl-sqlite))
2283
2284 (define-public sbcl-parenscript
2285   ;; Source archives are overwritten on every release, we use the Git repo instead.
2286   (let ((commit "7a1ac46353cecd144fc91915ba9f122aafcf4766"))
2287     (package
2288       (name "sbcl-parenscript")
2289       (version (git-version "2.7.1" "1" commit))
2290       (source
2291        (origin
2292          (method git-fetch)
2293          (uri (git-reference
2294                (url "https://gitlab.common-lisp.net/parenscript/parenscript")
2295                (commit commit)))
2296          (file-name (git-file-name "parenscript" version))
2297          (sha256
2298           (base32
2299            "0c22lqarrpbq82dg1sb3y6mp6w2faczp34ymzhnmff88yfq1xzsf"))))
2300       (build-system asdf-build-system/sbcl)
2301       (inputs
2302        `(("cl-ppcre" ,sbcl-cl-ppcre)
2303          ("anaphora" ,sbcl-anaphora)
2304          ("named-readtables" ,sbcl-named-readtables)))
2305       (home-page "https://common-lisp.net/project/parenscript/")
2306       (synopsis "Translator from a subset of Common Lisp to JavaScript")
2307       (description
2308        "Parenscript is a translator from an extended subset of Common Lisp to
2309 JavaScript.  Parenscript code can run almost identically on both the
2310 browser (as JavaScript) and server (as Common Lisp).
2311
2312 Parenscript code is treated the same way as Common Lisp code, making the full
2313 power of Lisp macros available for JavaScript.  This provides a web
2314 development environment that is unmatched in its ability to reduce code
2315 duplication and provide advanced meta-programming facilities to web
2316 developers.
2317
2318 At the same time, Parenscript is different from almost all other \"language
2319 X\" to JavaScript translators in that it imposes almost no overhead:
2320
2321 @itemize
2322 @item No run-time dependencies: Any piece of Parenscript code is runnable
2323 as-is.  There are no JavaScript files to include.
2324 @item Native types: Parenscript works entirely with native JavaScript data
2325 types.  There are no new types introduced, and object prototypes are not
2326 touched.
2327 @item Native calling convention: Any JavaScript code can be called without the
2328 need for bindings.  Likewise, Parenscript can be used to make efficient,
2329 self-contained JavaScript libraries.
2330 @item Readable code: Parenscript generates concise, formatted, idiomatic
2331 JavaScript code.  Identifier names are preserved.  This enables seamless
2332 debugging in tools like Firebug.
2333 @item Efficiency: Parenscript introduces minimal overhead for advanced Common
2334 Lisp features.  The generated code is almost as fast as hand-written
2335 JavaScript.
2336 @end itemize\n")
2337       (license license:bsd-3))))
2338
2339 (define-public cl-parenscript
2340   (sbcl-package->cl-source-package sbcl-parenscript))
2341
2342 (define-public ecl-parenscript
2343   (sbcl-package->ecl-package sbcl-parenscript))
2344
2345 (define-public sbcl-cl-json
2346   (let ((commit "6dfebb9540bfc3cc33582d0c03c9ec27cb913e79"))
2347     (package
2348       (name "sbcl-cl-json")
2349       (version (git-version "0.5" "1" commit))
2350       (source
2351        (origin
2352          (method git-fetch)
2353          (uri (git-reference
2354                (url "https://github.com/hankhero/cl-json")
2355                (commit commit)))
2356          (file-name (git-file-name "cl-json" version))
2357          (sha256
2358           (base32
2359            "0fx3m3x3s5ji950yzpazz4s0img3l6b3d6l3jrfjv0lr702496lh"))))
2360       (build-system asdf-build-system/sbcl)
2361       (native-inputs
2362        `(("fiveam" ,sbcl-fiveam)))
2363       (home-page "https://github.com/hankhero/cl-json")
2364       (synopsis "JSON encoder and decoder for Common-Lisp")
2365       (description
2366        "@command{cl-json} provides an encoder of Lisp objects to JSON format
2367 and a corresponding decoder of JSON data to Lisp objects.  Both the encoder
2368 and the decoder are highly customizable; at the same time, the default
2369 settings ensure a very simple mode of operation, similar to that provided by
2370 @command{yason} or @command{st-json}.")
2371       (license license:expat))))
2372
2373 (define-public cl-json
2374   (sbcl-package->cl-source-package sbcl-cl-json))
2375
2376 (define-public ecl-cl-json
2377   (sbcl-package->ecl-package sbcl-cl-json))
2378
2379 (define-public sbcl-unix-opts
2380   (package
2381     (name "sbcl-unix-opts")
2382     (version "0.1.7")
2383     (source
2384      (origin
2385        (method git-fetch)
2386        (uri (git-reference
2387              (url "https://github.com/libre-man/unix-opts")
2388              (commit version)))
2389        (file-name (git-file-name "unix-opts" version))
2390        (sha256
2391         (base32
2392          "08djdi1ard09fijb7w9bdmhmwd98b1hzmcnjw9fqjiqa0g3b44rr"))))
2393     (build-system asdf-build-system/sbcl)
2394     (home-page "https://github.com/hankhero/cl-json")
2395     (synopsis "Unix-style command line options parser")
2396     (description
2397      "This is a minimalistic parser of command line options.  The main
2398 advantage of the library is the ability to concisely define command line
2399 options once and then use this definition for parsing and extraction of
2400 command line arguments, as well as printing description of command line
2401 options (you get --help for free).  This way you don't need to repeat
2402 yourself.  Also, @command{unix-opts} doesn't depend on anything and
2403 precisely controls the behavior of the parser via Common Lisp restarts.")
2404     (license license:expat)))
2405
2406 (define-public cl-unix-opts
2407   (sbcl-package->cl-source-package sbcl-unix-opts))
2408
2409 (define-public ecl-unix-opts
2410   (sbcl-package->ecl-package sbcl-unix-opts))
2411
2412 (define-public sbcl-trivial-garbage
2413   (package
2414     (name "sbcl-trivial-garbage")
2415     (version "0.21")
2416     (source
2417      (origin
2418        (method git-fetch)
2419        (uri (git-reference
2420              (url "https://github.com/trivial-garbage/trivial-garbage")
2421              (commit (string-append "v" version))))
2422        (file-name (git-file-name "trivial-garbage" version))
2423        (sha256
2424         (base32 "0122jicfg7pca1wxw8zak1n92h5friqy60988ns0ysksj3fphw9n"))))
2425     (build-system asdf-build-system/sbcl)
2426     (native-inputs
2427      `(("rt" ,sbcl-rt)))
2428     (home-page "https://common-lisp.net/project/trivial-garbage/")
2429     (synopsis "Portable GC-related APIs for Common Lisp")
2430     (description "@command{trivial-garbage} provides a portable API to
2431 finalizers, weak hash-tables and weak pointers on all major implementations of
2432 the Common Lisp programming language.")
2433     (license license:public-domain)))
2434
2435 (define-public cl-trivial-garbage
2436   (sbcl-package->cl-source-package sbcl-trivial-garbage))
2437
2438 (define-public ecl-trivial-garbage
2439   (sbcl-package->ecl-package sbcl-trivial-garbage))
2440
2441 (define-public sbcl-closer-mop
2442   (let ((commit "19c9d33f576e10715fd79cc1d4f688dab0f241d6"))
2443     (package
2444       (name "sbcl-closer-mop")
2445       (version (git-version  "1.0.0" "2" commit))
2446       (source
2447        (origin
2448          (method git-fetch)
2449          (uri (git-reference
2450                (url "https://github.com/pcostanza/closer-mop")
2451                (commit commit)))
2452          (sha256
2453           (base32 "1w3x087wvlwkd6swfdgbvjfs6kazf0la8ax4pjfzikwjch4snn2c"))
2454          (file-name (git-file-name "closer-mop" version ))))
2455       (build-system asdf-build-system/sbcl)
2456       (home-page "https://github.com/pcostanza/closer-mop")
2457       (synopsis "Rectifies absent or incorrect CLOS MOP features")
2458       (description "Closer to MOP is a compatibility layer that rectifies many
2459 of the absent or incorrect CLOS MOP features across a broad range of Common
2460 Lisp implementations.")
2461       (license license:expat))))
2462
2463 (define-public cl-closer-mop
2464   (sbcl-package->cl-source-package sbcl-closer-mop))
2465
2466 (define-public ecl-closer-mop
2467   (sbcl-package->ecl-package sbcl-closer-mop))
2468
2469 (define-public sbcl-cl-cffi-gtk
2470   (let ((commit "412d17214e092220c65a5660f5cbbd9cb69b8fe4"))
2471     (package
2472       (name "sbcl-cl-cffi-gtk")
2473       (version (git-version "0.11.2" "1" commit))
2474       (source
2475        (origin
2476          (method git-fetch)
2477          (uri (git-reference
2478                (url "https://github.com/Ferada/cl-cffi-gtk/")
2479                (commit commit)))
2480          (file-name (git-file-name "cl-cffi-gtk" version))
2481          (sha256
2482           (base32
2483            "0n997yhcnzk048nalx8ys62ja2ac8iv4mbn3mb55iapl0321hghn"))))
2484       (build-system asdf-build-system/sbcl)
2485       (native-inputs
2486        `(("fiveam" ,sbcl-fiveam)))
2487       (inputs
2488        `(("bordeaux-threads" ,sbcl-bordeaux-threads)
2489          ("cairo" ,cairo)
2490          ("cffi" ,sbcl-cffi)
2491          ("closer-mop" ,sbcl-closer-mop)
2492          ("gdk-pixbuf" ,gdk-pixbuf)
2493          ("glib" ,glib)
2494          ("gtk" ,gtk+)
2495          ("iterate" ,sbcl-iterate)
2496          ("pango" ,pango)
2497          ("trivial-features" ,sbcl-trivial-features)
2498          ("trivial-garbage" ,sbcl-trivial-garbage)))
2499       (arguments
2500        `(#:asd-files '("gtk/cl-cffi-gtk.asd"
2501                        "glib/cl-cffi-gtk-glib.asd"
2502                        "gobject/cl-cffi-gtk-gobject.asd"
2503                        "gio/cl-cffi-gtk-gio.asd"
2504                        "cairo/cl-cffi-gtk-cairo.asd"
2505                        "pango/cl-cffi-gtk-pango.asd"
2506                        "gdk-pixbuf/cl-cffi-gtk-gdk-pixbuf.asd"
2507                        "gdk/cl-cffi-gtk-gdk.asd")
2508          #:test-asd-file "test/cl-cffi-gtk-test.asd"
2509          ;; TODO: Tests fail with memory fault.
2510          ;; See https://github.com/Ferada/cl-cffi-gtk/issues/24.
2511          #:tests? #f
2512          #:phases
2513          (modify-phases %standard-phases
2514            (add-after 'unpack 'fix-paths
2515              (lambda* (#:key inputs #:allow-other-keys)
2516                (substitute* "glib/glib.init.lisp"
2517                  (("libglib|libgthread" all)
2518                   (string-append (assoc-ref inputs "glib") "/lib/" all)))
2519                (substitute* "gobject/gobject.init.lisp"
2520                  (("libgobject" all)
2521                   (string-append (assoc-ref inputs "glib") "/lib/" all)))
2522                (substitute* "gio/gio.init.lisp"
2523                  (("libgio" all)
2524                   (string-append (assoc-ref inputs "glib") "/lib/" all)))
2525                (substitute* "cairo/cairo.init.lisp"
2526                  (("libcairo" all)
2527                   (string-append (assoc-ref inputs "cairo") "/lib/" all)))
2528                (substitute* "pango/pango.init.lisp"
2529                  (("libpango" all)
2530                   (string-append (assoc-ref inputs "pango") "/lib/" all)))
2531                (substitute* "gdk-pixbuf/gdk-pixbuf.init.lisp"
2532                  (("libgdk_pixbuf" all)
2533                   (string-append (assoc-ref inputs "gdk-pixbuf") "/lib/" all)))
2534                (substitute* "gdk/gdk.init.lisp"
2535                  (("libgdk" all)
2536                   (string-append (assoc-ref inputs "gtk") "/lib/" all)))
2537                (substitute* "gdk/gdk.package.lisp"
2538                  (("libgtk" all)
2539                   (string-append (assoc-ref inputs "gtk") "/lib/" all))))))))
2540       (home-page "https://github.com/Ferada/cl-cffi-gtk/")
2541       (synopsis "Common Lisp binding for GTK+3")
2542       (description
2543        "@command{cl-cffi-gtk} is a Lisp binding to GTK+ 3 (GIMP Toolkit) which
2544 is a library for creating graphical user interfaces.")
2545       (license license:lgpl3))))
2546
2547 (define-public cl-cffi-gtk
2548   (sbcl-package->cl-source-package sbcl-cl-cffi-gtk))
2549
2550 (define-public ecl-cl-cffi-gtk
2551   (sbcl-package->ecl-package sbcl-cl-cffi-gtk))
2552
2553 (define-public sbcl-cl-webkit
2554   (let ((commit "dccf9d25de4e9a69f716f8ed9578e58963ead967"))
2555     (package
2556       (name "sbcl-cl-webkit")
2557       (version (git-version "2.4" "5" commit))
2558       (source
2559        (origin
2560          (method git-fetch)
2561          (uri (git-reference
2562                (url "https://github.com/joachifm/cl-webkit")
2563                (commit commit)))
2564          (file-name (git-file-name "cl-webkit" version))
2565          (sha256
2566           (base32
2567            "0cn43ks2mgqkfnalq1p997z6q5pr1sfvz99gvvr5fp7r1acn7v5w"))))
2568       (build-system asdf-build-system/sbcl)
2569       (inputs
2570        `(("cffi" ,sbcl-cffi)
2571          ("cl-cffi-gtk" ,sbcl-cl-cffi-gtk)
2572          ("webkitgtk" ,webkitgtk)))
2573       (arguments
2574        `(#:asd-systems '("cl-webkit2")
2575          #:phases
2576          (modify-phases %standard-phases
2577            (add-after 'unpack 'fix-paths
2578              (lambda* (#:key inputs #:allow-other-keys)
2579                (substitute* "webkit2/webkit2.init.lisp"
2580                  (("libwebkit2gtk" all)
2581                   (string-append
2582                    (assoc-ref inputs "webkitgtk") "/lib/" all))))))))
2583       (home-page "https://github.com/joachifm/cl-webkit")
2584       (synopsis "Binding to WebKitGTK+ for Common Lisp")
2585       (description
2586        "@command{cl-webkit} is a binding to WebKitGTK+ for Common Lisp,
2587 currently targeting WebKit version 2.  The WebKitGTK+ library adds web
2588 browsing capabilities to an application, leveraging the full power of the
2589 WebKit browsing engine.")
2590       (license license:expat))))
2591
2592 (define-public cl-webkit
2593   (sbcl-package->cl-source-package sbcl-cl-webkit))
2594
2595 (define-public ecl-cl-webkit
2596   (sbcl-package->ecl-package sbcl-cl-webkit))
2597
2598 (define-public sbcl-lparallel
2599   (package
2600     (name "sbcl-lparallel")
2601     (version "2.8.4")
2602     (source
2603      (origin
2604        (method git-fetch)
2605        (uri (git-reference
2606              (url "https://github.com/lmj/lparallel/")
2607              (commit (string-append "lparallel-" version))))
2608        (file-name (git-file-name "lparallel" version))
2609        (sha256
2610         (base32
2611          "0g0aylrbbrqsz0ahmwhvnk4cmc2931fllbpcfgzsprwnqqd7vwq9"))))
2612     (build-system asdf-build-system/sbcl)
2613     (inputs
2614      `(("alexandria" ,sbcl-alexandria)
2615        ("bordeaux-threads" ,sbcl-bordeaux-threads)
2616        ("trivial-garbage" ,sbcl-trivial-garbage)))
2617     (arguments
2618      `(#:phases
2619        (modify-phases %standard-phases
2620          (add-after 'unpack 'fix-dependency
2621            ;; lparallel loads a SBCL specific system in its asd file. This is
2622            ;; not carried over into the fasl which is generated. In order for
2623            ;; it to be carried over, it needs to be listed as a dependency.
2624            (lambda _
2625              (substitute* "lparallel.asd"
2626                ((":depends-on \\(:alexandria" all)
2627                 (string-append all " #+sbcl :sb-cltl2"))))))))
2628     (home-page "https://lparallel.org/")
2629     (synopsis "Parallelism for Common Lisp")
2630     (description
2631      "@command{lparallel} is a library for parallel programming in Common
2632 Lisp, featuring:
2633
2634 @itemize
2635 @item a simple model of task submission with receiving queue,
2636 @item constructs for expressing fine-grained parallelism,
2637 @item asynchronous condition handling across thread boundaries,
2638 @item parallel versions of map, reduce, sort, remove, and many others,
2639 @item promises, futures, and delayed evaluation constructs,
2640 @item computation trees for parallelizing interconnected tasks,
2641 @item bounded and unbounded FIFO queues,
2642 @item high and low priority tasks,
2643 @item task killing by category,
2644 @item integrated timeouts.
2645 @end itemize\n")
2646     (license license:expat)))
2647
2648 (define-public cl-lparallel
2649   (sbcl-package->cl-source-package sbcl-lparallel))
2650
2651 (define-public ecl-lparallel
2652   (sbcl-package->ecl-package sbcl-lparallel))
2653
2654 (define-public sbcl-cl-markup
2655   (let ((commit "e0eb7debf4bdff98d1f49d0f811321a6a637b390"))
2656     (package
2657       (name "sbcl-cl-markup")
2658       (version (git-version "0.1" "1" commit))
2659       (source
2660        (origin
2661          (method git-fetch)
2662          (uri (git-reference
2663                (url "https://github.com/arielnetworks/cl-markup/")
2664                (commit commit)))
2665          (file-name (git-file-name "cl-markup" version))
2666          (sha256
2667           (base32
2668            "10l6k45971dl13fkdmva7zc6i453lmq9j4xax2ci6pjzlc6xjhp7"))))
2669       (build-system asdf-build-system/sbcl)
2670       (home-page "https://github.com/arielnetworks/cl-markup/")
2671       (synopsis "Markup generation library for Common Lisp")
2672       (description
2673        "A modern markup generation library for Common Lisp that features:
2674
2675 @itemize
2676 @item Fast (even faster through compiling the code)
2677 @item Safety
2678 @item Support for multiple document types (markup, xml, html, html5, xhtml)
2679 @item Output with doctype
2680 @item Direct output to stream
2681 @end itemize\n")
2682       (license license:lgpl3+))))
2683
2684 (define-public cl-markup
2685   (sbcl-package->cl-source-package sbcl-cl-markup))
2686
2687 (define-public ecl-cl-markup
2688   (sbcl-package->ecl-package sbcl-cl-markup))
2689
2690 (define-public sbcl-cl-css
2691   (let ((commit "8fe654c8f0cf95b300718101cce4feb517f78e2f"))
2692     (package
2693       (name "sbcl-cl-css")
2694       (version (git-version "0.1" "1" commit))
2695       (source
2696        (origin
2697          (method git-fetch)
2698          (uri (git-reference
2699                (url "https://github.com/inaimathi/cl-css/")
2700                (commit commit)))
2701          (file-name (git-file-name "cl-css" version))
2702          (sha256
2703           (base32
2704            "1lc42zi2sw11fl2589sc19nr5sd2p0wy7wgvgwaggxa5f3ajhsmd"))))
2705       (build-system asdf-build-system/sbcl)
2706       (home-page "https://github.com/inaimathi/cl-css/")
2707       (synopsis "Non-validating, inline CSS generator for Common Lisp")
2708       (description
2709        "This is a dead-simple, non validating, inline CSS generator for Common
2710 Lisp.  Its goals are axiomatic syntax, simple implementation to support
2711 portability, and boilerplate reduction in CSS.")
2712       (license license:expat))))
2713
2714 (define-public cl-css
2715   (sbcl-package->cl-source-package sbcl-cl-css))
2716
2717 (define-public ecl-cl-css
2718   (sbcl-package->ecl-package sbcl-cl-css))
2719
2720 (define-public sbcl-portable-threads
2721   (let ((commit "aa26bf38338a6b068bf8bfb3375d8d8c3b0a28df"))
2722     (package
2723       (name "sbcl-portable-threads")
2724       (version (git-version "2.3" "2" commit))
2725       (source
2726        (origin
2727          (method git-fetch)
2728          (uri (git-reference
2729                (url "https://github.com/binghe/portable-threads/")
2730                (commit commit)))
2731          (file-name (git-file-name "portable-threads" version))
2732          (sha256
2733           (base32 "058ksi07vfdmhrf5mdlc833s82m1rcqfja2266520m3r8bzs8bvs"))))
2734       (build-system asdf-build-system/sbcl)
2735       (arguments
2736        `(;; Tests seem broken.
2737          #:tests? #f))
2738       (home-page "https://github.com/binghe/portable-threads")
2739       (synopsis "Portable threads API for Common Lisp")
2740       (description
2741        "Portable Threads (and Scheduled and Periodic Functions) API for Common
2742 Lisp (from GBBopen project).")
2743       (license license:asl2.0))))
2744
2745 (define-public cl-portable-threads
2746   (sbcl-package->cl-source-package sbcl-portable-threads))
2747
2748 (define-public ecl-portable-threads
2749   (sbcl-package->ecl-package sbcl-portable-threads))
2750
2751 (define-public sbcl-usocket
2752   (package
2753     (name "sbcl-usocket")
2754     (version "0.8.3")
2755     (source
2756      (origin
2757        (method git-fetch)
2758        (uri (git-reference
2759              (url "https://github.com/usocket/usocket/")
2760              (commit (string-append "v" version))))
2761        (file-name (git-file-name "usocket" version))
2762        (sha256
2763         (base32
2764          "0x746wr2324l6bn7skqzgkzcbj5kd0zp2ck0c8rldrw0rzabg826"))))
2765     (build-system asdf-build-system/sbcl)
2766     (native-inputs
2767      `(("rt" ,sbcl-rt)))
2768     (inputs
2769      `(("bordeaux-threads" ,sbcl-bordeaux-threads)
2770        ("split-sequence" ,sbcl-split-sequence)))
2771     (arguments
2772      `(#:tests? #f ; FIXME: Tests need network access?
2773        #:asd-systems '("usocket"
2774                        "usocket-server")))
2775     (home-page "https://common-lisp.net/project/usocket/")
2776     (synopsis "Universal socket library for Common Lisp")
2777     (description
2778      "This library strives to provide a portable TCP/IP and UDP/IP socket
2779 interface for as many Common Lisp implementations as possible, while keeping
2780 the abstraction and portability layer as thin as possible.")
2781     (license license:expat)))
2782
2783 (define-public cl-usocket
2784   (sbcl-package->cl-source-package sbcl-usocket))
2785
2786 (define-public ecl-usocket
2787   (sbcl-package->ecl-package sbcl-usocket))
2788
2789 (define-public sbcl-s-xml
2790   (package
2791     (name "sbcl-s-xml")
2792     (version "3")
2793     (source
2794      (origin
2795        (method url-fetch)
2796        (uri "https://common-lisp.net/project/s-xml/s-xml.tgz")
2797        (sha256
2798         (base32
2799          "061qcr0dzshsa38s5ma4ay924cwak2nq9gy59dw6v9p0qb58nzjf"))))
2800     (build-system asdf-build-system/sbcl)
2801     (home-page "https://common-lisp.net/project/s-xml/")
2802     (synopsis "Simple XML parser implemented in Common Lisp")
2803     (description
2804      "S-XML is a simple XML parser implemented in Common Lisp.  This XML
2805 parser implementation has the following features:
2806
2807 @itemize
2808 @item It works (handling many common XML usages).
2809 @item It is very small (the core is about 700 lines of code, including
2810 comments and whitespace).
2811 @item It has a core API that is simple, efficient and pure functional, much
2812 like that from SSAX (see also http://ssax.sourceforge.net).
2813 @item It supports different DOM models: an XSML-based one, an LXML-based one
2814 and a classic xml-element struct based one.
2815 @item It is reasonably time and space efficient (internally avoiding garbage
2816 generatation as much as possible).
2817 @item It does support CDATA.
2818 @item It should support the same character sets as your Common Lisp
2819 implementation.
2820 @item It does support XML name spaces.
2821 @end itemize
2822
2823 This XML parser implementation has the following limitations:
2824
2825 @itemize
2826 @item It does not support any special tags (like processing instructions).
2827 @item It is not validating, even skips DTD's all together.
2828 @end itemize\n")
2829     (license license:lgpl3+)))
2830
2831 (define-public cl-s-xml
2832   (sbcl-package->cl-source-package sbcl-s-xml))
2833
2834 (define-public ecl-s-xml
2835   (sbcl-package->ecl-package sbcl-s-xml))
2836
2837 (define-public sbcl-s-xml-rpc
2838   (package
2839     (name "sbcl-s-xml-rpc")
2840     (version "7")
2841     (source
2842      (origin
2843        (method url-fetch)
2844        (uri "https://common-lisp.net/project/s-xml-rpc/s-xml-rpc.tgz")
2845        (sha256
2846         (base32
2847          "02z7k163d51v0pzk8mn1xb6h5s6x64gjqkslhwm3a5x26k2gfs11"))))
2848     (build-system asdf-build-system/sbcl)
2849     (inputs
2850      `(("s-xml" ,sbcl-s-xml)))
2851     (home-page "https://common-lisp.net/project/s-xml-rpc/")
2852     (synopsis "Implementation of XML-RPC in Common Lisp for both client and server")
2853     (description
2854      "S-XML-RPC is an implementation of XML-RPC in Common Lisp for both
2855 client and server.")
2856     (license license:lgpl3+)))
2857
2858 (define-public cl-s-xml-rpc
2859   (sbcl-package->cl-source-package sbcl-s-xml-rpc))
2860
2861 (define-public ecl-s-xml-rpc
2862   (sbcl-package->ecl-package sbcl-s-xml-rpc))
2863
2864 (define-public sbcl-trivial-clipboard
2865   (let ((commit "5af3415d1484e6d69a1b5c178f24680d9fd01796"))
2866     (package
2867       (name "sbcl-trivial-clipboard")
2868       (version (git-version "0.0.0.0" "2" commit))
2869       (source
2870        (origin
2871          (method git-fetch)
2872          (uri (git-reference
2873                (url "https://github.com/snmsts/trivial-clipboard")
2874                (commit commit)))
2875          (file-name (git-file-name "trivial-clipboard" version))
2876          (sha256
2877           (base32
2878            "1gb515z5yq6h5548pb1fwhmb0hhq1ssyb78pvxh4alq799xipxs9"))))
2879       (build-system asdf-build-system/sbcl)
2880       (inputs
2881        `(("xclip" ,xclip)))
2882       (native-inputs
2883        `(("fiveam" ,sbcl-fiveam)))
2884       (arguments
2885        `(#:phases
2886          (modify-phases %standard-phases
2887            (add-after 'unpack 'fix-paths
2888              (lambda* (#:key inputs #:allow-other-keys)
2889                (substitute* "src/text.lisp"
2890                  (("\\(executable-find \"xclip\"\\)")
2891                   (string-append "(executable-find \""
2892                                  (assoc-ref inputs "xclip")
2893                                  "/bin/xclip\")"))))))))
2894       (home-page "https://github.com/snmsts/trivial-clipboard")
2895       (synopsis "Access system clipboard in Common Lisp")
2896       (description
2897        "@command{trivial-clipboard} gives access to the system clipboard.")
2898       (license license:expat))))
2899
2900 (define-public cl-trivial-clipboard
2901   (sbcl-package->cl-source-package sbcl-trivial-clipboard))
2902
2903 (define-public ecl-trivial-clipboard
2904   (sbcl-package->ecl-package sbcl-trivial-clipboard))
2905
2906 (define-public sbcl-trivial-backtrace
2907   (let ((commit "ca81c011b86424a381a7563cea3b924f24e6fbeb")
2908         (revision "1"))
2909     (package
2910      (name "sbcl-trivial-backtrace")
2911      (version (git-version "0.0.0" revision commit))
2912      (source
2913       (origin
2914        (method git-fetch)
2915        (uri (git-reference
2916              (url "https://github.com/gwkkwg/trivial-backtrace")
2917              (commit commit)))
2918        (file-name (git-file-name "trivial-backtrace" version))
2919        (sha256
2920         (base32 "10p41p43skj6cimdg8skjy7372s8v2xpkg8djjy0l8rm45i654k1"))))
2921      (build-system asdf-build-system/sbcl)
2922      (inputs
2923       `(("sbcl-lift" ,sbcl-lift)))
2924      (arguments
2925       `(#:phases
2926         (modify-phases %standard-phases
2927           (add-after 'check 'delete-test-results
2928             (lambda* (#:key outputs #:allow-other-keys)
2929               (let ((test-results (string-append (assoc-ref outputs "out")
2930                                                  "/share/common-lisp/"
2931                                                  (%lisp-type)
2932                                                  "/trivial-backtrace"
2933                                                  "/test-results")))
2934                 (when (file-exists? test-results)
2935                   (delete-file-recursively test-results)))
2936               #t)))))
2937      (home-page "https://common-lisp.net/project/trivial-backtrace/")
2938      (synopsis "Portable simple API to work with backtraces in Common Lisp")
2939      (description
2940       "One of the many things that didn't quite get into the Common Lisp
2941 standard was how to get a Lisp to output its call stack when something has
2942 gone wrong.  As such, each Lisp has developed its own notion of what to
2943 display, how to display it, and what sort of arguments can be used to
2944 customize it.  @code{trivial-backtrace} is a simple solution to generating a
2945 backtrace portably.")
2946      (license license:expat))))
2947
2948 (define-public cl-trivial-backtrace
2949   (sbcl-package->cl-source-package sbcl-trivial-backtrace))
2950
2951 (define-public ecl-trivial-backtrace
2952   (sbcl-package->ecl-package sbcl-trivial-backtrace))
2953
2954 (define-public sbcl-rfc2388
2955   (let ((commit "591bcf7e77f2c222c43953a80f8c297751dc0c4e")
2956         (revision "1"))
2957     (package
2958      (name "sbcl-rfc2388")
2959      (version (git-version "0.0.0" revision commit))
2960      (source
2961       (origin
2962        (method git-fetch)
2963        (uri (git-reference
2964              (url "https://github.com/jdz/rfc2388")
2965              (commit commit)))
2966        (file-name (git-file-name "rfc2388" version))
2967        (sha256
2968         (base32 "0phh5n3clhl9ji8jaxrajidn22d3f0aq87mlbfkkxlnx2pnw694k"))))
2969      (build-system asdf-build-system/sbcl)
2970      (home-page "https://github.com/jdz/rfc2388/")
2971      (synopsis "An implementation of RFC 2388 in Common Lisp")
2972      (description
2973       "This package contains an implementation of RFC 2388, which is used to
2974 process form data posted with HTTP POST method using enctype
2975 \"multipart/form-data\".")
2976      (license license:bsd-2))))
2977
2978 (define-public cl-rfc2388
2979   (sbcl-package->cl-source-package sbcl-rfc2388))
2980
2981 (define-public ecl-rfc2388
2982   (sbcl-package->ecl-package sbcl-rfc2388))
2983
2984 (define-public sbcl-md5
2985   (package
2986     (name "sbcl-md5")
2987     (version "2.0.4")
2988     (source
2989      (origin
2990        (method git-fetch)
2991        (uri (git-reference
2992               (url "https://github.com/pmai/md5")
2993               (commit (string-append "release-" version))))
2994        (file-name (git-file-name "md5" version))
2995        (sha256
2996         (base32 "1waqxzm7vlc22n92hv8r27anlvvjkkh9slhrky1ww7mdx4mmxwb8"))))
2997     (build-system asdf-build-system/sbcl)
2998     (home-page "https://github.com/pmai/md5")
2999     (synopsis
3000      "Common Lisp implementation of the MD5 Message-Digest Algorithm (RFC 1321)")
3001     (description
3002      "This package implements The MD5 Message-Digest Algorithm, as defined in
3003 RFC 1321 by R. Rivest, published April 1992.")
3004     (license license:public-domain)))
3005
3006 (define-public cl-md5
3007   (sbcl-package->cl-source-package sbcl-md5))
3008
3009 (define-public ecl-md5
3010   (package
3011     (inherit (sbcl-package->ecl-package sbcl-md5))
3012     (inputs
3013      `(("flexi-streams" ,ecl-flexi-streams)))))
3014
3015 (define-public sbcl-cl+ssl
3016   (let ((commit "701e645081e6533a3f0f0b3ac86389d6f506c4b5")
3017         (revision "1"))
3018     (package
3019       (name "sbcl-cl+ssl")
3020       (version (git-version "0.0.0" revision commit))
3021       (source
3022        (origin
3023          (method git-fetch)
3024          (uri (git-reference
3025                (url "https://github.com/cl-plus-ssl/cl-plus-ssl")
3026                (commit commit)))
3027          (file-name (git-file-name "cl+ssl" version))
3028          (sha256
3029           (base32 "0nfl275nwhff3m25872y388cydz14kqb6zbwywa6nj85r9k8bgs0"))))
3030       (build-system asdf-build-system/sbcl)
3031       (arguments
3032        '(#:phases
3033          (modify-phases %standard-phases
3034            (add-after 'unpack 'fix-paths
3035              (lambda* (#:key inputs #:allow-other-keys)
3036                (substitute* "src/reload.lisp"
3037                  (("libssl.so" all)
3038                   (string-append
3039                    (assoc-ref inputs "openssl") "/lib/" all))))))))
3040       (inputs
3041        `(("openssl" ,openssl)
3042          ("sbcl-cffi" ,sbcl-cffi)
3043          ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)
3044          ("sbcl-flexi-streams" ,sbcl-flexi-streams)
3045          ("sbcl-bordeaux-threads" ,sbcl-bordeaux-threads)
3046          ("sbcl-trivial-garbage" ,sbcl-trivial-garbage)
3047          ("sbcl-alexandria" ,sbcl-alexandria)
3048          ("sbcl-trivial-features" ,sbcl-trivial-features)))
3049       (home-page "https://common-lisp.net/project/cl-plus-ssl/")
3050       (synopsis "Common Lisp bindings to OpenSSL")
3051       (description
3052        "This library is a fork of SSL-CMUCL.  The original SSL-CMUCL source
3053 code was written by Eric Marsden and includes contributions by Jochen Schmidt.
3054 Development into CL+SSL was done by David Lichteblau.")
3055       (license license:expat))))
3056
3057 (define-public cl-cl+ssl
3058   (sbcl-package->cl-source-package sbcl-cl+ssl))
3059
3060 (define-public ecl-cl+ssl
3061   (sbcl-package->ecl-package sbcl-cl+ssl))
3062
3063 (define-public sbcl-kmrcl
3064   (let ((version "1.109.0")
3065         (commit "5260068b2eb735af6796740c2db4955afac21636")
3066         (revision "1"))
3067     (package
3068       (name "sbcl-kmrcl")
3069       (version (git-version version revision commit))
3070       (source
3071        (origin
3072          (method git-fetch)
3073          (uri (git-reference
3074                (url "http://git.kpe.io/kmrcl.git/")
3075                (commit commit)))
3076          (file-name (git-file-name name version))
3077          (sha256
3078           (base32 "1va7xjgzfv674bpsli674i7zj3f7wg5kxic41kz18r6hh4n52dfv"))))
3079       (build-system asdf-build-system/sbcl)
3080       (arguments
3081        ;; Tests fail with: :FORCE and :FORCE-NOT arguments not allowed in a
3082        ;; nested call to ASDF/OPERATE:OPERATE unless identically to toplevel
3083        '(#:tests? #f))
3084       (inputs
3085        `(("sbcl-rt" ,sbcl-rt)))
3086       (home-page "http://files.kpe.io/kmrcl/")
3087       (synopsis "General utilities for Common Lisp programs")
3088       (description
3089        "KMRCL is a collection of utilities used by a number of Kevin
3090 Rosenberg's CL packages.")
3091       (license license:llgpl))))
3092
3093 (define-public cl-kmrcl
3094   (sbcl-package->cl-source-package sbcl-kmrcl))
3095
3096 (define-public ecl-kmrcl
3097   (sbcl-package->ecl-package sbcl-kmrcl))
3098
3099 (define-public sbcl-cl-base64
3100   (package
3101     (name "sbcl-cl-base64")
3102     (version "3.3.4")
3103     (source
3104      (origin
3105        (method url-fetch)
3106        (uri (string-append "http://files.kpe.io/cl-base64/cl-base64-"
3107                            version ".tar.gz"))
3108        (sha256
3109         (base32 "0pl4zwn5bf18dm8fh1kn1yshaa6kpmfrjyb33z9mq4raqmj3xpv2"))))
3110     (build-system asdf-build-system/sbcl)
3111     (arguments
3112      ;; Tests fail with: :FORCE and :FORCE-NOT arguments not allowed
3113      ;; in a nested call to ASDF/OPERATE:OPERATE unless identically
3114      ;; to toplevel
3115      '(#:tests? #f))
3116     (inputs
3117      `(("sbcl-ptester" ,sbcl-ptester)
3118        ("sbcl-kmrcl" ,sbcl-kmrcl)))
3119     (home-page "http://files.kpe.io/cl-base64/")
3120     (synopsis
3121      "Common Lisp package to encode and decode base64 with URI support")
3122     (description
3123      "This package provides highly optimized base64 encoding and decoding.
3124 Besides conversion to and from strings, integer conversions are supported.
3125 Encoding with Uniform Resource Identifiers is supported by using a modified
3126 encoding table that uses only URI-compatible characters.")
3127     (license license:bsd-3)))
3128
3129 (define-public cl-base64
3130   (sbcl-package->cl-source-package sbcl-cl-base64))
3131
3132 (define-public ecl-cl-base64
3133   (sbcl-package->ecl-package sbcl-cl-base64))
3134
3135 (define-public sbcl-chunga
3136   (package
3137     (name "sbcl-chunga")
3138     (version "1.1.7")
3139     (source
3140      (origin
3141        (method git-fetch)
3142        (uri (git-reference
3143               (url "https://github.com/edicl/chunga")
3144               (commit (string-append "v" version))))
3145        (file-name (git-file-name name version))
3146        (sha256
3147         (base32 "0jzn3nyb3f22gm983rfk99smqs3mhb9ivjmasvhq9qla5cl9pyhd"))))
3148     (build-system asdf-build-system/sbcl)
3149     (inputs
3150      `(("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)))
3151     (home-page "https://edicl.github.io/chunga/")
3152     (synopsis "Portable chunked streams for Common Lisp")
3153     (description
3154      "Chunga implements streams capable of chunked encoding on demand as
3155 defined in RFC 2616.")
3156     (license license:bsd-2)))
3157
3158 (define-public cl-chunga
3159   (sbcl-package->cl-source-package sbcl-chunga))
3160
3161 (define-public ecl-chunga
3162   (sbcl-package->ecl-package sbcl-chunga))
3163
3164 (define-public sbcl-cl-who
3165   (let ((version "1.1.4")
3166         (commit "2c08caa4bafba720409af9171feeba3f32e86d32")
3167         (revision "1"))
3168     (package
3169       (name "sbcl-cl-who")
3170       (version (git-version version revision commit))
3171       (source
3172        (origin
3173          (method git-fetch)
3174          (uri (git-reference
3175                (url "https://github.com/edicl/cl-who")
3176                (commit commit)))
3177          (file-name (git-file-name name version))
3178          (sha256
3179           (base32
3180            "0yjb6sr3yazm288m318kqvj9xk8rm9n1lpimgf65ymqv0i5agxsb"))))
3181       (build-system asdf-build-system/sbcl)
3182       (native-inputs
3183        `(("sbcl-flexi-streams" ,sbcl-flexi-streams)))
3184       (home-page "https://edicl.github.io/cl-who/")
3185       (synopsis "Yet another Lisp markup language")
3186       (description
3187        "There are plenty of Lisp Markup Languages out there - every Lisp
3188 programmer seems to write at least one during his career - and CL-WHO (where
3189 WHO means \"with-html-output\" for want of a better acronym) is probably just
3190 as good or bad as the next one.")
3191       (license license:bsd-2))))
3192
3193 (define-public cl-who
3194   (sbcl-package->cl-source-package sbcl-cl-who))
3195
3196 (define-public ecl-cl-who
3197   (sbcl-package->ecl-package sbcl-cl-who))
3198
3199 (define-public sbcl-chipz
3200   (let ((version "0.8")
3201         (commit "75dfbc660a5a28161c57f115adf74c8a926bfc4d")
3202         (revision "1"))
3203     (package
3204       (name "sbcl-chipz")
3205       (version (git-version version revision commit))
3206       (source
3207        (origin
3208          (method git-fetch)
3209          (uri (git-reference
3210                (url "https://github.com/froydnj/chipz")
3211                (commit commit)))
3212          (file-name (git-file-name name version))
3213          (sha256
3214           (base32
3215            "0plx4rs39zbs4gjk77h4a2q11zpy75fh9v8hnxrvsf8fnakajhwg"))))
3216       (build-system asdf-build-system/sbcl)
3217       (native-inputs
3218        `(("sbcl-flexi-streams" ,sbcl-flexi-streams)))
3219       (home-page "http://method-combination.net/lisp/chipz/")
3220       (synopsis
3221        "Common Lisp library for decompressing deflate, zlib, gzip, and bzip2
3222 data")
3223       (description
3224        "DEFLATE data, defined in RFC1951, forms the core of popular
3225 compression formats such as zlib (RFC 1950) and gzip (RFC 1952).  As such,
3226 Chipz also provides for decompressing data in those formats as well.  BZIP2 is
3227 the format used by the popular compression tool bzip2.")
3228       ;; The author describes it as "MIT-like"
3229       (license license:expat))))
3230
3231 (define-public cl-chipz
3232   (sbcl-package->cl-source-package sbcl-chipz))
3233
3234 (define-public ecl-chipz
3235   (sbcl-package->ecl-package sbcl-chipz))
3236
3237 (define-public sbcl-drakma
3238   (package
3239     (name "sbcl-drakma")
3240     (version "2.0.7")
3241     (source
3242      (origin
3243        (method git-fetch)
3244        (uri (git-reference
3245              (url "https://github.com/edicl/drakma")
3246              (commit (string-append "v" version))))
3247        (file-name (git-file-name name version))
3248        (sha256
3249         (base32
3250          "1441idnyif9xzx3ln1p3fg36k2v9h4wasjqrzc8y52j61420qpci"))))
3251     (build-system asdf-build-system/sbcl)
3252     (inputs
3253      `(("sbcl-puri" ,sbcl-puri)
3254        ("sbcl-cl-base64" ,sbcl-cl-base64)
3255        ("sbcl-chunga" ,sbcl-chunga)
3256        ("sbcl-flexi-streams" ,sbcl-flexi-streams)
3257        ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
3258        ("sbcl-chipz" ,sbcl-chipz)
3259        ("sbcl-usocket" ,sbcl-usocket)
3260        ("sbcl-cl+ssl" ,sbcl-cl+ssl)))
3261     (native-inputs
3262      `(("sbcl-fiveam" ,sbcl-fiveam)))
3263     (home-page "https://edicl.github.io/drakma/")
3264     (synopsis "HTTP client written in Common Lisp")
3265     (description
3266      "Drakma is a full-featured HTTP client implemented in Common Lisp.  It
3267 knows how to handle HTTP/1.1 chunking, persistent connections, re-usable
3268 sockets, SSL, continuable uploads, file uploads, cookies, and more.")
3269     (license license:bsd-2)))
3270
3271 (define-public cl-drakma
3272   (sbcl-package->cl-source-package sbcl-drakma))
3273
3274 (define-public ecl-drakma
3275   (sbcl-package->ecl-package sbcl-drakma))
3276
3277 (define-public sbcl-hunchentoot
3278   (package
3279     (name "sbcl-hunchentoot")
3280     (version "1.2.38")
3281     (source
3282      (origin
3283        (method git-fetch)
3284        (uri (git-reference
3285              (url "https://github.com/edicl/hunchentoot")
3286              (commit (string-append "v" version))))
3287        (file-name (git-file-name "hunchentoot" version))
3288        (sha256
3289         (base32 "1anpcad7w045m4rsjs1f3xdhjwx5cppq1h0vlb3q7dz81fi3i6yq"))))
3290     (build-system asdf-build-system/sbcl)
3291     (native-inputs
3292      `(("sbcl-cl-who" ,sbcl-cl-who)
3293        ("sbcl-drakma" ,sbcl-drakma)))
3294     (inputs
3295      `(("sbcl-chunga" ,sbcl-chunga)
3296        ("sbcl-cl-base64" ,sbcl-cl-base64)
3297        ("sbcl-cl-fad" ,sbcl-cl-fad)
3298        ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
3299        ("sbcl-flexi-streams" ,sbcl-flexi-streams)
3300        ("sbcl-cl+ssl" ,sbcl-cl+ssl)
3301        ("sbcl-md5" ,sbcl-md5)
3302        ("sbcl-rfc2388" ,sbcl-rfc2388)
3303        ("sbcl-trivial-backtrace" ,sbcl-trivial-backtrace)
3304        ("sbcl-usocket" ,sbcl-usocket)))
3305     (home-page "https://edicl.github.io/hunchentoot/")
3306     (synopsis "Web server written in Common Lisp")
3307     (description
3308      "Hunchentoot is a web server written in Common Lisp and at the same
3309 time a toolkit for building dynamic websites.  As a stand-alone web server,
3310 Hunchentoot is capable of HTTP/1.1 chunking (both directions), persistent
3311 connections (keep-alive), and SSL.")
3312     (license license:bsd-2)))
3313
3314 (define-public cl-hunchentoot
3315   (sbcl-package->cl-source-package sbcl-hunchentoot))
3316
3317 (define-public ecl-hunchentoot
3318   (package
3319     (inherit (sbcl-package->ecl-package sbcl-hunchentoot))
3320     (arguments
3321      ;; Tests fail on ECL with 'Socket error in "socket": EINVAL'.
3322      '(#:tests? #f))))
3323
3324 (define-public sbcl-trivial-types
3325   (package
3326     (name "sbcl-trivial-types")
3327     (version "0.0.1")
3328     (source
3329      (origin
3330        (method git-fetch)
3331        (uri (git-reference
3332              (url "https://github.com/m2ym/trivial-types")
3333              (commit "ee869f2b7504d8aa9a74403641a5b42b16f47d88")))
3334        (file-name (git-file-name name version))
3335        (sha256
3336         (base32 "1s4cp9bdlbn8447q7w7f1wkgwrbvfzp20mgs307l5pxvdslin341"))))
3337     (build-system asdf-build-system/sbcl)
3338     (home-page "https://github.com/m2ym/trivial-types")
3339     (synopsis "Trivial type definitions for Common Lisp")
3340     (description
3341      "TRIVIAL-TYPES provides missing but important type definitions such as
3342 PROPER-LIST, ASSOCIATION-LIST, PROPERTY-LIST and TUPLE.")
3343     (license license:llgpl)))
3344
3345 (define-public cl-trivial-types
3346   (sbcl-package->cl-source-package sbcl-trivial-types))
3347
3348 (define-public ecl-trivial-types
3349   (sbcl-package->ecl-package sbcl-trivial-types))
3350
3351 (define-public sbcl-cl-annot
3352   (let ((commit "c99e69c15d935eabc671b483349a406e0da9518d")
3353         (revision "1"))
3354     (package
3355       (name "sbcl-cl-annot")
3356       (version (git-version "0.0.0" revision commit))
3357       (source
3358        (origin
3359          (method git-fetch)
3360          (uri (git-reference
3361                (url "https://github.com/m2ym/cl-annot")
3362                (commit commit)))
3363          (file-name (git-file-name name version))
3364          (sha256
3365           (base32 "1wq1gs9jjd5m6iwrv06c2d7i5dvqsfjcljgbspfbc93cg5xahk4n"))))
3366       (build-system asdf-build-system/sbcl)
3367       (inputs
3368        `(("sbcl-alexandria" ,sbcl-alexandria)))
3369       (home-page "https://github.com/m2ym/cl-annot")
3370       (synopsis "Python-like Annotation Syntax for Common Lisp.")
3371       (description
3372        "@code{cl-annot} is an general annotation library for Common Lisp.")
3373       (license license:llgpl))))
3374
3375 (define-public cl-annot
3376   (sbcl-package->cl-source-package sbcl-cl-annot))
3377
3378 (define-public ecl-cl-annot
3379   (sbcl-package->ecl-package sbcl-cl-annot))
3380
3381 (define-public sbcl-cl-syntax
3382   (package
3383     (name "sbcl-cl-syntax")
3384     (version "0.0.3")
3385     (source
3386      (origin
3387        (method git-fetch)
3388        (uri (git-reference
3389              (url "https://github.com/m2ym/cl-syntax")
3390              (commit "03f0c329bbd55b8622c37161e6278366525e2ccc")))
3391        (file-name (git-file-name "cl-syntax" version))
3392        (sha256
3393         (base32 "17ran8xp77asagl31xv8w819wafh6whwfc9p6dgx22ca537gyl4y"))))
3394     (build-system asdf-build-system/sbcl)
3395     (inputs
3396      `(("cl-annot" ,sbcl-cl-annot)
3397        ("cl-interpol" ,sbcl-cl-interpol)
3398        ("named-readtables" ,sbcl-named-readtables)
3399        ("trivial-types" ,sbcl-trivial-types)))
3400     (arguments
3401      '(#:asd-systems '("cl-syntax"
3402                        "cl-syntax-annot"
3403                        "cl-syntax-interpol")))
3404     (home-page "https://github.com/m2ym/cl-syntax")
3405     (synopsis "Reader Syntax Coventions for Common Lisp and SLIME")
3406     (description
3407      "CL-SYNTAX provides Reader Syntax Coventions for Common Lisp and SLIME.")
3408     (license license:llgpl)))
3409
3410 (define-public cl-syntax
3411   (sbcl-package->cl-source-package sbcl-cl-syntax))
3412
3413 (define-public ecl-cl-syntax
3414   (sbcl-package->ecl-package sbcl-cl-syntax))
3415
3416 (define-public sbcl-cl-utilities
3417   (let ((commit "dce2d2f6387091ea90357a130fa6d13a6776884b")
3418         (revision "1"))
3419     (package
3420       (name "sbcl-cl-utilities")
3421       (version (git-version "0.0.0" revision commit))
3422       (source
3423        (origin
3424          (method url-fetch)
3425          (uri
3426           (string-append
3427            "https://gitlab.common-lisp.net/cl-utilities/cl-utilities/-/"
3428            "archive/" commit "/cl-utilities-" commit ".tar.gz"))
3429          (sha256
3430           (base32 "1r46v730yf96nk2vb24qmagv9x96xvd08abqwhf02ghgydv1a7z2"))))
3431       (build-system asdf-build-system/sbcl)
3432       (arguments
3433        '(#:phases
3434          (modify-phases %standard-phases
3435            (add-after 'unpack 'fix-paths
3436              (lambda* (#:key inputs #:allow-other-keys)
3437                (substitute* "rotate-byte.lisp"
3438                  (("in-package :cl-utilities)" all)
3439                   "in-package :cl-utilities)\n\n#+sbcl\n(require :sb-rotate-byte)")))))))
3440       (home-page "http://common-lisp.net/project/cl-utilities")
3441       (synopsis "A collection of semi-standard utilities")
3442       (description
3443        "On Cliki.net <http://www.cliki.net/Common%20Lisp%20Utilities>, there
3444 is a collection of Common Lisp Utilities, things that everybody writes since
3445 they're not part of the official standard.  There are some very useful things
3446 there; the only problems are that they aren't implemented as well as you'd
3447 like (some aren't implemented at all) and they aren't conveniently packaged
3448 and maintained.  It takes quite a bit of work to carefully implement utilities
3449 for common use, commented and documented, with error checking placed
3450 everywhere some dumb user might make a mistake.")
3451       (license license:public-domain))))
3452
3453 (define-public cl-utilities
3454   (sbcl-package->cl-source-package sbcl-cl-utilities))
3455
3456 (define-public ecl-cl-utilities
3457   (sbcl-package->ecl-package sbcl-cl-utilities))
3458
3459 (define-public sbcl-map-set
3460   (let ((commit "7b4b545b68b8")
3461         (revision "1"))
3462     (package
3463       (name "sbcl-map-set")
3464       (version (git-version "0.0.0" revision commit))
3465       (source
3466        (origin
3467          (method url-fetch)
3468          (uri (string-append
3469                "https://bitbucket.org/tarballs_are_good/map-set/get/"
3470                commit ".tar.gz"))
3471          (sha256
3472           (base32 "1sx5j5qdsy5fklspfammwb16kjrhkggdavm922a9q86jm5l0b239"))))
3473       (build-system asdf-build-system/sbcl)
3474       (home-page "https://bitbucket.org/tarballs_are_good/map-set")
3475       (synopsis "Set-like data structure")
3476       (description
3477        "Implementation of a set-like data structure with constant time
3478 addition, removal, and random selection.")
3479       (license license:bsd-3))))
3480
3481 (define-public cl-map-set
3482   (sbcl-package->cl-source-package sbcl-map-set))
3483
3484 (define-public ecl-map-set
3485   (sbcl-package->ecl-package sbcl-map-set))
3486
3487 (define-public sbcl-quri
3488   (let ((commit "b53231c5f19446dd7c24b15a249fefa45ae94f9a")
3489         (revision "2"))
3490     (package
3491       (name "sbcl-quri")
3492       (version (git-version "0.1.0" revision commit))
3493       (source
3494        (origin
3495          (method git-fetch)
3496          (uri (git-reference
3497                (url "https://github.com/fukamachi/quri")
3498                (commit commit)))
3499          (file-name (git-file-name name version))
3500          (sha256
3501           (base32 "0cansr63m690ymvhway419178mq2sqnmxm4rdxclbsrnjwwbi36m"))))
3502       (build-system asdf-build-system/sbcl)
3503       (arguments
3504        ;; Tests fail with: Component QURI-ASD::QURI-TEST not found,
3505        ;; required by #<SYSTEM "quri">. Why?
3506        '(#:tests? #f))
3507       (native-inputs `(("sbcl-prove" ,sbcl-prove)))
3508       (inputs `(("sbcl-babel" ,sbcl-babel)
3509                 ("sbcl-split-sequence" ,sbcl-split-sequence)
3510                 ("sbcl-cl-utilities" ,sbcl-cl-utilities)
3511                 ("sbcl-alexandria" ,sbcl-alexandria)))
3512       (home-page "https://github.com/fukamachi/quri")
3513       (synopsis "Yet another URI library for Common Lisp")
3514       (description
3515        "QURI (pronounced \"Q-ree\") is yet another URI library for Common
3516 Lisp. It is intended to be a replacement of PURI.")
3517       (license license:bsd-3))))
3518
3519 (define-public cl-quri
3520   (sbcl-package->cl-source-package sbcl-quri))
3521
3522 (define-public ecl-quri
3523   (sbcl-package->ecl-package sbcl-quri))
3524
3525 (define-public sbcl-myway
3526   (let ((commit "286230082a11f879c18b93f17ca571c5f676bfb7")
3527         (revision "1"))
3528     (package
3529      (name "sbcl-myway")
3530      (version (git-version "0.1.0" revision commit))
3531      (source
3532       (origin
3533        (method git-fetch)
3534        (uri (git-reference
3535              (url "https://github.com/fukamachi/myway")
3536              (commit commit)))
3537        (file-name (git-file-name "myway" version))
3538        (sha256
3539         (base32 "0briia9bk3lbr0frnx39d1qg6i38dm4j6z9w3yga3d40k6df4a90"))))
3540      (build-system asdf-build-system/sbcl)
3541      (arguments
3542       ;; Tests fail with: Component MYWAY-ASD::MYWAY-TEST not found, required
3543       ;; by #<SYSTEM "myway">. Why?
3544       '(#:tests? #f))
3545      (native-inputs
3546       `(("sbcl-prove" ,sbcl-prove)))
3547      (inputs
3548       `(("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
3549         ("sbcl-quri" ,sbcl-quri)
3550         ("sbcl-map-set" ,sbcl-map-set)))
3551      (home-page "https://github.com/fukamachi/myway")
3552      (synopsis "Sinatra-compatible URL routing library for Common Lisp")
3553      (description "My Way is a Sinatra-compatible URL routing library.")
3554      (license license:llgpl))))
3555
3556 (define-public cl-myway
3557   (sbcl-package->cl-source-package sbcl-myway))
3558
3559 (define-public ecl-myway
3560   (sbcl-package->ecl-package sbcl-myway))
3561
3562 (define-public sbcl-xsubseq
3563   (let ((commit "5ce430b3da5cda3a73b9cf5cee4df2843034422b")
3564         (revision "1"))
3565     (package
3566      (name "sbcl-xsubseq")
3567      (version (git-version "0.0.1" revision commit))
3568      (source
3569       (origin
3570        (method git-fetch)
3571        (uri (git-reference
3572              (url "https://github.com/fukamachi/xsubseq")
3573              (commit commit)))
3574        (file-name (git-file-name name version))
3575        (sha256
3576         (base32 "1xz79q0p2mclf3sqjiwf6izdpb6xrsr350bv4mlmdlm6rg5r99px"))))
3577      (build-system asdf-build-system/sbcl)
3578      (arguments
3579       ;; Tests fail with: Component XSUBSEQ-ASD::XSUBSEQ-TEST not found,
3580       ;; required by #<SYSTEM "xsubseq">. Why?
3581       '(#:tests? #f))
3582      (native-inputs
3583       `(("sbcl-prove" ,sbcl-prove)))
3584      (home-page "https://github.com/fukamachi/xsubseq")
3585      (synopsis "Efficient way to use \"subseq\"s in Common Lisp")
3586      (description
3587       "XSubseq provides functions to be able to handle \"subseq\"s more
3588 effieiently.")
3589      (license license:bsd-2))))
3590
3591 (define-public cl-xsubseq
3592   (sbcl-package->cl-source-package sbcl-xsubseq))
3593
3594 (define-public ecl-xsubseq
3595   (sbcl-package->ecl-package sbcl-xsubseq))
3596
3597 (define-public sbcl-smart-buffer
3598   (let ((commit "09b9a9a0b3abaa37abe9a730f5aac2643dca4e62")
3599         (revision "1"))
3600     (package
3601       (name "sbcl-smart-buffer")
3602       (version (git-version "0.0.1" revision commit))
3603       (source
3604        (origin
3605          (method git-fetch)
3606          (uri (git-reference
3607                (url "https://github.com/fukamachi/smart-buffer")
3608                (commit commit)))
3609          (file-name (git-file-name name version))
3610          (sha256
3611           (base32 "0qz1zzxx0wm5ff7gpgsq550a59p0qj594zfmm2rglj97dahj54l7"))))
3612       (build-system asdf-build-system/sbcl)
3613       (arguments
3614        ;; Tests fail with: Component SMART-BUFFER-ASD::SMART-BUFFER-TEST not
3615        ;; found, required by #<SYSTEM "smart-buffer">. Why?
3616        `(#:tests? #f))
3617       (native-inputs
3618        `(("sbcl-prove" ,sbcl-prove)))
3619       (inputs
3620        `(("sbcl-xsubseq" ,sbcl-xsubseq)
3621          ("sbcl-flexi-streams" ,sbcl-flexi-streams)))
3622       (home-page "https://github.com/fukamachi/smart-buffer")
3623       (synopsis "Smart octets buffer")
3624       (description
3625        "Smart-buffer provides an output buffer which changes the destination
3626 depending on content size.")
3627       (license license:bsd-3))))
3628
3629 (define-public cl-smart-buffer
3630   (sbcl-package->cl-source-package sbcl-smart-buffer))
3631
3632 (define-public ecl-smart-buffer
3633   (sbcl-package->ecl-package sbcl-smart-buffer))
3634
3635 (define-public sbcl-fast-http
3636   (let ((commit "502a37715dcb8544cc8528b78143a942de662c5a")
3637         (revision "2"))
3638     (package
3639       (name "sbcl-fast-http")
3640       (version (git-version "0.2.0" revision commit))
3641       (source
3642        (origin
3643          (method git-fetch)
3644          (uri (git-reference
3645                (url "https://github.com/fukamachi/fast-http")
3646                (commit commit)))
3647          (file-name (git-file-name name version))
3648          (sha256
3649           (base32 "0al2g7g219jjljsf7b23pbilpgacxy5as5gs2nqf76b5qni396mi"))))
3650       (build-system asdf-build-system/sbcl)
3651       (arguments
3652        ;; Tests fail with: Component FAST-HTTP-ASD::FAST-HTTP-TEST not found,
3653        ;; required by #<SYSTEM "fast-http">. Why?
3654        `(#:tests? #f))
3655       (native-inputs
3656        `(("sbcl-prove" ,sbcl-prove)
3657          ("cl-syntax" ,sbcl-cl-syntax)))
3658       (inputs
3659        `(("sbcl-alexandria" ,sbcl-alexandria)
3660          ("sbcl-proc-parse" ,sbcl-proc-parse)
3661          ("sbcl-xsubseq" ,sbcl-xsubseq)
3662          ("sbcl-smart-buffer" ,sbcl-smart-buffer)
3663          ("sbcl-cl-utilities" ,sbcl-cl-utilities)))
3664       (home-page "https://github.com/fukamachi/fast-http")
3665       (synopsis "HTTP request/response parser for Common Lisp")
3666       (description
3667        "@code{fast-http} is a HTTP request/response protocol parser for Common
3668 Lisp.")
3669       ;; Author specified the MIT license
3670       (license license:expat))))
3671
3672 (define-public cl-fast-http
3673   (sbcl-package->cl-source-package sbcl-fast-http))
3674
3675 (define-public ecl-fast-http
3676   (sbcl-package->ecl-package sbcl-fast-http))
3677
3678 (define-public sbcl-static-vectors
3679   (package
3680     (name "sbcl-static-vectors")
3681     (version "1.8.4")
3682     (source
3683      (origin
3684        (method git-fetch)
3685        (uri (git-reference
3686              (url "https://github.com/sionescu/static-vectors")
3687              (commit (string-append "v" version))))
3688        (file-name (git-file-name name version))
3689        (sha256
3690         (base32 "0qvf9z6bhwhm8n45fjwkm7j8dcb58szfvndky65cyn4lpdval7m1"))))
3691     (native-inputs
3692      `(("sbcl-fiveam" ,sbcl-fiveam)))
3693     (inputs
3694      `(("sbcl-cffi" ,sbcl-cffi)))
3695     (build-system asdf-build-system/sbcl)
3696     (home-page "https://github.com/sionescu/static-vectors")
3697     (synopsis "Allocate SIMPLE-ARRAYs in static memory")
3698     (description
3699      "With @code{static-vectors}, you can create vectors allocated in static
3700 memory.")
3701     (license license:expat)))
3702
3703 (define-public cl-static-vectors
3704   (sbcl-package->cl-source-package sbcl-static-vectors))
3705
3706 (define-public ecl-static-vectors
3707   (sbcl-package->ecl-package sbcl-static-vectors))
3708
3709 (define-public sbcl-marshal
3710   (let ((commit "eff1b15f2b0af2f26f71ad6a4dd5c4beab9299ec")
3711         (revision "1"))
3712     (package
3713      (name "sbcl-marshal")
3714      (version (git-version "1.3.0" revision commit))
3715      (source
3716       (origin
3717        (method git-fetch)
3718        (uri (git-reference
3719              (url "https://github.com/wlbr/cl-marshal")
3720              (commit commit)))
3721        (file-name (git-file-name name version))
3722        (sha256
3723         (base32 "08qs6fhk38xpkkjkpcj92mxx0lgy4ygrbbzrmnivdx281syr0gwh"))))
3724      (build-system asdf-build-system/sbcl)
3725      (home-page "https://github.com/wlbr/cl-marshal")
3726      (synopsis "Simple (de)serialization of Lisp datastructures")
3727      (description
3728       "Simple and fast marshalling of Lisp datastructures.  Convert any object
3729 into a string representation, put it on a stream an revive it from there.
3730 Only minimal changes required to make your CLOS objects serializable.")
3731      (license license:expat))))
3732
3733 (define-public cl-marshal
3734   (sbcl-package->cl-source-package sbcl-marshal))
3735
3736 (define-public ecl-marshal
3737   (sbcl-package->ecl-package sbcl-marshal))
3738
3739 (define-public sbcl-checkl
3740   (let ((commit "80328800d047fef9b6e32dfe6bdc98396aee3cc9")
3741         (revision "1"))
3742     (package
3743       (name "sbcl-checkl")
3744       (version (git-version "0.0.0" revision commit))
3745       (source
3746        (origin
3747          (method git-fetch)
3748          (uri (git-reference
3749                (url "https://github.com/rpav/CheckL")
3750                (commit commit)))
3751          (file-name (git-file-name name version))
3752          (sha256
3753           (base32 "0bpisihx1gay44xmyr1dmhlwh00j0zzi04rp9fy35i95l2r4xdlx"))))
3754       (build-system asdf-build-system/sbcl)
3755       (arguments
3756        ;; Error while trying to load definition for system checkl-test from
3757        ;; pathname [...]/checkl-test.asd: The function CHECKL:DEFINE-TEST-OP
3758        ;; is undefined.
3759        '(#:asd-files '("checkl.asd")
3760          #:tests? #f))
3761       (native-inputs
3762        `(("sbcl-fiveam" ,sbcl-fiveam)))
3763       (inputs
3764        `(("sbcl-marshal" ,sbcl-marshal)))
3765       (home-page "https://github.com/rpav/CheckL/")
3766       (synopsis "Dynamic testing for Common Lisp")
3767       (description
3768        "CheckL lets you write tests dynamically, it checks resulting values
3769 against the last run.")
3770       ;; The author specifies both LLGPL and "BSD", but the "BSD" license
3771       ;; isn't specified anywhere, so I don't know which kind.  LLGPL is the
3772       ;; stronger of the two and so I think only listing this should suffice.
3773       (license license:llgpl))))
3774
3775 (define-public cl-checkl
3776   (sbcl-package->cl-source-package sbcl-checkl))
3777
3778 (define-public ecl-checkl
3779   (sbcl-package->ecl-package sbcl-checkl))
3780
3781 (define-public sbcl-fast-io
3782   (let ((commit "603f4903dd74fb221859da7058ae6ca3853fe64b")
3783         (revision "2"))
3784     (package
3785      (name "sbcl-fast-io")
3786      (version (git-version "1.0.0" revision commit))
3787      (source
3788       (origin
3789        (method git-fetch)
3790        (uri (git-reference
3791              (url "https://github.com/rpav/fast-io")
3792              (commit commit)))
3793        (file-name (git-file-name name version))
3794        (sha256
3795         (base32 "00agvc0xx4w715i6ach05p995zpcpghn04xc06zyci06q677vw3n"))))
3796      (build-system asdf-build-system/sbcl)
3797      (arguments
3798       ;; Error while trying to load definition for system fast-io-test from
3799       ;; pathname [...]/fast-io-test.asd: The function CHECKL:DEFINE-TEST-OP
3800       ;; is undefined.
3801       '(#:tests? #f
3802         #:asd-files '("fast-io.asd")))
3803      (native-inputs
3804       `(("sbcl-fiveam" ,sbcl-fiveam)
3805         ("sbcl-checkl" ,sbcl-checkl)))
3806      (inputs
3807       `(("sbcl-alexandria" ,sbcl-alexandria)
3808         ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)
3809         ("sbcl-static-vectors" ,sbcl-static-vectors)))
3810      (home-page "https://github.com/rpav/fast-io")
3811      (synopsis "Fast octet-vector/stream I/O for Common Lisp")
3812      (description
3813       "Fast-io is about improving performance to octet-vectors and octet
3814 streams (though primarily the former, while wrapping the latter).")
3815      ;; Author specifies this as NewBSD which is an alias
3816      (license license:bsd-3))))
3817
3818 (define-public cl-fast-io
3819   (sbcl-package->cl-source-package sbcl-fast-io))
3820
3821 (define-public ecl-fast-io
3822   (sbcl-package->ecl-package sbcl-fast-io))
3823
3824 (define-public sbcl-jonathan
3825   (let ((commit "1f448b4f7ac8265e56e1c02b32ce383e65316300")
3826         (revision "1"))
3827     (package
3828      (name "sbcl-jonathan")
3829      (version (git-version "0.1.0" revision commit))
3830      (source
3831       (origin
3832        (method git-fetch)
3833        (uri (git-reference
3834              (url "https://github.com/Rudolph-Miller/jonathan")
3835              (commit commit)))
3836        (file-name (git-file-name name version))
3837        (sha256
3838         (base32 "14x4iwz3mbag5jzzzr4sb6ai0m9r4q4kyypbq32jmsk2dx1hi807"))))
3839      (build-system asdf-build-system/sbcl)
3840      (arguments
3841       ;; Tests fail with: Component JONATHAN-ASD::JONATHAN-TEST not found,
3842       ;; required by #<SYSTEM "jonathan">. Why?
3843       `(#:tests? #f))
3844      (native-inputs
3845       `(("sbcl-prove" ,sbcl-prove)))
3846      (inputs
3847       `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
3848         ("sbcl-fast-io" ,sbcl-fast-io)
3849         ("sbcl-proc-parse" ,sbcl-proc-parse)
3850         ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)))
3851      (home-page "https://rudolph-miller.github.io/jonathan/overview.html")
3852      (synopsis "JSON encoder and decoder")
3853      (description
3854       "High performance JSON encoder and decoder.  Currently support: SBCL,
3855 CCL.")
3856      ;; Author specifies the MIT license
3857      (license license:expat))))
3858
3859 (define-public cl-jonathan
3860   (sbcl-package->cl-source-package sbcl-jonathan))
3861
3862 (define-public ecl-jonathan
3863   (sbcl-package->ecl-package sbcl-jonathan))
3864
3865 (define-public sbcl-http-body
3866   (let ((commit "dd01dc4f5842e3d29728552e5163acce8386eb73")
3867         (revision "1"))
3868     (package
3869      (name "sbcl-http-body")
3870      (version (git-version "0.1.0" revision commit))
3871      (source
3872       (origin
3873        (method git-fetch)
3874        (uri (git-reference
3875              (url "https://github.com/fukamachi/http-body")
3876              (commit commit)))
3877        (file-name (git-file-name name version))
3878        (sha256
3879         (base32 "1jd06snjvxcprhapgfq8sx0y5lrldkvhf206ix6d5a23dd6zcmr0"))))
3880      (build-system asdf-build-system/sbcl)
3881      (arguments
3882       ;; Tests fail with: Component HTTP-BODY-ASD::HTTP-BODY-TEST not
3883       ;; found, required by #<SYSTEM "http-body">. Why?
3884       `(#:tests? #f))
3885      (native-inputs
3886       `(("sbcl-prove" ,sbcl-prove)))
3887      (inputs
3888       `(("sbcl-fast-http" ,sbcl-fast-http)
3889         ("sbcl-jonathan" ,sbcl-jonathan)
3890         ("sbcl-quri" ,sbcl-quri)))
3891      (home-page "https://github.com/fukamachi/http-body")
3892      (synopsis "HTTP POST data parser")
3893      (description
3894       "HTTP-Body parses HTTP POST data and returns POST parameters.  It
3895 supports application/x-www-form-urlencoded, application/json, and
3896 multipart/form-data.")
3897      (license license:bsd-2))))
3898
3899 (define-public cl-http-body
3900   (sbcl-package->cl-source-package sbcl-http-body))
3901
3902 (define-public ecl-http-body
3903   (sbcl-package->ecl-package sbcl-http-body))
3904
3905 (define-public sbcl-circular-streams
3906   (let ((commit "e770bade1919c5e8533dd2078c93c3d3bbeb38df")
3907         (revision "1"))
3908     (package
3909      (name "sbcl-circular-streams")
3910      (version (git-version "0.1.0" revision commit))
3911      (source
3912       (origin
3913        (method git-fetch)
3914        (uri (git-reference
3915              (url "https://github.com/fukamachi/circular-streams")
3916              (commit commit)))
3917        (file-name (git-file-name name version))
3918        (sha256
3919         (base32 "1wpw6d5cciyqcf92f7mvihak52pd5s47kk4qq6f0r2z2as68p5rs"))))
3920      (build-system asdf-build-system/sbcl)
3921      (arguments
3922       ;; The tests depend on cl-test-more which is now prove. Prove
3923       ;; tests aren't working for some reason.
3924       `(#:tests? #f))
3925      (inputs
3926       `(("sbcl-fast-io" ,sbcl-fast-io)
3927         ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)))
3928      (home-page "https://github.com/fukamachi/circular-streams")
3929      (synopsis "Circularly readable streams for Common Lisp")
3930      (description
3931       "Circular-Streams allows you to read streams circularly by wrapping real
3932 streams. Once you reach end-of-file of a stream, it's file position will be
3933 reset to 0 and you're able to read it again.")
3934      (license license:llgpl))))
3935
3936 (define-public cl-circular-streams
3937   (sbcl-package->cl-source-package sbcl-circular-streams))
3938
3939 (define-public ecl-circular-streams
3940   (sbcl-package->ecl-package sbcl-circular-streams))
3941
3942 (define-public sbcl-lack
3943   (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
3944         (revision "1"))
3945     (package
3946       (name "sbcl-lack")
3947       (version (git-version "0.1.0" revision commit))
3948       (source
3949        (origin
3950          (method git-fetch)
3951          (uri (git-reference
3952                (url "https://github.com/fukamachi/lack")
3953                (commit commit)))
3954          (file-name (git-file-name "lack" version))
3955          (sha256
3956           (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
3957       (build-system asdf-build-system/sbcl)
3958       (native-inputs
3959        `(("prove" ,sbcl-prove)))
3960       (inputs
3961        `(("circular-streams" ,sbcl-circular-streams)
3962          ("http-body" ,sbcl-http-body)
3963          ("ironclad" ,sbcl-ironclad)
3964          ("local-time" ,sbcl-local-time)
3965          ("quri" ,sbcl-quri)
3966          ("trivial-mimes" ,sbcl-trivial-mimes)))
3967       (arguments
3968        '(#:asd-systems '("lack"
3969                          "lack-request"
3970                          "lack-response"
3971                          "lack-component"
3972                          "lack-util"
3973                          "lack-middleware-backtrace"
3974                          "lack-middleware-static")
3975          #:test-asd-file "t-lack.asd"
3976          ;; XXX: Component :CLACK not found
3977          #:tests? #f))
3978       (home-page "https://github.com/fukamachi/lack")
3979       (synopsis "Lack, the core of Clack")
3980       (description
3981        "Lack is a Common Lisp library which allows web applications to be
3982 constructed of modular components.  It was originally a part of Clack, however
3983 it's going to be rewritten as an individual project since Clack v2 with
3984 performance and simplicity in mind.")
3985       (license license:llgpl))))
3986
3987 (define-public cl-lack
3988   (sbcl-package->cl-source-package sbcl-lack))
3989
3990 (define-public ecl-lack
3991   (sbcl-package->ecl-package sbcl-lack))
3992
3993 (define-public sbcl-local-time
3994   (let ((commit "62792705245168d3fc2e04164b9a143477284142")
3995         (revision "1"))
3996     (package
3997      (name "sbcl-local-time")
3998      (version (git-version "1.0.6" revision commit))
3999      (source
4000       (origin
4001        (method git-fetch)
4002        (uri (git-reference
4003              (url "https://github.com/dlowe-net/local-time")
4004              (commit commit)))
4005        (file-name (git-file-name name version))
4006        (sha256
4007         (base32 "1r5zq4l1lrgprdr2pw7wwry194yknnllyjf6lx7snypb3k4r3yir"))))
4008      (build-system asdf-build-system/sbcl)
4009      (arguments
4010       ;; TODO: Component :STEFIL not found, required by #<SYSTEM
4011       ;; "local-time/test">
4012       '(#:tests? #f))
4013      (native-inputs
4014       `(("stefil" ,sbcl-hu.dwim.stefil)))
4015      (inputs
4016       `(("sbcl-cl-fad" ,sbcl-cl-fad)))
4017      (home-page "https://common-lisp.net/project/local-time/")
4018      (synopsis "Time manipulation library for Common Lisp")
4019      (description
4020       "The LOCAL-TIME library is a Common Lisp library for the manipulation of
4021 dates and times.  It is based almost entirely upon Erik Naggum's paper \"The
4022 Long Painful History of Time\".")
4023      (license license:expat))))
4024
4025 (define-public cl-local-time
4026   (sbcl-package->cl-source-package sbcl-local-time))
4027
4028 (define-public ecl-local-time
4029   (sbcl-package->ecl-package sbcl-local-time))
4030
4031 (define-public sbcl-trivial-mimes
4032   (let ((commit "303f8ac0aa6ca0bc139aa3c34822e623c3723fab")
4033         (revision "1"))
4034     (package
4035       (name "sbcl-trivial-mimes")
4036       (version (git-version "1.1.0" revision commit))
4037       (source
4038        (origin
4039          (method git-fetch)
4040          (uri (git-reference
4041                (url "https://github.com/Shinmera/trivial-mimes")
4042                (commit commit)))
4043          (file-name (git-file-name name version))
4044          (sha256
4045           (base32 "17jxgl47r695bvsb7wi3n2ws5rp1zzgvw0zii8cy5ggw4b4ayv6m"))))
4046       (build-system asdf-build-system/sbcl)
4047       (native-inputs
4048        `(("stefil" ,sbcl-hu.dwim.stefil)))
4049       (inputs
4050        `(("sbcl-cl-fad" ,sbcl-cl-fad)))
4051       (home-page "https://shinmera.github.io/trivial-mimes/")
4052       (synopsis "Tiny Common Lisp library to detect mime types in files")
4053       (description
4054        "This is a teensy library that provides some functions to determine the
4055 mime-type of a file.")
4056       (license license:artistic2.0))))
4057
4058 (define-public cl-trivial-mimes
4059   (sbcl-package->cl-source-package sbcl-trivial-mimes))
4060
4061 (define-public ecl-trivial-mimes
4062   (sbcl-package->ecl-package sbcl-trivial-mimes))
4063
4064 (define-public sbcl-ningle
4065   (let ((commit "50bd4f09b5a03a7249bd4d78265d6451563b25ad")
4066         (revision "1"))
4067     (package
4068       (name "sbcl-ningle")
4069       (version (git-version "0.3.0" revision commit))
4070       (source
4071        (origin
4072          (method git-fetch)
4073          (uri (git-reference
4074                (url "https://github.com/fukamachi/ningle")
4075                (commit commit)))
4076          (file-name (git-file-name name version))
4077          (sha256
4078           (base32 "1bsl8cnxhacb8p92z9n89vhk1ikmij5zavk0m2zvmj7iqm79jzgw"))))
4079       (build-system asdf-build-system/sbcl)
4080       (arguments
4081        ;; TODO: pull in clack-test
4082        '(#:tests? #f
4083          #:phases
4084          (modify-phases %standard-phases
4085            (delete 'cleanup-files)
4086            (delete 'cleanup)
4087            (add-before 'cleanup 'combine-fasls
4088              (lambda* (#:key outputs #:allow-other-keys)
4089                (let* ((out (assoc-ref outputs "out"))
4090                       (lib (string-append out "/lib/sbcl"))
4091                       (ningle-path (string-append lib "/ningle"))
4092                       (fasl-files (find-files out "\\.fasl$")))
4093                  (mkdir-p ningle-path)
4094                  (let ((fasl-path (lambda (name)
4095                                     (string-append ningle-path
4096                                                    "/"
4097                                                    (basename name)
4098                                                    "--system.fasl"))))
4099                    (for-each (lambda (file)
4100                                (rename-file file
4101                                             (fasl-path
4102                                              (basename file ".fasl"))))
4103                              fasl-files))
4104                  fasl-files)
4105                #t)))))
4106       (native-inputs
4107        `(("sbcl-prove" ,sbcl-prove)))
4108       (inputs
4109        `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
4110          ("sbcl-myway" ,sbcl-myway)
4111          ("sbcl-lack" ,sbcl-lack)
4112          ("sbcl-alexandria" ,sbcl-alexandria)
4113          ("sbcl-babel" ,sbcl-babel)))
4114       (home-page "https://8arrow.org/ningle/")
4115       (synopsis "Super micro framework for Common Lisp")
4116       (description
4117        "Ningle is a lightweight web application framework for Common Lisp.")
4118       (license license:llgpl))))
4119
4120 (define-public cl-ningle
4121   (sbcl-package->cl-source-package sbcl-ningle))
4122
4123 (define-public ecl-ningle
4124   (sbcl-package->ecl-package sbcl-ningle))
4125
4126 (define-public sbcl-cl-fastcgi
4127   (let ((commit "d576d20eeb12f225201074b28934ba395b15781a")
4128         (revision "1"))
4129     (package
4130       (name "sbcl-cl-fastcgi")
4131       (version (git-version "0.2" revision commit))
4132       (source
4133        (origin
4134          (method git-fetch)
4135          (uri (git-reference
4136                (url "https://github.com/KDr2/cl-fastcgi/")
4137                (commit commit)))
4138          (file-name (git-file-name name version))
4139          (sha256
4140           (base32 "02mvzzyn0k960s38rbxaqqmdkwcfmyhf8dx6ynz8xyxflmp0s5zv"))))
4141       (build-system asdf-build-system/sbcl)
4142       (inputs
4143        `(("usocket" ,sbcl-usocket)
4144          ("cffi" ,sbcl-cffi)
4145          ("fcgi" ,fcgi)))
4146       (arguments
4147        `(#:phases
4148          (modify-phases %standard-phases
4149            (add-after 'unpack 'fix-paths
4150              (lambda* (#:key inputs #:allow-other-keys)
4151                (substitute* "cl-fastcgi.lisp"
4152                  (("\"libfcgi.so\"")
4153                   (string-append
4154                    "\""
4155                    (assoc-ref inputs "fcgi") "/lib/libfcgi.so\""))))))))
4156       (home-page "https://kdr2.com/project/cl-fastcgi.html")
4157       (synopsis "FastCGI wrapper for Common Lisp")
4158       (description
4159        "CL-FastCGI is a generic version of SB-FastCGI, targeting to run on
4160 mostly Common Lisp implementation.")
4161       ;; TODO: Upstream on specifies "BSD license":
4162       ;; https://github.com/KDr2/cl-fastcgi/issues/4
4163       (license license:bsd-2))))
4164
4165 (define-public cl-fastcgi
4166   (sbcl-package->cl-source-package sbcl-cl-fastcgi))
4167
4168 (define-public ecl-cl-fastcgi
4169   (sbcl-package->ecl-package sbcl-cl-fastcgi))
4170
4171 (define-public sbcl-clack
4172   (let ((commit "e3e032843bb1220ab96263c411aa7f2feb4746e0")
4173         (revision "1"))
4174     (package
4175       (name "sbcl-clack")
4176       (version (git-version "2.0.0" revision commit))
4177       (source
4178        (origin
4179          (method git-fetch)
4180          (uri (git-reference
4181                (url "https://github.com/fukamachi/clack")
4182                (commit commit)))
4183          (file-name (git-file-name name version))
4184          (sha256
4185           (base32 "1ymzs6qyrwhlj6cgqsnpyn6g5cbp7a3s1vgxwna20y2q7y4iacy0"))))
4186       (build-system asdf-build-system/sbcl)
4187       (inputs
4188        `(("alexandria" ,sbcl-alexandria)
4189          ("bordeaux-threads" ,sbcl-bordeaux-threads)
4190          ("cl-fastcgi" ,sbcl-cl-fastcgi)
4191          ("flexi-streams" ,sbcl-flexi-streams)
4192          ("hunchentoot" ,sbcl-hunchentoot)
4193          ("lack" ,sbcl-lack)
4194          ("split-sequence" ,sbcl-split-sequence)
4195          ("usocket" ,sbcl-usocket)
4196          ("quri" ,sbcl-quri)))
4197       (arguments
4198        '(#:asd-systems '("clack"
4199                          "clack-handler-fcgi"
4200                          "clack-socket"
4201                          "clack-handler-hunchentoot")))
4202       (home-page "https://github.com/fukamachi/clack")
4203       (synopsis "Web Application Environment for Common Lisp")
4204       (description
4205        "Clack is a web application environment for Common Lisp inspired by
4206 Python's WSGI and Ruby's Rack.")
4207       (license license:llgpl))))
4208
4209 (define-public cl-clack
4210   (sbcl-package->cl-source-package sbcl-clack))
4211
4212 (define-public ecl-clack
4213   (sbcl-package->ecl-package sbcl-clack))
4214
4215 (define-public sbcl-log4cl
4216   (let ((commit "611e094458504b938d49de904eab141285328c7c")
4217         (revision "1"))
4218     (package
4219       (name "sbcl-log4cl")
4220       (build-system asdf-build-system/sbcl)
4221       (version "1.1.2")
4222       (source
4223        (origin
4224          (method git-fetch)
4225          (uri (git-reference
4226                (url "https://github.com/sharplispers/log4cl")
4227                (commit commit)))
4228          (file-name (git-file-name name version))
4229          (sha256
4230           (base32
4231            "08jly0s0g26b56hhpfizxsb4j0yvbh946sd205gr42dkzv8l7dsc"))))
4232       ;; FIXME: tests require stefil, sbcl-hu.dwim.stefil wont work
4233       (arguments
4234        `(#:tests? #f))
4235       (inputs `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
4236       (synopsis "Common Lisp logging framework, modeled after Log4J")
4237       (home-page "https://github.com/7max/log4cl")
4238       (description "This is a Common Lisp logging framework that can log at
4239 various levels and mix text with expressions.")
4240       (license license:asl2.0))))
4241
4242 (define-public cl-log4cl
4243   (sbcl-package->cl-source-package sbcl-log4cl))
4244
4245 (define-public ecl-log4cl
4246   (sbcl-package->ecl-package sbcl-log4cl))
4247
4248 (define-public sbcl-find-port
4249   (let ((commit "00c96a25af93a0f8681d34ec548861f2d7485478")
4250         (revision "1"))
4251     (package
4252       (name "sbcl-find-port")
4253       (build-system asdf-build-system/sbcl)
4254       (version "0.1")
4255       (home-page "https://github.com/eudoxia0/find-port")
4256       (source
4257        (origin
4258          (method git-fetch)
4259          (uri (git-reference
4260                (url home-page)
4261                (commit commit)))
4262          (file-name (git-file-name name version))
4263          (sha256
4264           (base32
4265            "0d6dzbb45jh0rx90wgs6v020k2xa87mvzas3mvfzvivjvqqlpryq"))))
4266       (native-inputs
4267        `(("fiveam" ,sbcl-fiveam)))
4268       (inputs
4269        `(("sbcl-usocket" ,sbcl-usocket)))
4270       (synopsis "Find open ports programmatically in Common Lisp")
4271       (description "This is a small Common Lisp library that finds an open
4272 port within a range.")
4273       (license license:expat))))
4274
4275 (define-public cl-find-port
4276   (sbcl-package->cl-source-package sbcl-find-port))
4277
4278 (define-public ecl-find-port
4279   (sbcl-package->ecl-package sbcl-find-port))
4280
4281 (define-public sbcl-clunit
4282   (let ((commit "6f6d72873f0e1207f037470105969384f8380628")
4283         (revision "1"))
4284     (package
4285       (name "sbcl-clunit")
4286       (version (git-version "0.2.3" revision commit))
4287       (source
4288        (origin
4289          (method git-fetch)
4290          (uri (git-reference
4291                (url "https://github.com/tgutu/clunit")
4292                (commit commit)))
4293          (file-name (git-file-name name version))
4294          (sha256
4295           (base32
4296            "1idf2xnqzlhi8rbrqmzpmb3i1l6pbdzhhajkmhwbp6qjkmxa4h85"))))
4297       (build-system asdf-build-system/sbcl)
4298       (synopsis "CLUnit is a Common Lisp unit testing framework")
4299       (description
4300        "CLUnit is a Common Lisp unit testing framework.  It is designed
4301 to be easy to use so that you can quickly start testing.  CLUnit
4302 provides a rich set of features aimed at improving your unit testing
4303 experience.")
4304       (home-page "https://tgutu.github.io/clunit/")
4305       ;; MIT License
4306       (license license:expat))))
4307
4308 (define-public cl-clunit
4309   (sbcl-package->cl-source-package sbcl-clunit))
4310
4311 (define-public ecl-clunit
4312   (sbcl-package->ecl-package sbcl-clunit))
4313
4314 (define-public sbcl-py4cl
4315   (let ((commit "4c8a2b0814fd311f978964f825ce012290f60136")
4316         (revision "1"))
4317     (package
4318       (name "sbcl-py4cl")
4319       (version (git-version "0.0.0" revision commit))
4320       (source
4321        (origin
4322          (method git-fetch)
4323          (uri (git-reference
4324                (url "https://github.com/bendudson/py4cl")
4325                (commit commit)))
4326          (file-name (git-file-name name version))
4327          (sha256
4328           (base32
4329            "15mk7qdqjkj56gdnbyrdyz6r7m1h26ldvn6ch96pmvg5vmr1m45r"))
4330          (modules '((guix build utils)))))
4331       (build-system asdf-build-system/sbcl)
4332       (native-inputs
4333        `(("sbcl-clunit" ,sbcl-clunit)))
4334       (inputs
4335        `(("sbcl-trivial-garbage" ,sbcl-trivial-garbage)))
4336       (propagated-inputs
4337        ;; This package doesn't do anything without python available
4338        `(("python" ,python)
4339          ;; For multi-dimensional array support
4340          ("python-numpy" ,python-numpy)))
4341       (arguments
4342        '(#:phases
4343          (modify-phases %standard-phases
4344            (add-after 'unpack 'replace-*base-directory*-var
4345              (lambda* (#:key outputs #:allow-other-keys)
4346                ;; In the ASD, the author makes an attempt to
4347                ;; programatically determine the location of the
4348                ;; source-code so lisp can call into "py4cl.py". We can
4349                ;; hard-code this since we know where this file will
4350                ;; reside.
4351                (substitute* "src/callpython.lisp"
4352                  (("py4cl/config:\\*base-directory\\*")
4353                   (string-append
4354                    "\""
4355                    (assoc-ref outputs "out")
4356                    "/share/common-lisp/sbcl-source/py4cl/"
4357                    "\""))))))))
4358       (synopsis "Call python from Common Lisp")
4359       (description
4360        "Py4CL is a bridge between Common Lisp and Python, which enables Common
4361 Lisp to interact with Python code.  It uses streams to communicate with a
4362 separate python process, the approach taken by cl4py.  This is different to
4363 the CFFI approach used by burgled-batteries, but has the same goal.")
4364       (home-page "https://github.com/bendudson/py4cl")
4365       ;; MIT License
4366       (license license:expat))))
4367
4368 (define-public cl-py4cl
4369   (sbcl-package->cl-source-package sbcl-py4cl))
4370
4371 (define-public ecl-py4cl
4372   (sbcl-package->ecl-package sbcl-py4cl))
4373
4374 (define-public sbcl-parse-declarations
4375   (let ((commit "549aebbfb9403a7fe948654126b9c814f443f4f2")
4376         (revision "1"))
4377     (package
4378       (name "sbcl-parse-declarations")
4379       (version (git-version "1.0.0" revision commit))
4380       (source
4381        (origin
4382          (method git-fetch)
4383          (uri (git-reference
4384                (url (string-append
4385                      "https://gitlab.common-lisp.net/parse-declarations/"
4386                      "parse-declarations.git"))
4387                (commit commit)))
4388          (file-name (git-file-name name version))
4389          (sha256
4390           (base32 "03g5qks4c59nmxa48pbslxkfh77h8hn8566jddp6m9pl15dzzpxd"))))
4391       (build-system asdf-build-system/sbcl)
4392       (arguments
4393        `(#:asd-systems '("parse-declarations-1.0")))
4394       (home-page "https://common-lisp.net/project/parse-declarations/")
4395       (synopsis "Parse, filter, and build declarations")
4396       (description
4397        "Parse-Declarations is a Common Lisp library to help writing
4398 macros which establish bindings.  To be semantically correct, such
4399 macros must take user declarations into account, as these may affect
4400 the bindings they establish.  Yet the ANSI standard of Common Lisp does
4401 not provide any operators to work with declarations in a convenient,
4402 high-level way.  This library provides such operators.")
4403       ;; MIT License
4404       (license license:expat))))
4405
4406 (define-public cl-parse-declarations
4407   (sbcl-package->cl-source-package sbcl-parse-declarations))
4408
4409 (define-public ecl-parse-declarations
4410   (sbcl-package->ecl-package sbcl-parse-declarations))
4411
4412 (define-public sbcl-cl-quickcheck
4413   (let ((commit "807b2792a30c883a2fbecea8e7db355b50ba662f")
4414         (revision "1"))
4415     (package
4416       (name "sbcl-cl-quickcheck")
4417       (version (git-version "0.0.4" revision commit))
4418       (source
4419        (origin
4420          (method git-fetch)
4421          (uri (git-reference
4422                (url "https://github.com/mcandre/cl-quickcheck")
4423                (commit commit)))
4424          (file-name (git-file-name name version))
4425          (sha256
4426           (base32
4427            "165lhypq5xkcys6hvzb3jq7ywnmqvzaflda29qk2cbs3ggas4767"))))
4428       (build-system asdf-build-system/sbcl)
4429       (synopsis
4430        "Common Lisp port of the QuickCheck unit test framework")
4431       (description
4432        "Common Lisp port of the QuickCheck unit test framework")
4433       (home-page "https://github.com/mcandre/cl-quickcheck")
4434       ;; MIT
4435       (license license:expat))))
4436
4437 (define-public cl-quickcheck
4438   (sbcl-package->cl-source-package sbcl-cl-quickcheck))
4439
4440 (define-public ecl-cl-quickcheck
4441   (sbcl-package->ecl-package sbcl-cl-quickcheck))
4442
4443 (define-public sbcl-burgled-batteries3
4444   (let ((commit "f65f454d13bb6c40e17e9ec62e41eb5069e09760")
4445         (revision "2"))
4446     (package
4447       (name "sbcl-burgled-batteries3")
4448       (version (git-version "0.0.0" revision commit))
4449       (source
4450        (origin
4451          (method git-fetch)
4452          (uri (git-reference
4453                (url "https://github.com/snmsts/burgled-batteries3")
4454                (commit commit)))
4455          (file-name (git-file-name name version))
4456          (sha256
4457           (base32
4458            "1nzn7jawrfajyzwfnzrg2cmn9xxadcqh4szbpg0jggkhdkdzz4wa"))))
4459       (build-system asdf-build-system/sbcl)
4460       (arguments
4461        `(#:tests? #f
4462          #:modules (((guix build python-build-system) #:select (python-version))
4463                     ,@%asdf-build-system-modules)
4464          #:imported-modules ((guix build python-build-system)
4465                              ,@%asdf-build-system-modules)
4466          #:phases
4467          (modify-phases (@ (guix build asdf-build-system) %standard-phases)
4468            (add-after 'unpack 'set-*cpython-include-dir*-var
4469              (lambda* (#:key inputs #:allow-other-keys)
4470                (let ((python (assoc-ref inputs "python")))
4471                  (setenv "BB_PYTHON3_INCLUDE_DIR"
4472                          (string-append python "/include/python"
4473                                         (python-version python)))
4474                  (setenv "BB_PYTHON3_DYLIB"
4475                          (string-append python "/lib/libpython3.so"))
4476                  #t)))
4477            (add-after 'unpack 'adjust-for-python-3.8
4478              (lambda _
4479                ;; This method is no longer part of the public API.
4480                (substitute* "ffi-interface.lisp"
4481                  ((".*PyEval_ReInitThreads.*")
4482                   ""))
4483                #t)))))
4484       (native-inputs
4485        `(("sbcl-cl-fad" ,sbcl-cl-fad)
4486          ("sbcl-lift" ,sbcl-lift)
4487          ("sbcl-cl-quickcheck" ,sbcl-cl-quickcheck)))
4488       (inputs
4489        `(("python" ,python)
4490          ("sbcl-cffi" ,sbcl-cffi)
4491          ("sbcl-alexandria" , sbcl-alexandria)
4492          ("sbcl-parse-declarations-1.0" ,sbcl-parse-declarations)
4493          ("sbcl-trivial-garbage" ,sbcl-trivial-garbage)))
4494       (synopsis "Bridge between Python and Lisp (FFI bindings, etc.)")
4495       (description
4496        "This package provides a shim between Python3 (specifically, the
4497 CPython implementation of Python) and Common Lisp.")
4498       (home-page "https://github.com/snmsts/burgled-batteries3")
4499       (license license:expat))))
4500
4501 (define-public cl-burgled-batteries3
4502   (sbcl-package->cl-source-package sbcl-burgled-batteries3))
4503
4504 (define-public ecl-burgled-batteries3
4505   (sbcl-package->ecl-package sbcl-burgled-batteries3))
4506
4507 (define-public sbcl-metabang-bind
4508   (let ((commit "c93b7f7e1c18c954c2283efd6a7fdab36746ab5e")
4509         (revision "1"))
4510     (package
4511       (name "sbcl-metabang-bind")
4512       (version (git-version "0.8.0" revision commit))
4513       (source
4514        (origin
4515          (method git-fetch)
4516          (uri (git-reference
4517                (url "https://github.com/gwkkwg/metabang-bind")
4518                (commit commit)))
4519          (file-name (git-file-name name version))
4520          (sha256
4521           (base32
4522            "0hd0kr91795v77akpbcyqiss9p0p7ypa9dznrllincnmgvsxlmf0"))))
4523       (build-system asdf-build-system/sbcl)
4524       (native-inputs
4525        `(("sbcl-lift" ,sbcl-lift)))
4526       (synopsis "Macro that generalizes @code{multiple-value-bind} etc.")
4527       (description
4528        "Bind extends the idea of of let and destructing to provide a uniform
4529 syntax for all your accessor needs.  It combines @code{let},
4530 @code{destructuring-bind}, @code{with-slots}, @code{with-accessors}, structure
4531 editing, property or association-lists, and @code{multiple-value-bind} and a
4532 whole lot more into a single form.")
4533       (home-page "https://common-lisp.net/project/metabang-bind/")
4534       ;; MIT License
4535       (license license:expat))))
4536
4537 (define-public cl-metabang-bind
4538   (sbcl-package->cl-source-package sbcl-metabang-bind))
4539
4540 (define-public ecl-metabang-bind
4541   (sbcl-package->ecl-package sbcl-metabang-bind))
4542
4543 (define-public sbcl-fare-utils
4544   (let ((commit "66e9c6f1499140bc00ccc22febf2aa528cbb5724")
4545         (revision "1"))
4546     (package
4547       (name "sbcl-fare-utils")
4548       (version (git-version "1.0.0.5" revision commit))
4549       (source
4550        (origin
4551          (method git-fetch)
4552          (uri
4553           (git-reference
4554            (url
4555             "https://gitlab.common-lisp.net/frideau/fare-utils.git")
4556            (commit commit)))
4557          (file-name (git-file-name name version))
4558          (sha256
4559           (base32
4560            "01wsr1aap3jdzhn4hrqjbhsjx6qci9dbd3gh4gayv1p49rbg8aqr"))))
4561       (build-system asdf-build-system/sbcl)
4562       (arguments
4563        `(#:test-asd-file "test/fare-utils-test.asd"))
4564       (native-inputs
4565        `(("sbcl-hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
4566       (synopsis "Collection of utilities and data structures")
4567       (description
4568        "fare-utils is a small collection of utilities.  It contains a lot of
4569 basic everyday functions and macros.")
4570       (home-page "https://gitlab.common-lisp.net/frideau/fare-utils")
4571       ;; MIT License
4572       (license license:expat))))
4573
4574 (define-public cl-fare-utils
4575   (sbcl-package->cl-source-package sbcl-fare-utils))
4576
4577 (define-public ecl-fare-utils
4578   (sbcl-package->ecl-package sbcl-fare-utils))
4579
4580 (define-public sbcl-trivial-utf-8
4581   (let ((commit "4d427cfbb1c452436a0efb71c3205c9da67f718f")
4582         (revision "1"))
4583     (package
4584       (name "sbcl-trivial-utf-8")
4585       (version (git-version "0.0.0" revision commit))
4586       (source
4587        (origin
4588          (method git-fetch)
4589          (uri
4590           (git-reference
4591            (url (string-append "https://gitlab.common-lisp.net/"
4592                                "trivial-utf-8/trivial-utf-8.git"))
4593            (commit commit)))
4594          (file-name (git-file-name name version))
4595          (sha256
4596           (base32
4597            "1jz27gz8gvqdmvp3k9bxschs6d5b3qgk94qp2bj6nv1d0jc3m1l1"))))
4598       (arguments
4599        ;; Guix incorrectly assumes the "8" is part of the version
4600        ;; number and lobs it off.
4601        `(#:asd-systems '("trivial-utf-8")))
4602       (build-system asdf-build-system/sbcl)
4603       (synopsis "UTF-8 input/output library")
4604       (description
4605        "The Babel library solves a similar problem while understanding more
4606 encodings.  Trivial UTF-8 was written before Babel existed, but for new
4607 projects you might be better off going with Babel.  The one plus that Trivial
4608 UTF-8 has is that it doesn't depend on any other libraries.")
4609       (home-page "https://common-lisp.net/project/trivial-utf-8/")
4610       (license license:bsd-3))))
4611
4612 (define-public cl-trivial-utf-8
4613   (sbcl-package->cl-source-package sbcl-trivial-utf-8))
4614
4615 (define-public ecl-trivial-utf-8
4616   (sbcl-package->ecl-package sbcl-trivial-utf-8))
4617
4618 (define-public sbcl-idna
4619   (package
4620     (name "sbcl-idna")
4621     (build-system asdf-build-system/sbcl)
4622     (version "0.2.2")
4623     (home-page "https://github.com/antifuchs/idna")
4624     (source
4625      (origin
4626        (method git-fetch)
4627        (uri (git-reference
4628              (url home-page)
4629              (commit version)))
4630        (file-name (git-file-name name version))
4631        (sha256
4632         (base32
4633          "00nbr3mffxhlq14gg9d16pa6691s4qh35inyw76v906s77khm5a2"))))
4634     (inputs
4635      `(("split-sequence" ,sbcl-split-sequence)))
4636     (synopsis "IDNA string encoding and decoding routines for Common Lisp")
4637     (description "This Common Lisp library provides string encoding and
4638 decoding routines for IDNA, the International Domain Names in Applications.")
4639     (license license:expat)))
4640
4641 (define-public cl-idna
4642   (sbcl-package->cl-source-package sbcl-idna))
4643
4644 (define-public ecl-idna
4645   (sbcl-package->ecl-package sbcl-idna))
4646
4647 (define-public sbcl-swap-bytes
4648   (package
4649     (name "sbcl-swap-bytes")
4650     (build-system asdf-build-system/sbcl)
4651     (version "1.2")
4652     (home-page "https://github.com/sionescu/swap-bytes")
4653     (source
4654      (origin
4655        (method git-fetch)
4656        (uri (git-reference
4657              (url home-page)
4658              (commit (string-append "v" version))))
4659        (file-name (git-file-name name version))
4660        (sha256
4661         (base32
4662          "1hw1v1lw26rifyznpnj1csphha9jgzwpiic16ni3pvs6hcsni9rz"))))
4663     (inputs
4664      `(("trivial-features" ,sbcl-trivial-features)))
4665     (native-inputs
4666      `(("fiveam" ,sbcl-fiveam)))
4667     (synopsis "Efficient endianness conversion for Common Lisp")
4668     (description "This Common Lisp library provides optimized byte-swapping
4669 primitives.  The library can change endianness of unsigned integers of length
4670 1/2/4/8.  Very useful in implementing various network protocols and file
4671 formats.")
4672     (license license:expat)))
4673
4674 (define-public cl-swap-bytes
4675   (sbcl-package->cl-source-package sbcl-swap-bytes))
4676
4677 (define-public ecl-swap-bytes
4678   (sbcl-package->ecl-package sbcl-swap-bytes))
4679
4680 (define-public sbcl-iolib
4681   ;; Latest release is from June 2017.
4682   (let ((commit "7f5ea3a8457a29d224b24653c2b3657fb1898021")
4683         (revision "2"))
4684     (package
4685       (name "sbcl-iolib")
4686       (version (git-version "0.8.3" revision commit))
4687       (home-page "https://github.com/sionescu/iolib")
4688       (source
4689        (origin
4690          (method git-fetch)
4691          (uri (git-reference
4692                (url home-page)
4693                (commit commit)))
4694          (file-name (git-file-name name version))
4695          (sha256
4696           (base32
4697            "1bg5w7lm61hqk4b0svmri8a590q36z76jfa0sdgzb39r98c04w12"))))
4698       (build-system asdf-build-system/sbcl)
4699       (inputs
4700        `(("alexandria" ,sbcl-alexandria)
4701          ("bordeaux-threads" ,sbcl-bordeaux-threads)
4702          ("cffi" ,sbcl-cffi)
4703          ("idna" ,sbcl-idna)
4704          ("libfixposix" ,libfixposix)
4705          ("split-sequence" ,sbcl-split-sequence)
4706          ("swap-bytes" ,sbcl-swap-bytes)))
4707       (arguments
4708        '(#:asd-files '("iolib.asdf.asd"
4709                        "iolib.conf.asd"
4710                        "iolib.common-lisp.asd"
4711                        "iolib.base.asd"
4712                        "iolib.asd")
4713          #:phases
4714          (modify-phases %standard-phases
4715            (add-after 'unpack 'fix-paths
4716              (lambda* (#:key inputs #:allow-other-keys)
4717                (substitute* "src/syscalls/ffi-functions-unix.lisp"
4718                  (("\\(:default \"libfixposix\"\\)")
4719                   (string-append
4720                    "(:default \""
4721                    (assoc-ref inputs "libfixposix") "/lib/libfixposix\")")))
4722                ;; Socket tests need Internet access, disable them.
4723                (substitute* "iolib.asd"
4724                  (("\\(:file \"sockets\" :depends-on \\(\"pkgdcl\" \"defsuites\"\\)\\)")
4725                   "")))))))
4726       (synopsis "Common Lisp I/O library")
4727       (description "IOlib is to be a better and more modern I/O library than
4728 the standard Common Lisp library.  It contains a socket library, a DNS
4729 resolver, an I/O multiplexer(which supports @code{select(2)}, @code{epoll(4)}
4730 and @code{kqueue(2)}), a pathname library and file-system utilities.")
4731       (license license:expat))))
4732
4733 (define-public cl-iolib
4734   (let ((parent (sbcl-package->cl-source-package sbcl-iolib)))
4735     (package
4736       (inherit parent)
4737       (propagated-inputs
4738        ;; Need header to compile.
4739        `(("libfixposix" ,libfixposix)
4740          ,@(package-propagated-inputs parent))))))
4741
4742 (define-public ecl-iolib
4743   (sbcl-package->ecl-package sbcl-iolib))
4744
4745 (define-public sbcl-ieee-floats
4746   (let ((commit "566b51a005e81ff618554b9b2f0b795d3b29398d")
4747         (revision "1"))
4748     (package
4749       (name "sbcl-ieee-floats")
4750       (build-system asdf-build-system/sbcl)
4751       (version (git-version "20170924" revision commit))
4752       (home-page "https://github.com/marijnh/ieee-floats/")
4753       (source
4754        (origin
4755          (method git-fetch)
4756          (uri (git-reference
4757                (url home-page)
4758                (commit commit)))
4759          (file-name (git-file-name name version))
4760          (sha256
4761           (base32
4762            "1xyj49j9x3lc84cv3dhbf9ja34ywjk1c46dklx425fxw9mkwm83m"))))
4763       (native-inputs
4764        `(("fiveam" ,sbcl-fiveam)))
4765       (synopsis "IEEE 754 binary representation for floats in Common Lisp")
4766       (description "This is a Common Lisp library that converts
4767 floating point values to IEEE 754 binary representation.")
4768       (license license:bsd-3))))
4769
4770 (define-public cl-ieee-floats
4771   (sbcl-package->cl-source-package sbcl-ieee-floats))
4772
4773 (define-public ecl-ieee-floats
4774   (sbcl-package->ecl-package sbcl-ieee-floats))
4775
4776 (define sbcl-closure-common
4777   (let ((commit "e3c5f5f454b72b01b89115e581c3c52a7e201e5c")
4778         (revision "1"))
4779     (package
4780       (name "sbcl-closure-common")
4781       (build-system asdf-build-system/sbcl)
4782       (version (git-version "20101006" revision commit))
4783       (home-page "https://common-lisp.net/project/cxml/")
4784       (source
4785        (origin
4786          (method git-fetch)
4787          (uri (git-reference
4788                (url "https://github.com/sharplispers/closure-common")
4789                (commit commit)))
4790          (file-name (git-file-name name version))
4791          (sha256
4792           (base32
4793            "0k5r2qxn122pxi301ijir3nayi9sg4d7yiy276l36qmzwhp4mg5n"))))
4794       (inputs
4795        `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)
4796          ("babel" ,sbcl-babel)))
4797       (synopsis "Support Common Lisp library for CXML")
4798       (description "Closure-common is an internal helper library.  The name
4799 Closure is a reference to the web browser it was originally written for.")
4800       ;; TODO: License?
4801       (license #f))))
4802
4803 (define-public sbcl-cxml
4804   (let ((commit "00b22bf4c4cf11c993d5866fae284f95ab18e6bf")
4805         (revision "1"))
4806     (package
4807       (name "sbcl-cxml")
4808       (version (git-version "0.0.0" revision commit))
4809       (source
4810        (origin
4811          (method git-fetch)
4812          (uri (git-reference
4813                (url "https://github.com/sharplispers/cxml")
4814                (commit commit)))
4815          (file-name (git-file-name name version))
4816          (sha256
4817           (base32
4818            "13kif7rf3gqdycsk9zq0d7y0g9y81krkl0z87k0p2fkbjfgrph37"))))
4819       (build-system asdf-build-system/sbcl)
4820     (inputs
4821      `(("closure-common" ,sbcl-closure-common)
4822        ("puri" ,sbcl-puri)
4823        ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
4824     (synopsis "Common Lisp XML parser")
4825     (description "CXML implements a namespace-aware, validating XML 1.0
4826 parser as well as the DOM Level 2 Core interfaces.  Two parser interfaces are
4827 offered, one SAX-like, the other similar to StAX.")
4828     (home-page "https://common-lisp.net/project/cxml/")
4829     (license license:llgpl))))
4830
4831 (define-public cl-cxml
4832   (sbcl-package->cl-source-package sbcl-cxml))
4833
4834 (define-public ecl-cxml
4835   (sbcl-package->ecl-package sbcl-cxml))
4836
4837 (define-public sbcl-cl-reexport
4838   (let ((commit "312f3661bbe187b5f28536cd7ec2956e91366c3b")
4839         (revision "1"))
4840     (package
4841       (name "sbcl-cl-reexport")
4842       (build-system asdf-build-system/sbcl)
4843       (version (git-version "0.1" revision commit))
4844       (home-page "https://github.com/takagi/cl-reexport")
4845       (source
4846        (origin
4847          (method git-fetch)
4848          (uri (git-reference
4849                (url home-page)
4850                (commit commit)))
4851          (file-name (git-file-name name version))
4852          (sha256
4853           (base32
4854            "1cwpn1m3wrl0fl9plznn7p464db646gnfc8zkyk97dyxski2aq0x"))))
4855       (inputs
4856        `(("alexandria" ,sbcl-alexandria)))
4857       (arguments
4858        ;; TODO: Tests fail because cl-test-more is missing, but I can't find it online.
4859        `(#:tests? #f))
4860       (synopsis "HTTP cookie manager for Common Lisp")
4861       (description "cl-cookie is a Common Lisp library featuring parsing of
4862 cookie headers, cookie creation, cookie jar creation and more.")
4863       (license license:llgpl))))
4864
4865 (define-public cl-reexport
4866   (sbcl-package->cl-source-package sbcl-cl-reexport))
4867
4868 (define-public ecl-cl-reexport
4869   (sbcl-package->ecl-package sbcl-cl-reexport))
4870
4871 (define-public sbcl-cl-cookie
4872   (let ((commit "cea55aed8b9ad25fafd13defbcb9fe8f41b29546")
4873         (revision "1"))
4874     (package
4875       (name "sbcl-cl-cookie")
4876       (build-system asdf-build-system/sbcl)
4877       (version (git-version "0.9.10" revision commit))
4878       (home-page "https://github.com/fukamachi/cl-cookie")
4879       (source
4880        (origin
4881          (method git-fetch)
4882          (uri (git-reference
4883                (url home-page)
4884                (commit commit)))
4885          (file-name (git-file-name name version))
4886          (sha256
4887           (base32
4888            "090g7z75h98zvc1ldx0vh4jn4086dhjm2w30jcwkq553qmyxwl8h"))))
4889       (inputs
4890        `(("proc-parse" ,sbcl-proc-parse)
4891          ("alexandria" ,sbcl-alexandria)
4892          ("quri" ,sbcl-quri)
4893          ("cl-ppcre" ,sbcl-cl-ppcre)
4894          ("local-time" ,sbcl-local-time)))
4895       (native-inputs
4896        `(("prove" ,sbcl-prove)))
4897       (arguments
4898        ;; TODO: Tests fail because cl-cookie depends on cl-cookie-test.
4899        `(#:tests? #f))
4900       (synopsis "HTTP cookie manager for Common Lisp")
4901       (description "cl-cookie is a Common Lisp library featuring parsing of
4902 cookie headers, cookie creation, cookie jar creation and more.")
4903       (license license:bsd-2))))
4904
4905 (define-public cl-cookie
4906   (sbcl-package->cl-source-package sbcl-cl-cookie))
4907
4908 (define-public ecl-cl-cookie
4909   (sbcl-package->ecl-package sbcl-cl-cookie))
4910
4911 (define-public sbcl-dexador
4912   (let ((commit "953090f04c4d1a9ee6632b90133cdc297b68badc")
4913         (revision "1"))
4914     (package
4915       (name "sbcl-dexador")
4916       (build-system asdf-build-system/sbcl)
4917       (version "0.9.14" )
4918       (home-page "https://github.com/fukamachi/dexador")
4919       (source
4920        (origin
4921          (method git-fetch)
4922          (uri (git-reference
4923                (url home-page)
4924                (commit commit)))
4925          (file-name (git-file-name name version))
4926          (sha256
4927           (base32
4928            "0w18fz3301rpmwc3kwb810czcd24mbf7r1z8vdyc0v5crjfpw3mn"))))
4929       (inputs
4930        `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)
4931          ("babel" ,sbcl-babel)
4932          ("usocket" ,sbcl-usocket)
4933          ("fast-http" ,sbcl-fast-http)
4934          ("quri" ,sbcl-quri)
4935          ("fast-io" ,sbcl-fast-io)
4936          ("chunga" ,sbcl-chunga)
4937          ("cl-ppcre" ,sbcl-cl-ppcre)
4938          ("cl-cookie" ,sbcl-cl-cookie)
4939          ("trivial-mimes" ,sbcl-trivial-mimes)
4940          ("chipz" ,sbcl-chipz)
4941          ("cl-base64" ,sbcl-cl-base64)
4942          ("cl-reexport" ,sbcl-cl-reexport)
4943          ("cl+ssl" ,sbcl-cl+ssl)
4944          ("bordeaux-threads" ,sbcl-bordeaux-threads)
4945          ("alexandria" ,sbcl-alexandria)))
4946       (native-inputs
4947        `(("prove" ,sbcl-prove)
4948          ("lack" ,sbcl-lack)
4949          ("clack" ,sbcl-clack)
4950          ("babel" ,sbcl-babel)
4951          ("alexandria" ,sbcl-alexandria)
4952          ("cl-ppcre" ,sbcl-cl-ppcre)
4953          ("local-time" ,sbcl-local-time)
4954          ("trivial-features" ,sbcl-trivial-features)))
4955       (arguments
4956        ;; TODO: Circular dependency: tests depend on clack-test which depends on dexador.
4957        `(#:tests? #f
4958          #:phases
4959          (modify-phases %standard-phases
4960            (add-after 'unpack 'fix-permissions
4961              (lambda _ (make-file-writable "t/data/test.gz") #t)))))
4962       (synopsis "Yet another HTTP client for Common Lisp")
4963       (description "Dexador is yet another HTTP client for Common Lisp with
4964 neat APIs and connection-pooling.  It is meant to supersede Drakma.")
4965       (license license:expat))))
4966
4967 (define-public cl-dexador
4968   (package
4969     (inherit (sbcl-package->cl-source-package sbcl-dexador))
4970     (arguments
4971      `(#:phases
4972        ;; asdf-build-system/source has its own phases and does not inherit
4973        ;; from asdf-build-system/sbcl phases.
4974        (modify-phases %standard-phases/source
4975          ;; Already done in SBCL package.
4976          (delete 'reset-gzip-timestamps))))))
4977
4978 (define-public ecl-dexador
4979   (sbcl-package->ecl-package sbcl-dexador))
4980
4981 (define-public sbcl-lisp-namespace
4982   (let ((commit "28107cafe34e4c1c67490fde60c7f92dc610b2e0")
4983         (revision "1"))
4984     (package
4985       (name "sbcl-lisp-namespace")
4986       (build-system asdf-build-system/sbcl)
4987       (version (git-version "0.1" revision commit))
4988       (home-page "https://github.com/guicho271828/lisp-namespace")
4989       (source
4990        (origin
4991          (method git-fetch)
4992          (uri (git-reference
4993                (url home-page)
4994                (commit commit)))
4995          (file-name (git-file-name name version))
4996          (sha256
4997           (base32
4998            "1jw2wykp06z2afb9nm1lgfzll5cjlj36pnknjx614057zkkxq4iy"))))
4999       (inputs
5000        `(("alexandria" ,sbcl-alexandria)))
5001       (native-inputs
5002        `(("fiveam" ,sbcl-fiveam)))
5003       (arguments
5004        `(#:test-asd-file "lisp-namespace.test.asd"
5005         ;; XXX: Component LISP-NAMESPACE-ASD::LISP-NAMESPACE.TEST not found
5006          #:tests? #f))
5007       (synopsis "LISP-N, or extensible namespaces in Common Lisp")
5008       (description "Common Lisp already has major 2 namespaces, function
5009 namespace and value namespace (or variable namespace), but there are actually
5010 more — e.g., class namespace.
5011 This library offers macros to deal with symbols from any namespace.")
5012       (license license:llgpl))))
5013
5014 (define-public cl-lisp-namespace
5015   (sbcl-package->cl-source-package sbcl-lisp-namespace))
5016
5017 (define-public ecl-lisp-namespace
5018   (sbcl-package->ecl-package sbcl-lisp-namespace))
5019
5020 (define-public sbcl-trivial-cltl2
5021   (let ((commit "8a3bda30dc25d2f65fcf514d0eb6e6db75252c61")
5022         (revision "2"))
5023     (package
5024       (name "sbcl-trivial-cltl2")
5025       (build-system asdf-build-system/sbcl)
5026       (version (git-version "0.1.1" revision commit))
5027       (home-page "https://github.com/Zulu-Inuoe/trivial-cltl2")
5028       (source
5029        (origin
5030          (method git-fetch)
5031          (uri (git-reference
5032                (url home-page)
5033                (commit commit)))
5034          (file-name (git-file-name name version))
5035          (sha256
5036           (base32
5037            "08cnzb9rnczn4pn2zpf0587ny4wjy1mjndy885fz9pw7xrlx37ip"))))
5038       (synopsis "Simple CLtL2 compatibility layer for Common Lisp")
5039       (description "This library is a portable compatibility layer around
5040 \"Common Lisp the Language, 2nd
5041 Edition\" (@url{https://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node102.html})
5042 and it exports symbols from implementation-specific packages.")
5043       (license license:llgpl))))
5044
5045 (define-public cl-trivial-cltl2
5046   (sbcl-package->cl-source-package sbcl-trivial-cltl2))
5047
5048 (define-public ecl-trivial-cltl2
5049   (sbcl-package->ecl-package sbcl-trivial-cltl2))
5050
5051 (define-public sbcl-introspect-environment
5052   (let ((commit "fff42f8f8fd0d99db5ad6c5812e53de7d660020b")
5053         (revision "1"))
5054     (package
5055       (name "sbcl-introspect-environment")
5056       (build-system asdf-build-system/sbcl)
5057       (version (git-version "0.1" revision commit))
5058       (home-page "https://github.com/Bike/introspect-environment")
5059       (source
5060        (origin
5061          (method git-fetch)
5062          (uri (git-reference
5063                (url home-page)
5064                (commit commit)))
5065          (file-name (git-file-name name version))
5066          (sha256
5067           (base32
5068            "1i305n0wfmpac63ni4i3vixnnkl8daw5ncxy0k3dv92krgx6qzhp"))))
5069       (native-inputs
5070        `(("fiveam" ,sbcl-fiveam)))
5071       (synopsis "Common Lisp environment introspection portability layer")
5072       (description "This library is a small interface to portable but
5073 nonstandard introspection of Common Lisp environments.  It is intended to
5074 allow a bit more compile-time introspection of environments in Common Lisp.
5075
5076 Quite a bit of information is available at the time a macro or compiler-macro
5077 runs; inlining info, type declarations, that sort of thing.  This information
5078 is all standard - any Common Lisp program can @code{(declare (integer x))} and
5079 such.
5080
5081 This info ought to be accessible through the standard @code{&environment}
5082 parameters, but it is not.  Several implementations keep the information for
5083 their own purposes but do not make it available to user programs, because
5084 there is no standard mechanism to do so.
5085
5086 This library uses implementation-specific hooks to make information available
5087 to users.  This is currently supported on SBCL, CCL, and CMUCL.  Other
5088 implementations have implementations of the functions that do as much as they
5089 can and/or provide reasonable defaults.")
5090       (license license:wtfpl2))))
5091
5092 (define-public cl-introspect-environment
5093   (sbcl-package->cl-source-package sbcl-introspect-environment))
5094
5095 (define-public ecl-introspect-environment
5096   (sbcl-package->ecl-package sbcl-introspect-environment))
5097
5098 (define-public sbcl-type-i
5099   (let ((commit "d34440ab4ebf5a46a58deccb35950b15670e3667")
5100         (revision "2"))
5101     (package
5102       (name "sbcl-type-i")
5103       (build-system asdf-build-system/sbcl)
5104       (version (git-version "0.1" revision commit))
5105       (home-page "https://github.com/guicho271828/type-i")
5106       (source
5107        (origin
5108          (method git-fetch)
5109          (uri (git-reference
5110                (url home-page)
5111                (commit commit)))
5112          (file-name (git-file-name name version))
5113          (sha256
5114           (base32
5115            "12wsga0pwjkkr176lnjwkmmlm3ccp0n310sjj9h20lk53iyd0z69"))))
5116       (inputs
5117        `(("alexandria" ,sbcl-alexandria)
5118          ("introspect-environment" ,sbcl-introspect-environment)
5119          ("trivia.trivial" ,sbcl-trivia.trivial)))
5120       (native-inputs
5121        `(("fiveam" ,sbcl-fiveam)))
5122       (arguments
5123        `(#:test-asd-file "type-i.test.asd"))
5124       (synopsis "Type inference utility on unary predicates for Common Lisp")
5125       (description "This library tries to provide a way to detect what kind of
5126 type the given predicate is trying to check.  This is different from inferring
5127 the return type of a function.")
5128       (license license:llgpl))))
5129
5130 (define-public cl-type-i
5131   (sbcl-package->cl-source-package sbcl-type-i))
5132
5133 (define-public ecl-type-i
5134   (package
5135     (inherit (sbcl-package->ecl-package sbcl-type-i))
5136     (arguments
5137      ;; The tests get stuck indefinitly
5138      '(#:tests? #f))))
5139
5140 (define-public sbcl-optima
5141   (let ((commit "373b245b928c1a5cce91a6cb5bfe5dd77eb36195")
5142         (revision "1"))
5143     (package
5144       (name "sbcl-optima")
5145       (build-system asdf-build-system/sbcl)
5146       (version (git-version "1.0" revision commit))
5147       (home-page "https://github.com/m2ym/optima")
5148       (source
5149        (origin
5150          (method git-fetch)
5151          (uri (git-reference
5152                (url home-page)
5153                (commit commit)))
5154          (file-name (git-file-name name version))
5155          (sha256
5156           (base32
5157            "1yw4ymq7ms89342kkvb3aqxgv0w38m9kd8ikdqxxzyybnkjhndal"))))
5158       (inputs
5159        `(("alexandria" ,sbcl-alexandria)
5160          ("closer-mop" ,sbcl-closer-mop)))
5161       (native-inputs
5162        `(("eos" ,sbcl-eos)))
5163       (arguments
5164        ;; XXX: Circular dependencies: tests depend on optima.ppcre which depends on optima.
5165        `(#:tests? #f
5166          #:test-asd-file "optima.test.asd"))
5167       (synopsis "Optimized pattern matching library for Common Lisp")
5168       (description "Optima is a fast pattern matching library which uses
5169 optimizing techniques widely used in the functional programming world.")
5170       (license license:expat))))
5171
5172 (define-public cl-optima
5173   (sbcl-package->cl-source-package sbcl-optima))
5174
5175 (define-public ecl-optima
5176   (sbcl-package->ecl-package sbcl-optima))
5177
5178 (define-public sbcl-fare-quasiquote
5179   (let ((commit "640d39a0451094071b3e093c97667b3947f43639")
5180         (revision "1"))
5181     (package
5182       (name "sbcl-fare-quasiquote")
5183       (build-system asdf-build-system/sbcl)
5184       (version (git-version "1.0.1" revision commit))
5185       (home-page "https://gitlab.common-lisp.net/frideau/fare-quasiquote")
5186       (source
5187        (origin
5188          (method git-fetch)
5189          (uri (git-reference
5190                (url (string-append "https://gitlab.common-lisp.net/frideau/"
5191                                    "fare-quasiquote.git"))
5192                (commit commit)))
5193          (file-name (git-file-name name version))
5194          (sha256
5195           (base32 "1g6q11l50kgija9f55lzqpcwvaq0ljiw8v1j265hnyg6nahjwjvg"))))
5196       (inputs
5197        `(("fare-utils" ,sbcl-fare-utils)
5198          ("named-readtables" ,sbcl-named-readtables)
5199          ("optima" ,sbcl-optima)))
5200       (arguments
5201        ;; XXX: Circular dependencies: Tests depend on subsystems,
5202        ;; which depend on the main systems.
5203        `(#:tests? #f
5204          #:asd-systems '("fare-quasiquote"
5205                          "fare-quasiquote-extras")
5206          #:phases
5207          (modify-phases %standard-phases
5208            ;; XXX: Require 1.0.0 version of fare-utils, and we package some
5209            ;; commits after 1.0.0.5, but ASDF fails to read the
5210            ;; "-REVISION-COMMIT" part generated by Guix.
5211            (add-after 'unpack 'patch-requirement
5212              (lambda _
5213                (substitute* "fare-quasiquote.asd"
5214                  (("\\(:version \"fare-utils\" \"1.0.0\"\\)")
5215                   "\"fare-utils\""))
5216                (substitute* "fare-quasiquote-optima.asd"
5217                  (("\\(:version \"optima\" \"1\\.0\"\\)")
5218                   "\"optima\""))
5219                #t)))))
5220       (synopsis "Pattern-matching friendly implementation of quasiquote")
5221       (description "The main purpose of this n+2nd reimplementation of
5222 quasiquote is enable matching of quasiquoted patterns, using Optima or
5223 Trivia.")
5224       (license license:expat))))
5225
5226 (define-public cl-fare-quasiquote
5227   (sbcl-package->cl-source-package sbcl-fare-quasiquote))
5228
5229 (define-public ecl-fare-quasiquote
5230   (sbcl-package->ecl-package sbcl-fare-quasiquote))
5231
5232 ;;; Split the trivia package in two to work around the circular dependency
5233 ;;; between guicho271828/trivia and guicho271828/type-i.
5234 (define-public sbcl-trivia.trivial
5235   (let ((commit "37698b47a14c2007630468de7a993694ef7bd475")
5236         (revision "2"))
5237     (package
5238       (name "sbcl-trivia.trivial")
5239       (version (git-version "0.0.0" revision commit))
5240       (source
5241        (origin
5242          (method git-fetch)
5243          (uri (git-reference
5244                (url "https://github.com/guicho271828/trivia")
5245                (commit commit)))
5246          (file-name (git-file-name "trivia" version))
5247          (sha256
5248           (base32
5249            "0rsbwbw3ipxxgr6zzhci12nilq8zky475kmhz1rcxy4q8a85vn72"))))
5250       (build-system asdf-build-system/sbcl)
5251       (inputs
5252        `(("alexandria" ,sbcl-alexandria)
5253          ("closer-mop" ,sbcl-closer-mop)
5254          ("lisp-namespace" ,sbcl-lisp-namespace)
5255          ("trivial-cltl2" ,sbcl-trivial-cltl2)))
5256       (arguments
5257        '(#:phases
5258          (modify-phases %standard-phases
5259            (add-after 'unpack 'fix-build
5260              (lambda _
5261                (for-each delete-file
5262                          '("trivia.balland2006.asd"
5263                            "trivia.ppcre.asd"
5264                            "trivia.quasiquote.asd"
5265                            "trivia.cffi.asd"
5266                            "trivia.asd"
5267                            "trivia.test.asd"))
5268                #t)))))
5269       (synopsis "Pattern matching in Common Lisp")
5270       (description "Trivia is a pattern matching compiler that is compatible
5271 with Optima, another pattern matching library for Common Lisp.  It is meant to
5272 be faster and more extensible than Optima.")
5273       (home-page "https://github.com/guicho271828/trivia")
5274       (license license:llgpl))))
5275
5276 (define-public cl-trivia.trivial
5277   (sbcl-package->cl-source-package sbcl-trivia.trivial))
5278
5279 (define-public ecl-trivia.trivial
5280   (sbcl-package->ecl-package sbcl-trivia.trivial))
5281
5282 (define-public sbcl-trivia
5283   (package
5284     (inherit sbcl-trivia.trivial)
5285     (name "sbcl-trivia")
5286     (native-inputs
5287      `(("fiveam" ,sbcl-fiveam)
5288        ("optima" ,sbcl-optima)))
5289     (inputs
5290      `(("alexandria" ,sbcl-alexandria)
5291        ("cffi" ,sbcl-cffi)
5292        ("cl-ppcre" ,sbcl-cl-ppcre)
5293        ("fare-quasiquote" ,sbcl-fare-quasiquote)
5294        ("iterate" ,sbcl-iterate)
5295        ("trivia.trivial" ,sbcl-trivia.trivial)
5296        ("type-i" ,sbcl-type-i)))
5297     (arguments
5298      '(#:asd-systems '("trivia"
5299                        "trivia.ppcre"
5300                        "trivia.quasiquote"
5301                        "trivia.cffi")
5302        #:test-asd-file "trivia.test.asd"
5303        #:phases
5304        (modify-phases %standard-phases
5305          (add-after 'unpack 'fix-build
5306            (lambda _
5307              (for-each delete-file
5308                        '("trivia.level0.asd"
5309                          "trivia.level1.asd"
5310                          "trivia.level2.asd"
5311                          "trivia.trivial.asd"))
5312              #t)))))))
5313
5314 (define-public cl-trivia
5315   (sbcl-package->cl-source-package sbcl-trivia))
5316
5317 (define-public ecl-trivia
5318   (sbcl-package->ecl-package sbcl-trivia))
5319
5320 (define-public sbcl-mk-string-metrics
5321   (package
5322     (name "sbcl-mk-string-metrics")
5323     (version "0.1.2")
5324     (home-page "https://github.com/cbaggers/mk-string-metrics/")
5325     (source (origin
5326               (method git-fetch)
5327               (uri (git-reference
5328                     (url home-page)
5329                     (commit version)))
5330               (sha256
5331                (base32 "0bg0bv2mfd4k0g3x72x563hvmrx18xavaffr6xk5rh4if5j7kcf6"))
5332               (file-name (git-file-name name version))))
5333     (build-system asdf-build-system/sbcl)
5334     (synopsis "Calculate various string metrics efficiently in Common Lisp")
5335     (description "This library implements efficient algorithms that calculate
5336 various string metrics in Common Lisp:
5337
5338 @itemize
5339 @item Damerau-Levenshtein distance
5340 @item Hamming distance
5341 @item Jaccard similarity coefficient
5342 @item Jaro distance
5343 @item Jaro-Winkler distance
5344 @item Levenshtein distance
5345 @item Normalized Damerau-Levenshtein distance
5346 @item Normalized Levenshtein distance
5347 @item Overlap coefficient
5348 @end itemize\n")
5349     (license license:x11)))
5350
5351 (define-public cl-mk-string-metrics
5352   (sbcl-package->cl-source-package sbcl-mk-string-metrics))
5353
5354 (define-public ecl-mk-string-metrics
5355   (sbcl-package->ecl-package sbcl-mk-string-metrics))
5356
5357 (define-public sbcl-cl-str
5358   (let ((commit "eb480f283e28802d67b35bf916506701152f9a2a"))
5359     (package
5360       (name "sbcl-cl-str")
5361       (version (git-version "0.17" "1" commit))
5362       (home-page "https://github.com/vindarel/cl-str")
5363       (source (origin
5364                 (method git-fetch)
5365                 (uri (git-reference
5366                       (url home-page)
5367                       (commit commit)))
5368                 (sha256
5369                  (base32 "1hpq5m8zjjnzns370zy27z2vcm1p8n2ka5ij2x67gyc9amz9vla0"))
5370                 (file-name (git-file-name name version))))
5371       (build-system asdf-build-system/sbcl)
5372       (inputs
5373        `(("cl-ppcre" ,sbcl-cl-ppcre)
5374          ("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)
5375          ("cl-change-case" ,sbcl-cl-change-case)))
5376       (native-inputs
5377        `(("prove" ,sbcl-prove)))
5378       (arguments
5379        `(#:asd-systems '("str")
5380          #:test-asd-file "str.test.asd"))
5381       (synopsis "Modern, consistent and terse Common Lisp string manipulation library")
5382       (description "A modern and consistent Common Lisp string manipulation
5383 library that focuses on modernity, simplicity and discoverability:
5384 @code{(str:trim s)} instead of @code{(string-trim '(#\\Space ...) s)}), or
5385 @code{str:concat strings} instead of an unusual format construct; one
5386 discoverable library instead of many; consistency and composability, where
5387 @code{s} is always the last argument, which makes it easier to feed pipes and
5388 arrows.")
5389       (license license:expat))))
5390
5391 (define-public cl-str
5392   (sbcl-package->cl-source-package sbcl-cl-str))
5393
5394 (define-public ecl-cl-str
5395   (sbcl-package->ecl-package sbcl-cl-str))
5396
5397 (define-public sbcl-cl-xmlspam
5398   (let ((commit "ea06abcca2a73a9779bcfb09081e56665f94e22a"))
5399     (package
5400       (name "sbcl-cl-xmlspam")
5401       (build-system asdf-build-system/sbcl)
5402       (version (git-version "0.0.0" "1" commit))
5403       (home-page "https://github.com/rogpeppe/cl-xmlspam")
5404       (source
5405        (origin
5406          (method git-fetch)
5407          (uri (git-reference
5408                (url home-page)
5409                (commit commit)))
5410          (file-name (string-append name "-" version))
5411          (sha256
5412           (base32
5413            "0w4rqvrgdgk3fwfq3kx4r7wwdr2bv3b6n3bdqwsiriw9psqzpz2s"))))
5414       (inputs
5415        `(("cxml" ,sbcl-cxml)
5416          ("cl-ppcre" ,sbcl-cl-ppcre)))
5417       (synopsis "Concise, regexp-like pattern matching on streaming XML for Common Lisp")
5418       (description "CXML does an excellent job at parsing XML elements, but what
5419 do you do when you have a XML file that's larger than you want to fit in
5420 memory, and you want to extract some information from it?  Writing code to deal
5421 with SAX events, or even using Klacks, quickly becomes tedious.
5422 @code{cl-xmlspam} (for XML Stream PAttern Matcher) is designed to make it easy
5423 to write code that mirrors the structure of the XML that it's parsing.  It
5424 also makes it easy to shift paradigms when necessary - the usual Lisp control
5425 constructs can be used interchangeably with pattern matching, and the full
5426 power of CXML is available when necessary.")
5427       (license license:bsd-3))))
5428
5429 (define-public cl-xmlspam
5430   (sbcl-package->cl-source-package sbcl-cl-xmlspam))
5431
5432 (define-public ecl-cl-xmlspam
5433   (sbcl-package->ecl-package sbcl-cl-xmlspam))
5434
5435 (define-public sbcl-dbus
5436   (let ((commit "24b452df3a45ca5dc95015500f34baad175c981a")
5437         (revision "1"))
5438     (package
5439       (name "sbcl-dbus")
5440       (version (git-version "20190408" revision commit))
5441       (home-page "https://github.com/death/dbus")
5442       (source
5443        (origin
5444          (method git-fetch)
5445          (uri (git-reference
5446                (url home-page)
5447                (commit commit)))
5448          (file-name (git-file-name name version))
5449          (sha256
5450           (base32
5451            "0fw2q866yddbf23nk9pxphm9gsasx35vjyss82xzvndnjmzlqfl5"))))
5452       (build-system asdf-build-system/sbcl)
5453       (inputs
5454        `(("alexandria" ,sbcl-alexandria)
5455          ("trivial-garbage" ,sbcl-trivial-garbage)
5456          ("babel" ,sbcl-babel)
5457          ("iolib" ,sbcl-iolib)
5458          ("ieee-floats" ,sbcl-ieee-floats)
5459          ("flexi-streams" ,sbcl-flexi-streams)
5460          ("cl-xmlspam" ,sbcl-cl-xmlspam)
5461          ("ironclad" ,sbcl-ironclad)))
5462       (synopsis "D-Bus client library for Common Lisp")
5463       (description "This is a Common Lisp library that publishes D-Bus
5464 objects as well as send and notify other objects connected to a bus.")
5465       (license license:bsd-2))))
5466
5467 (define-public cl-dbus
5468   (sbcl-package->cl-source-package sbcl-dbus))
5469
5470 (define-public ecl-dbus
5471   (sbcl-package->ecl-package sbcl-dbus))
5472
5473 (define-public sbcl-cl-hooks
5474   (let ((commit "5b638083f3b4f1221a52631d9c8a0a265565cac7")
5475         (revision "1"))
5476     (package
5477       (name "sbcl-cl-hooks")
5478       (build-system asdf-build-system/sbcl)
5479       (version (git-version "0.2.1" revision commit))
5480       (home-page "https://github.com/scymtym/architecture.hooks")
5481       (source
5482        (origin
5483          (method git-fetch)
5484          (uri (git-reference
5485                (url home-page)
5486                (commit commit)))
5487          (file-name (git-file-name name version))
5488          (sha256
5489           (base32
5490            "0bg3l0a28lw5gqqjp6p6b5nhwqk46sgkb7184w5qbfngw1hk8x9y"))))
5491       (inputs
5492        `(("alexandria" ,sbcl-alexandria)
5493          ("let-plus" ,sbcl-let-plus)
5494          ("trivial-garbage" ,sbcl-trivial-garbage)
5495          ("closer-mop" ,sbcl-closer-mop)))
5496       (native-inputs
5497        `(("fiveam" ,sbcl-fiveam)))
5498       (synopsis "Hooks extension point mechanism (as in Emacs) for Common Lisp")
5499       (description "A hook, in the present context, is a certain kind of
5500 extension point in a program that allows interleaving the execution of
5501 arbitrary code with the execution of a the program without introducing any
5502 coupling between the two.  Hooks are used extensively in the extensible editor
5503 Emacs.
5504
5505 In the Common LISP Object System (CLOS), a similar kind of extensibility is
5506 possible using the flexible multi-method dispatch mechanism.  It may even seem
5507 that the concept of hooks does not provide any benefits over the possibilities
5508 of CLOS.  However, there are some differences:
5509
5510 @itemize
5511
5512 @item There can be only one method for each combination of specializers and
5513 qualifiers.  As a result this kind of extension point cannot be used by
5514 multiple extensions independently.
5515 @item Removing code previously attached via a @code{:before}, @code{:after} or
5516 @code{:around} method can be cumbersome.
5517 @item There could be other or even multiple extension points besides @code{:before}
5518 and @code{:after} in a single method.
5519 @item Attaching codes to individual objects using eql specializers can be
5520 cumbersome.
5521 @item Introspection of code attached a particular extension point is
5522 cumbersome since this requires enumerating and inspecting the methods of a
5523 generic function.
5524 @end itemize
5525
5526 This library tries to complement some of these weaknesses of method-based
5527 extension-points via the concept of hooks.")
5528       (license license:llgpl))))
5529
5530 (define-public cl-hooks
5531   (sbcl-package->cl-source-package sbcl-cl-hooks))
5532
5533 (define-public ecl-cl-hooks
5534   (sbcl-package->ecl-package sbcl-cl-hooks))
5535
5536 (define-public sbcl-s-sysdeps
5537   ;; No release since 2013.
5538   (let ((commit "9aa23bbdceb24bcdbe0e7c39fa1901858f823106")
5539         (revision "2"))
5540     (package
5541       (name "sbcl-s-sysdeps")
5542       (build-system asdf-build-system/sbcl)
5543       (version (git-version "1" revision commit))
5544       (home-page "https://github.com/svenvc/s-sysdeps")
5545       (source
5546        (origin
5547          (method git-fetch)
5548          (uri (git-reference
5549                (url home-page)
5550                (commit commit)))
5551          (file-name (git-file-name name version))
5552          (sha256
5553           (base32
5554            "1fh8r7kf8s3hvqdg6b71b8p7w3v2kkga9bw8j3qqdxhzr6anpm0b"))))
5555       (inputs
5556        `(("bordeaux-threads" ,sbcl-bordeaux-threads)
5557          ("usocket" ,sbcl-usocket)))
5558       (synopsis "Common Lisp abstraction layer over platform dependent functionality")
5559       (description "@code{s-sysdeps} is an abstraction layer over platform
5560 dependent functionality.  This simple package is used as a building block in a
5561 number of other open source projects.
5562
5563 @code{s-sysdeps} abstracts:
5564
5565 @itemize
5566 @item managing processes,
5567 @item implementing a standard TCP/IP server,
5568 @item opening a client TCP/IP socket stream,
5569 @item working with process locks.
5570 @end itemize\n")
5571       (license license:llgpl))))
5572
5573 (define-public cl-s-sysdeps
5574   (sbcl-package->cl-source-package sbcl-s-sysdeps))
5575
5576 (define-public ecl-s-sysdeps
5577   (sbcl-package->ecl-package sbcl-s-sysdeps))
5578
5579 (define-public sbcl-cl-prevalence
5580   (let ((commit "1e5f030d94237b33d20947a2f6c194abedb10727")
5581         (revision "3"))
5582     (package
5583       (name "sbcl-cl-prevalence")
5584       (build-system asdf-build-system/sbcl)
5585       (version (git-version "5" revision commit))
5586       (home-page "https://github.com/40ants/cl-prevalence")
5587       (source
5588        (origin
5589          (method git-fetch)
5590          (uri (git-reference
5591                (url home-page)
5592                (commit commit)))
5593          (file-name (git-file-name name version))
5594          (sha256
5595           (base32
5596            "13yb8lv2aap5wvqa6hw7ms31xnax58f4m2nxifkssrzkb2w2qf29"))))
5597       (inputs
5598        `(("s-sysdeps" ,sbcl-s-sysdeps)
5599          ("s-xml" ,sbcl-s-xml)))
5600       (native-inputs
5601        `(("fiveam" ,sbcl-fiveam)))
5602       (synopsis "Implementation of object prevalence for Common Lisp")
5603       (description "This Common Lisp library implements object prevalence (see
5604 @url{https://en.wikipedia.org/wiki/System_prevalence}).  It allows
5605 for (de)serializing to and from s-exps as well as XML.  Serialization of arbitrary
5606 classes and cyclic data structures are supported.")
5607       (license license:llgpl))))
5608
5609 (define-public cl-prevalence
5610   (sbcl-package->cl-source-package sbcl-cl-prevalence))
5611
5612 (define-public ecl-cl-prevalence
5613   (sbcl-package->ecl-package sbcl-cl-prevalence))
5614
5615 (define-public sbcl-series
5616   (let ((commit "da9061b336119d1e5214aff9117171d494d5a58a")
5617         (revision "1"))
5618     (package
5619       (name "sbcl-series")
5620       (version (git-version "2.2.11" revision commit))
5621       (source
5622        (origin
5623          (method git-fetch)
5624          (uri (git-reference
5625                (url "git://git.code.sf.net/p/series/series")
5626                (commit commit)))
5627          (file-name (git-file-name name version))
5628          (sha256
5629           (base32
5630            "07hk2lhfx42zk018pxqvn4gs77vd4n4g8m4xxbqaxgca76mifwfw"))))
5631       (build-system asdf-build-system/sbcl)
5632       (arguments
5633        ;; Disable the tests, they are apparently buggy and I didn't find
5634        ;; a simple way to make them run and pass.
5635        '(#:tests? #f))
5636       (synopsis "Series data structure for Common Lisp")
5637       (description
5638        "This Common Lisp library provides a series data structure much like
5639 a sequence, with similar kinds of operations.  The difference is that in many
5640 situations, operations on series may be composed functionally and yet execute
5641 iteratively, without the need to construct intermediate series values
5642 explicitly.  In this manner, series provide both the clarity of a functional
5643 programming style and the efficiency of an iterative programming style.")
5644       (home-page "http://series.sourceforge.net/")
5645       (license license:expat))))
5646
5647 (define-public cl-series
5648   (sbcl-package->cl-source-package sbcl-series))
5649
5650 (define-public ecl-series
5651   (sbcl-package->ecl-package sbcl-series))
5652
5653 (define-public sbcl-periods
5654   (let ((commit "983d4a57325db3c8def942f163133cec5391ec28")
5655         (revision "1"))
5656     (package
5657       (name "sbcl-periods")
5658       (version (git-version "0.0.2" revision commit))
5659       (source
5660        (origin
5661          (method git-fetch)
5662          (uri (git-reference
5663                (url "https://github.com/jwiegley/periods")
5664                (commit commit)))
5665          (file-name (git-file-name name version))
5666          (sha256
5667           (base32
5668            "0z30jr3lxz3cmi019fsl4lgcgwf0yqpn95v9zkkkwgymdrkd4lga"))))
5669       (build-system asdf-build-system/sbcl)
5670       (inputs
5671        `(("local-time" ,sbcl-local-time)
5672          ("series" ,sbcl-series)))
5673       (arguments
5674        '(#:asd-systems '("periods"
5675                          "periods-series")))
5676       (synopsis "Common Lisp library for manipulating date/time objects")
5677       (description
5678        "Periods is a Common Lisp library providing a set of utilities for
5679 manipulating times, distances between times, and both contiguous and
5680 discontiguous ranges of time.")
5681       (home-page "https://github.com/jwiegley/periods")
5682       (license license:bsd-3))))
5683
5684 (define-public cl-periods
5685   (sbcl-package->cl-source-package sbcl-periods))
5686
5687 (define-public ecl-periods
5688   (sbcl-package->ecl-package sbcl-periods))
5689
5690 (define-public sbcl-metatilities-base
5691   (let ((commit "6eaa9e3ff0939a93a92109dd0fcd218de85417d5")
5692         (revision "1"))
5693     (package
5694       (name "sbcl-metatilities-base")
5695       (version (git-version "0.6.6" revision commit))
5696       (source
5697        (origin
5698          (method git-fetch)
5699          (uri (git-reference
5700                (url "https://github.com/gwkkwg/metatilities-base")
5701                (commit commit)))
5702          (file-name (git-file-name name version))
5703          (sha256
5704           (base32
5705            "0xpa86pdzlnf4v5g64j3ifaplx71sx2ha8b7vvakswi652679ma0"))))
5706       (build-system asdf-build-system/sbcl)
5707       (native-inputs
5708        `(("lift" ,sbcl-lift)))
5709       (synopsis "Core of the metatilities Common Lisp library")
5710       (description
5711        "Metatilities-base is the core of the metatilities Common Lisp library
5712 which implements a set of utilities.")
5713       (home-page "https://common-lisp.net/project/metatilities-base/")
5714       (license license:expat))))
5715
5716 (define-public cl-metatilities-base
5717   (sbcl-package->cl-source-package sbcl-metatilities-base))
5718
5719 (define-public ecl-metatilities-base
5720   (sbcl-package->ecl-package sbcl-metatilities-base))
5721
5722 (define-public sbcl-cl-containers
5723   (let ((commit "3d1df53c22403121bffb5d553cf7acb1503850e7")
5724         (revision "3"))
5725     (package
5726       (name "sbcl-cl-containers")
5727       (version (git-version "0.12.1" revision commit))
5728       (source
5729        (origin
5730          (method git-fetch)
5731          (uri (git-reference
5732                (url "https://github.com/gwkkwg/cl-containers")
5733                (commit commit)))
5734          (file-name (git-file-name name version))
5735          (sha256
5736           (base32
5737            "18s6jfq11n8nv9k4biz32pm1s7y9zl054ry1gmdbcf39nisy377y"))))
5738       (build-system asdf-build-system/sbcl)
5739       (native-inputs
5740        `(("lift" ,sbcl-lift)))
5741       (inputs
5742        `(("metatilities-base" ,sbcl-metatilities-base)))
5743       (arguments
5744        '(#:asd-files '("cl-containers.asd")
5745          #:phases
5746          (modify-phases %standard-phases
5747            (add-after 'unpack 'relax-version-checks
5748              (lambda _
5749                (substitute* "cl-containers.asd"
5750                  (("\\(:version \"metatilities-base\" \"0\\.6\\.6\"\\)")
5751                   "\"metatilities-base\""))
5752                (substitute* "cl-containers-test.asd"
5753                  (("\\(:version \"lift\" \"1\\.7\\.0\"\\)")
5754                   "\"lift\""))
5755                #t)))))
5756       (synopsis "Container library for Common Lisp")
5757       (description
5758        "Common Lisp ships with a set of powerful built in data structures
5759 including the venerable list, full featured arrays, and hash-tables.
5760 CL-containers enhances and builds on these structures by adding containers
5761 that are not available in native Lisp (for example: binary search trees,
5762 red-black trees, sparse arrays and so on), and by providing a standard
5763 interface so that they are simpler to use and so that changing design
5764 decisions becomes significantly easier.")
5765       (home-page "https://common-lisp.net/project/cl-containers/")
5766       (license license:expat))))
5767
5768 (define-public cl-containers
5769   (sbcl-package->cl-source-package sbcl-cl-containers))
5770
5771 (define-public ecl-cl-containers
5772   (sbcl-package->ecl-package sbcl-cl-containers))
5773
5774 (define-public sbcl-xlunit
5775   (let ((commit "3805d34b1d8dc77f7e0ee527a2490194292dd0fc")
5776         (revision "1"))
5777     (package
5778       (name "sbcl-xlunit")
5779       (version (git-version "0.6.3" revision commit))
5780       (source
5781        (origin
5782          (method git-fetch)
5783          (uri (git-reference
5784                (url "http://git.kpe.io/xlunit.git")
5785                (commit commit)))
5786          (file-name (git-file-name name version))
5787          (sha256
5788           (base32
5789            "0argfmp9nghs4sihyj3f8ch9qfib2b7ll07v5m9ziajgzsfl5xw3"))))
5790       (build-system asdf-build-system/sbcl)
5791       (arguments
5792        '(#:phases
5793          (modify-phases %standard-phases
5794            (add-after 'unpack 'fix-tests
5795              (lambda _
5796                (substitute* "xlunit.asd"
5797                  ((" :force t") ""))
5798                #t)))))
5799       (synopsis "Unit testing package for Common Lisp")
5800       (description
5801        "The XLUnit package is a toolkit for building test suites.  It is based
5802 on the XPTest package by Craig Brozensky and the JUnit package by Kent Beck.")
5803       (home-page "http://quickdocs.org/xlunit/")
5804       (license license:bsd-3))))
5805
5806 (define-public cl-xlunit
5807   (sbcl-package->cl-source-package sbcl-xlunit))
5808
5809 (define-public ecl-xlunit
5810   (sbcl-package->ecl-package sbcl-xlunit))
5811
5812 (define-public sbcl-cambl
5813   (let ((commit "7016d1a98215f82605d1c158e7a16504ca1f4636")
5814         (revision "1"))
5815     (package
5816       (name "sbcl-cambl")
5817       (version (git-version "4.0.0" revision commit))
5818       (source
5819        (origin
5820          (method git-fetch)
5821          (uri (git-reference
5822                (url "https://github.com/jwiegley/cambl")
5823                (commit commit)))
5824          (file-name (git-file-name "cambl" version))
5825          (sha256
5826           (base32 "103mry04j2k9vznsxm7wcvccgxkil92cdrv52miwcmxl8daa4jiz"))))
5827       (build-system asdf-build-system/sbcl)
5828       (native-inputs
5829        `(("xlunit" ,sbcl-xlunit)))
5830       (inputs
5831        `(("alexandria" ,sbcl-alexandria)
5832          ("cl-containers" ,sbcl-cl-containers)
5833          ("local-time" ,sbcl-local-time)
5834          ("periods" ,sbcl-periods)))
5835       (arguments
5836        '(#:asd-files '("fprog.asd"
5837                        "cambl.asd")))
5838       (synopsis "Commoditized amounts and balances for Common Lisp")
5839       (description
5840        "CAMBL is a Common Lisp library providing a convenient facility for
5841 working with commoditized values.  It does not allow compound units (and so is
5842 not suited for scientific operations) but does work rather nicely for the
5843 purpose of financial calculations.")
5844       (home-page "https://github.com/jwiegley/cambl")
5845       (license license:bsd-3))))
5846
5847 (define-public cl-cambl
5848   (sbcl-package->cl-source-package sbcl-cambl))
5849
5850 (define-public ecl-cambl
5851   (sbcl-package->ecl-package sbcl-cambl))
5852
5853 (define-public sbcl-cl-ledger
5854   (let ((commit "08e0be41795e804cd36142e51756ad0b1caa377b")
5855         (revision "1"))
5856     (package
5857       (name "sbcl-cl-ledger")
5858       (version (git-version "4.0.0" revision commit))
5859       (source
5860        (origin
5861          (method git-fetch)
5862          (uri (git-reference
5863                (url "https://github.com/ledger/cl-ledger")
5864                (commit commit)))
5865          (file-name (git-file-name name version))
5866          (sha256
5867           (base32
5868            "1via0qf6wjcyxnfbmfxjvms0ik9j8rqbifgpmnhrzvkhrq9pv8h1"))))
5869       (build-system asdf-build-system/sbcl)
5870       (inputs
5871        `(("cambl" ,sbcl-cambl)
5872          ("cl-ppcre" ,sbcl-cl-ppcre)
5873          ("local-time" ,sbcl-local-time)
5874          ("periods" ,sbcl-periods)))
5875       (arguments
5876        '(#:phases
5877          (modify-phases %standard-phases
5878            (add-after 'unpack 'fix-system-definition
5879              (lambda _
5880                (substitute* "cl-ledger.asd"
5881                  (("  :build-operation program-op") "")
5882                  (("  :build-pathname \"cl-ledger\"") "")
5883                  (("  :entry-point \"ledger::main\"") ""))
5884                #t)))))
5885       (synopsis "Common Lisp port of the Ledger accounting system")
5886       (description
5887        "CL-Ledger is a Common Lisp port of the Ledger double-entry accounting
5888 system.")
5889       (home-page "https://github.com/ledger/cl-ledger")
5890       (license license:bsd-3))))
5891
5892 (define-public cl-ledger
5893   (sbcl-package->cl-source-package sbcl-cl-ledger))
5894
5895 (define-public ecl-cl-ledger
5896   (sbcl-package->ecl-package sbcl-cl-ledger))
5897
5898 (define-public sbcl-bst
5899   (let ((commit "34f9c7e8e0a9f2c952fe310ab36cb630d5d9c15a")
5900         (revision "1"))
5901     (package
5902       (name "sbcl-bst")
5903       (version (git-version "1.1" revision commit))
5904       (source
5905        (origin
5906          (method git-fetch)
5907          (uri (git-reference
5908                (url "https://github.com/glv2/bst")
5909                (commit commit)))
5910          (file-name (git-file-name name version))
5911          (sha256
5912           (base32
5913            "1amxns7hvvh4arwbh8ciwfzplg127vh37dnbamv1m1kmmnmihfc8"))))
5914       (build-system asdf-build-system/sbcl)
5915       (native-inputs
5916        `(("alexandria" ,sbcl-alexandria)
5917          ("fiveam" ,sbcl-fiveam)))
5918       (synopsis "Binary search tree for Common Lisp")
5919       (description
5920        "BST is a Common Lisp library for working with binary search trees that
5921 can contain any kind of values.")
5922       (home-page "https://github.com/glv2/bst")
5923       (license license:gpl3))))
5924
5925 (define-public cl-bst
5926   (sbcl-package->cl-source-package sbcl-bst))
5927
5928 (define-public ecl-bst
5929   (sbcl-package->ecl-package sbcl-bst))
5930
5931 (define-public sbcl-cl-octet-streams
5932   (package
5933     (name "sbcl-cl-octet-streams")
5934     (version "1.0")
5935     (source
5936      (origin
5937        (method git-fetch)
5938        (uri (git-reference
5939              (url "https://github.com/glv2/cl-octet-streams")
5940              (commit (string-append "v" version))))
5941        (file-name (git-file-name name version))
5942        (sha256
5943         (base32
5944          "1d7mn6ydv0j2x4r7clpc9ijjwrnfpxmvhifv8n5j7jh7s744sf8d"))))
5945     (build-system asdf-build-system/sbcl)
5946     (native-inputs
5947      `(("fiveam" ,sbcl-fiveam)))
5948     (inputs
5949      `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
5950     (synopsis "In-memory octet streams for Common Lisp")
5951     (description
5952      "CL-octet-streams is a library implementing in-memory octet
5953 streams for Common Lisp.  It was inspired by the trivial-octet-streams and
5954 cl-plumbing libraries.")
5955     (home-page "https://github.com/glv2/cl-octet-streams")
5956     (license license:gpl3+)))
5957
5958 (define-public cl-octet-streams
5959   (sbcl-package->cl-source-package sbcl-cl-octet-streams))
5960
5961 (define-public ecl-cl-octet-streams
5962   (sbcl-package->ecl-package sbcl-cl-octet-streams))
5963
5964 (define-public sbcl-lzlib
5965   (let ((commit "0de1db7129fef9a58a059d35a2fa2ecfc5b47b47")
5966         (revision "1"))
5967     (package
5968       (name "sbcl-lzlib")
5969       (version (git-version "1.0" revision commit))
5970       (source
5971        (origin
5972          (method git-fetch)
5973          (uri (git-reference
5974                (url "https://github.com/glv2/cl-lzlib")
5975                (commit commit)))
5976          (file-name (git-file-name name version))
5977          (sha256
5978           (base32
5979            "12ny7vj52fgnd8hb8fc8mry92vq4c1x72x2350191m4476j95clz"))))
5980       (build-system asdf-build-system/sbcl)
5981       (native-inputs
5982        `(("fiveam" ,sbcl-fiveam)))
5983       (inputs
5984        `(("cffi" ,sbcl-cffi)
5985          ("cl-octet-streams" ,sbcl-cl-octet-streams)
5986          ("lzlib" ,lzlib)))
5987       (arguments
5988        '(#:phases
5989          (modify-phases %standard-phases
5990            (add-after 'unpack 'fix-paths
5991              (lambda* (#:key inputs #:allow-other-keys)
5992                (substitute* "src/lzlib.lisp"
5993                  (("liblz\\.so")
5994                   (string-append (assoc-ref inputs "lzlib") "/lib/liblz.so")))
5995                #t)))))
5996       (synopsis "Common Lisp library for lzip (de)compression")
5997       (description
5998        "This Common Lisp library provides functions for lzip (LZMA)
5999 compression/decompression using bindings to the lzlib C library.")
6000       (home-page "https://github.com/glv2/cl-lzlib")
6001       (license license:gpl3+))))
6002
6003 (define-public cl-lzlib
6004   (sbcl-package->cl-source-package sbcl-lzlib))
6005
6006 (define-public ecl-lzlib
6007   (sbcl-package->ecl-package sbcl-lzlib))
6008
6009 (define-public sbcl-chanl
6010   (let ((commit "56e90a126c78b39bb621a01585e8d3b985238e8c")
6011         (revision "1"))
6012     (package
6013       (name "sbcl-chanl")
6014       (version (git-version "0.4.1" revision commit))
6015       (source
6016        (origin
6017          (method git-fetch)
6018          (uri (git-reference
6019                (url "https://github.com/zkat/chanl")
6020                (commit commit)))
6021          (file-name (git-file-name name version))
6022          (sha256
6023           (base32
6024            "0b1cf6c12qx5cy1fw2z42jgh566rp3l8nv5qf0qqc569s7bgmrh4"))))
6025       (build-system asdf-build-system/sbcl)
6026       (native-inputs
6027        `(("fiveam" ,sbcl-fiveam)))
6028       (inputs
6029        `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
6030       (synopsis "Portable channel-based concurrency for Common Lisp")
6031       (description "Common Lisp library for channel-based concurrency.  In
6032 a nutshell, you create various threads sequentially executing tasks you need
6033 done, and use channel objects to communicate and synchronize the state of these
6034 threads.")
6035       (home-page "https://github.com/zkat/chanl")
6036       (license (list license:expat license:bsd-3)))))
6037
6038 (define-public cl-chanl
6039   (sbcl-package->cl-source-package sbcl-chanl))
6040
6041 (define-public ecl-chanl
6042   (sbcl-package->ecl-package sbcl-chanl))
6043
6044 (define-public sbcl-cl-store
6045   (let ((commit "c787337a16ea8cf8a06227f35933a4ec774746b3")
6046         (revision "1"))
6047     (package
6048       (name "sbcl-cl-store")
6049       (version (git-version "0.8.11" revision commit))
6050       (source
6051        (origin
6052          (method git-fetch)
6053          (uri (git-reference
6054                (url "https://github.com/skypher/cl-store")
6055                (commit commit)))
6056          (file-name (git-file-name name version))
6057          (sha256
6058           (base32
6059            "194srkg8nrym19c6i7zbnkzshc1qhqa82m53qnkirz9fw928bqxr"))))
6060       (build-system asdf-build-system/sbcl)
6061       (native-inputs
6062        `(("rt" ,sbcl-rt)))
6063       (synopsis "Common Lisp library to serialize data")
6064       (description
6065        "CL-STORE is a portable serialization package which should give you the
6066 ability to store all Common Lisp data types into streams.")
6067       (home-page "https://www.common-lisp.net/project/cl-store/")
6068       (license license:expat))))
6069
6070 (define-public cl-store
6071   (sbcl-package->cl-source-package sbcl-cl-store))
6072
6073 (define-public ecl-cl-store
6074   (sbcl-package->ecl-package sbcl-cl-store))
6075
6076 (define-public sbcl-cl-gobject-introspection
6077   (let ((commit "7b703e2384945ea0ac39d9b766de434a08d81560")
6078         (revision "0"))
6079     (package
6080       (name "sbcl-cl-gobject-introspection")
6081       (version (git-version "0.3" revision commit))
6082       (home-page "https://github.com/andy128k/cl-gobject-introspection")
6083       (source
6084        (origin
6085          (method git-fetch)
6086          (uri (git-reference
6087                (url home-page)
6088                (commit commit)))
6089          (file-name (git-file-name name version))
6090          (sha256
6091           (base32
6092            "1zcqd2qj14f6b38vys8gr89s6cijsp9r8j43xa8lynilwva7bwyh"))))
6093       (build-system asdf-build-system/sbcl)
6094       (inputs
6095        `(("alexandria" ,sbcl-alexandria)
6096          ("cffi" ,sbcl-cffi)
6097          ("iterate" ,sbcl-iterate)
6098          ("trivial-garbage" ,sbcl-trivial-garbage)
6099          ("glib" ,glib)
6100          ("gobject-introspection" ,gobject-introspection)))
6101       (native-inputs
6102        `(("fiveam" ,sbcl-fiveam)))
6103       (arguments
6104        ;; TODO: Tests fail, see
6105        ;; https://github.com/andy128k/cl-gobject-introspection/issues/70.
6106        '(#:tests? #f
6107          #:phases
6108          (modify-phases %standard-phases
6109            (add-after (quote unpack) (quote fix-paths)
6110              (lambda* (#:key inputs #:allow-other-keys)
6111                (substitute* "src/init.lisp"
6112                  (("libgobject-2\\.0\\.so")
6113                   (string-append (assoc-ref inputs "glib") "/lib/libgobject-2.0.so"))
6114                  (("libgirepository-1\\.0\\.so")
6115                   (string-append (assoc-ref inputs "gobject-introspection")
6116                                  "/lib/libgirepository-1.0.so")))
6117                #t)))))
6118       (synopsis "Common Lisp bindings to GObject Introspection")
6119       (description
6120        "This library is a bridge between Common Lisp and GObject
6121 Introspection, which enables Common Lisp programs to access the full interface
6122 of C+GObject libraries without the need of writing dedicated bindings.")
6123       (license (list license:bsd-3
6124                      ;; Tests are under a different license.
6125                      license:llgpl)))))
6126
6127 (define-public cl-gobject-introspection
6128   (sbcl-package->cl-source-package sbcl-cl-gobject-introspection))
6129
6130 (define-public ecl-cl-gobject-introspection
6131   (sbcl-package->ecl-package sbcl-cl-gobject-introspection))
6132
6133 (define-public sbcl-string-case
6134   (let ((commit "718c761e33749e297cd2809c7ba3ade1985c49f7")
6135         (revision "0"))
6136     (package
6137       (name "sbcl-string-case")
6138       (version (git-version "0.0.2" revision commit))
6139       (home-page "https://github.com/pkhuong/string-case")
6140       (source
6141        (origin
6142          (method git-fetch)
6143          (uri (git-reference
6144                (url home-page)
6145                (commit commit)))
6146          (file-name (git-file-name name version))
6147          (sha256
6148           (base32
6149            "1n5i3yh0h5s636rcnwn7jwqy3rjflikra04lymimhpcshhjsk0md"))))
6150       (build-system asdf-build-system/sbcl)
6151       (synopsis "Efficient string= case in Common Lisp")
6152       (description
6153        "@code{string-case} is a Common Lisp macro that generates specialised decision
6154 trees to dispatch on string equality.")
6155       (license license:bsd-3))))
6156
6157 (define-public cl-string-case
6158   (sbcl-package->cl-source-package sbcl-string-case))
6159
6160 (define-public ecl-string-case
6161   (sbcl-package->ecl-package sbcl-string-case))
6162
6163 (define-public sbcl-global-vars
6164   (let ((commit "c749f32c9b606a1457daa47d59630708ac0c266e")
6165         (revision "0"))
6166     (package
6167       (name "sbcl-global-vars")
6168       (version (git-version "1.0.0" revision commit))
6169       (home-page "https://github.com/lmj/global-vars")
6170       (source
6171        (origin
6172          (method git-fetch)
6173          (uri (git-reference
6174                (url home-page)
6175                (commit commit)))
6176          (file-name (git-file-name name version))
6177          (sha256
6178           (base32
6179            "06m3xc8l3pgsapl8fvsi9wf6y46zs75cp9zn7zh6dc65v4s5wz3d"))))
6180       (build-system asdf-build-system/sbcl)
6181       (synopsis "Efficient global variables in Common Lisp")
6182       (description
6183        "In Common Lisp, a special variable that is never dynamically bound
6184 typically serves as a stand-in for a global variable.  The @code{global-vars}
6185 library provides true global variables that are implemented by some compilers.
6186 An attempt to rebind a global variable properly results in a compiler error.
6187 That is, a global variable cannot be dynamically bound.
6188
6189 Global variables therefore allow us to communicate an intended usage that
6190 differs from special variables.  Global variables are also more efficient than
6191 special variables, especially in the presence of threads.")
6192       (license license:expat))))
6193
6194 (define-public cl-global-vars
6195   (sbcl-package->cl-source-package sbcl-global-vars))
6196
6197 (define-public ecl-global-vars
6198   (sbcl-package->ecl-package sbcl-global-vars))
6199
6200 (define-public sbcl-trivial-file-size
6201   (let ((commit "1c1d672a01a446ba0391dbb4ffc40be3b0476f23")
6202         (revision "0"))
6203     (package
6204       (name "sbcl-trivial-file-size")
6205       (version (git-version "0.0.0" revision commit))
6206       (home-page "https://github.com/ruricolist/trivial-file-size")
6207       (source
6208        (origin
6209          (method git-fetch)
6210          (uri (git-reference
6211                (url home-page)
6212                (commit commit)))
6213          (file-name (git-file-name name version))
6214          (sha256
6215           (base32
6216            "17pp86c9zs4y7i1sh7q9gbfw9iqv6655k7fz8qbj9ly1ypgxp4qs"))))
6217       (build-system asdf-build-system/sbcl)
6218       (native-inputs
6219        `(("fiveam" ,sbcl-fiveam)))
6220       (synopsis "Size of a file in bytes in Common Lisp")
6221       (description
6222        "The canonical way to determine the size of a file in bytes, using Common Lisp,
6223 is to open the file with an element type of (unsigned-byte 8) and then
6224 calculate the length of the stream.  This is less than ideal.  In most cases
6225 it is better to get the size of the file from its metadata, using a system
6226 call.
6227
6228 This library exports a single function, file-size-in-octets.  It returns the
6229 size of a file in bytes, using system calls when possible.")
6230       (license license:expat))))
6231
6232 (define-public cl-trivial-file-size
6233   (sbcl-package->cl-source-package sbcl-trivial-file-size))
6234
6235 (define-public ecl-trivial-file-size
6236   (sbcl-package->ecl-package sbcl-trivial-file-size))
6237
6238 (define-public sbcl-trivial-macroexpand-all
6239   (let ((commit "933270ac7107477de1bc92c1fd641fe646a7a8a9")
6240         (revision "0"))
6241     (package
6242       (name "sbcl-trivial-macroexpand-all")
6243       (version (git-version "0.0.0" revision commit))
6244       (home-page "https://github.com/cbaggers/trivial-macroexpand-all")
6245       (source
6246        (origin
6247          (method git-fetch)
6248          (uri (git-reference
6249                (url home-page)
6250                (commit commit)))
6251          (file-name (git-file-name name version))
6252          (sha256
6253           (base32
6254            "191hnn4b5j4i3crydmlzbm231kj0h7l8zj6mzj69r1npbzkas4bd"))))
6255       (build-system asdf-build-system/sbcl)
6256       (native-inputs
6257        `(("fiveam" ,sbcl-fiveam)))
6258       (synopsis "Portable macroexpand-all for Common Lisp")
6259       (description
6260        "This library provides a macroexpand-all function that calls the
6261 implementation specific equivalent.")
6262       (license license:unlicense))))
6263
6264 (define-public cl-trivial-macroexpand-all
6265   (sbcl-package->cl-source-package sbcl-trivial-macroexpand-all))
6266
6267 (define-public ecl-trivial-macroexpand-all
6268   (sbcl-package->ecl-package sbcl-trivial-macroexpand-all))
6269
6270 (define-public sbcl-serapeum
6271   (let ((commit "a2ca90cbdcb9f76c2822286110c7abe9ba5b76c2")
6272         (revision "2"))
6273     (package
6274       (name "sbcl-serapeum")
6275       (version (git-version "0.0.0" revision commit))
6276       (home-page "https://github.com/ruricolist/serapeum")
6277       (source
6278        (origin
6279          (method git-fetch)
6280          (uri (git-reference
6281                (url home-page)
6282                (commit commit)))
6283          (file-name (git-file-name name version))
6284          (sha256
6285           (base32
6286            "1lrk2kf7qh5g6f8xvyg8wf89frzb5mw6m1jzgy46jy744f459i8q"))))
6287       (build-system asdf-build-system/sbcl)
6288       (inputs
6289        `(("alexandria" ,sbcl-alexandria)
6290          ("trivia" ,sbcl-trivia)
6291          ("split-sequence" ,sbcl-split-sequence)
6292          ("string-case" ,sbcl-string-case)
6293          ("parse-number" ,sbcl-parse-number)
6294          ("trivial-garbage" ,sbcl-trivial-garbage)
6295          ("bordeaux-threads" ,sbcl-bordeaux-threads)
6296          ("named-readtables" ,sbcl-named-readtables)
6297          ("fare-quasiquote" ,sbcl-fare-quasiquote)
6298          ("parse-declarations-1.0" ,sbcl-parse-declarations)
6299          ("global-vars" ,sbcl-global-vars)
6300          ("trivial-file-size" ,sbcl-trivial-file-size)
6301          ("trivial-macroexpand-all" ,sbcl-trivial-macroexpand-all)))
6302       (native-inputs
6303        `(("fiveam" ,sbcl-fiveam)
6304          ("local-time" ,sbcl-local-time)))
6305       (arguments
6306        '(#:phases
6307          (modify-phases %standard-phases
6308            (add-after 'unpack 'disable-failing-tests
6309              (lambda* (#:key inputs #:allow-other-keys)
6310                (substitute* "serapeum.asd"
6311                  ;; Guix does not have Quicklisp, and probably never will.
6312                  (("\\(:file \"quicklisp\"\\)") ""))
6313                #t)))))
6314       (synopsis "Common Lisp utility library beyond Alexandria")
6315       (description
6316        "Serapeum is a conservative library of Common Lisp utilities.  It is a
6317 supplement, not a competitor, to Alexandria.")
6318       (license license:expat))))
6319
6320 (define-public cl-serapeum
6321   (sbcl-package->cl-source-package sbcl-serapeum))
6322
6323 (define-public ecl-serapeum
6324   (sbcl-package->ecl-package sbcl-serapeum))
6325
6326 (define-public sbcl-arrows
6327   (let ((commit "df7cf0067e0132d9697ac8b1a4f1b9c88d4f5382")
6328         (revision "0"))
6329     (package
6330       (name "sbcl-arrows")
6331       (version (git-version "0.2.0" revision commit))
6332       (source
6333        (origin
6334          (method git-fetch)
6335          (uri (git-reference
6336                (url "https://gitlab.com/Harleqin/arrows.git")
6337                (commit commit)))
6338          (file-name (git-file-name name version))
6339          (sha256
6340           (base32
6341            "042k9vkssrqx9nhp14wdzm942zgdxvp35mba0p2syz98i75im2yy"))))
6342       (build-system asdf-build-system/sbcl)
6343       (native-inputs
6344        `(("hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
6345       (synopsis "Clojure-like arrow macros for Common Lisp")
6346       (description
6347        "This library implements the @code{->} and @code{->>} macros from
6348 Clojure, as well as several expansions on the idea.")
6349       (home-page "https://gitlab.com/Harleqin/arrows")
6350       (license license:public-domain))))
6351
6352 (define-public cl-arrows
6353   (sbcl-package->cl-source-package sbcl-arrows))
6354
6355 (define-public ecl-arrows
6356   (sbcl-package->ecl-package sbcl-arrows))
6357
6358 (define-public sbcl-simple-parallel-tasks
6359   (let ((commit "db460f7a3f7bbfe2d3a2223ed21e162068d04dda")
6360         (revision "0"))
6361     (package
6362       (name "sbcl-simple-parallel-tasks")
6363       (version (git-version "1.0" revision commit))
6364       (source
6365        (origin
6366          (method git-fetch)
6367          (uri (git-reference
6368                (url "https://github.com/glv2/simple-parallel-tasks")
6369                (commit commit)))
6370          (file-name (git-file-name name version))
6371          (sha256
6372           (base32
6373            "0amw3qk23wnlyrsgzszs6rs7y4zvxv8dr03rnqhc60mnm8ds4dd5"))))
6374       (build-system asdf-build-system/sbcl)
6375       (native-inputs
6376        `(("fiveam" ,sbcl-fiveam)))
6377       (inputs
6378        `(("chanl" ,sbcl-chanl)))
6379       (synopsis "Common Lisp library to evaluate some forms in parallel")
6380       (description "This is a simple Common Lisp library to evaluate some
6381 forms in parallel.")
6382       (home-page "https://github.com/glv2/simple-parallel-tasks")
6383       (license license:gpl3))))
6384
6385 (define-public cl-simple-parallel-tasks
6386   (sbcl-package->cl-source-package sbcl-simple-parallel-tasks))
6387
6388 (define-public ecl-simple-parallel-tasks
6389   (sbcl-package->ecl-package sbcl-simple-parallel-tasks))
6390
6391 (define-public sbcl-cl-heap
6392   (package
6393     (name "sbcl-cl-heap")
6394     (version "0.1.6")
6395     (source
6396      (origin
6397        (method url-fetch)
6398        (uri (string-append "https://common-lisp.net/project/cl-heap/releases/"
6399                            "cl-heap_" version ".tar.gz"))
6400        (sha256
6401         (base32
6402          "163hb07p2nxz126rpq3cj5dyala24n0by5i5786n2qcr1w0bak4i"))))
6403     (build-system asdf-build-system/sbcl)
6404     (native-inputs
6405      `(("xlunit" ,sbcl-xlunit)))
6406     (arguments
6407      `(#:test-asd-file "cl-heap-tests.asd"))
6408     (synopsis "Heap and priority queue data structures for Common Lisp")
6409     (description
6410      "CL-HEAP provides various implementations of heap data structures (a
6411 binary heap and a Fibonacci heap) as well as an efficient priority queue.")
6412     (home-page "https://common-lisp.net/project/cl-heap/")
6413     (license license:gpl3+)))
6414
6415 (define-public cl-heap
6416   (sbcl-package->cl-source-package sbcl-cl-heap))
6417
6418 (define-public ecl-cl-heap
6419   (sbcl-package->ecl-package sbcl-cl-heap))
6420
6421 (define-public sbcl-curry-compose-reader-macros
6422   (let ((commit "beaa92dedf392726c042184bfd6149fa8d9e6ac2")
6423         (revision "0"))
6424     (package
6425       (name "sbcl-curry-compose-reader-macros")
6426       (version (git-version "1.0.0" revision commit))
6427       (source
6428        (origin
6429          (method git-fetch)
6430          (uri
6431           (git-reference
6432            (url "https://github.com/eschulte/curry-compose-reader-macros")
6433            (commit commit)))
6434          (file-name (git-file-name name version))
6435          (sha256
6436           (base32
6437            "0rv9bl8xrad5wfcg5zs1dazvnpmvqz6297lbn8bywsrcfnlf7h98"))))
6438       (build-system asdf-build-system/sbcl)
6439       (inputs
6440        `(("alexandria" ,sbcl-alexandria)
6441          ("named-readtables" ,sbcl-named-readtables)))
6442       (synopsis "Reader macros for partial application and composition")
6443       (description
6444        "This Common Lisp library provides reader macros for concise expression
6445 of function partial application and composition.")
6446       (home-page "https://eschulte.github.io/curry-compose-reader-macros/")
6447       (license license:public-domain))))
6448
6449 (define-public cl-curry-compose-reader-macros
6450   (sbcl-package->cl-source-package sbcl-curry-compose-reader-macros))
6451
6452 (define-public ecl-curry-compose-reader-macros
6453   (sbcl-package->ecl-package sbcl-curry-compose-reader-macros))
6454
6455 (define-public sbcl-yason
6456   (package
6457     (name "sbcl-yason")
6458     (version "0.7.7")
6459     (source
6460      (origin
6461        (method git-fetch)
6462        (uri (git-reference
6463              (url "https://github.com/phmarek/yason")
6464              (commit (string-append "v" version))))
6465        (file-name (git-file-name name version))
6466        (sha256
6467         (base32
6468          "0479rbjgbj80jpk5bby18inlv1kfp771a82rlcq5psrz65qqa9bj"))))
6469     (build-system asdf-build-system/sbcl)
6470     (inputs
6471      `(("alexandria" ,sbcl-alexandria)
6472        ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
6473     (synopsis "Common Lisp JSON parser/encoder")
6474     (description
6475      "YASON is a Common Lisp library for encoding and decoding data in the
6476 JSON interchange format.")
6477     (home-page "https://github.com/phmarek/yason")
6478     (license license:bsd-3)))
6479
6480 (define-public cl-yason
6481   (sbcl-package->cl-source-package sbcl-yason))
6482
6483 (define-public ecl-yason
6484   (sbcl-package->ecl-package sbcl-yason))
6485
6486 (define-public sbcl-stefil
6487   (let ((commit "0398548ec95dceb50fc2c2c03e5fb0ce49b86c7a")
6488         (revision "0"))
6489     (package
6490       (name "sbcl-stefil")
6491       (version (git-version "0.1" revision commit))
6492       (source
6493        (origin
6494          (method git-fetch)
6495          (uri (git-reference
6496                (url "https://gitlab.common-lisp.net/stefil/stefil.git")
6497                (commit commit)))
6498          (file-name (git-file-name name version))
6499          (sha256
6500           (base32
6501            "0bqz64q2szzhf91zyqyssmvrz7da6442rs01808pf3wrdq28bclh"))))
6502       (build-system asdf-build-system/sbcl)
6503       (inputs
6504        `(("alexandria" ,sbcl-alexandria)
6505          ("iterate" ,sbcl-iterate)
6506          ("metabang-bind" ,sbcl-metabang-bind)
6507          ("swank" ,sbcl-slime-swank)))
6508       (arguments
6509        '(#:phases
6510          (modify-phases %standard-phases
6511            (add-after 'unpack 'drop-unnecessary-dependency
6512              (lambda _
6513                (substitute* "package.lisp"
6514                  ((":stefil-system") ""))
6515                #t)))))
6516       (home-page "https://common-lisp.net/project/stefil/index-old.shtml")
6517       (synopsis "Simple test framework")
6518       (description
6519        "Stefil is a simple test framework for Common Lisp, with a focus on
6520 interactive development.")
6521       (license license:public-domain))))
6522
6523 (define-public cl-stefil
6524   (sbcl-package->cl-source-package sbcl-stefil))
6525
6526 (define-public ecl-stefil
6527   (sbcl-package->ecl-package sbcl-stefil))
6528
6529 (define-public sbcl-graph
6530   (let ((commit "78bf9ec930d8eae4f0861b5be76765fb1e45e24f")
6531         (revision "0"))
6532     (package
6533       (name "sbcl-graph")
6534       (version (git-version "0.0.0" revision commit))
6535       (source
6536        (origin
6537          (method git-fetch)
6538          (uri
6539           (git-reference
6540            (url "https://github.com/eschulte/graph")
6541            (commit commit)))
6542          (file-name (git-file-name name version))
6543          (sha256
6544           (base32
6545            "1qpij4xh8bqwc2myahpilcbh916v7vg0acz2fij14d3y0jm02h0g"))))
6546       (build-system asdf-build-system/sbcl)
6547       (native-inputs
6548        `(("stefil" ,sbcl-stefil)))
6549       (inputs
6550        `(("alexandria" ,sbcl-alexandria)
6551          ("cl-heap" ,sbcl-cl-heap)
6552          ("cl-ppcre" ,sbcl-cl-ppcre)
6553          ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
6554          ("metabang-bind" ,sbcl-metabang-bind)
6555          ("named-readtables" ,sbcl-named-readtables)
6556          ("yason" ,sbcl-yason)))
6557       (arguments
6558        '(#:asd-systems '("graph"
6559                          "graph/dot"
6560                          "graph/json")))
6561       (synopsis "Graph data structure and algorithms for Common Lisp")
6562       (description
6563        "The GRAPH Common Lisp library provides a data structures to represent
6564 graphs, as well as some graph manipulation and analysis algorithms (shortest
6565 path, maximum flow, minimum spanning tree, etc.).")
6566       (home-page "https://eschulte.github.io/graph/")
6567       (license license:gpl3+))))
6568
6569 (define-public cl-graph
6570   (sbcl-package->cl-source-package sbcl-graph))
6571
6572 (define-public ecl-graph
6573   (sbcl-package->ecl-package sbcl-graph))
6574
6575 (define-public sbcl-trivial-indent
6576   (let ((commit "2d016941751647c6cc5bd471751c2cf68861c94a")
6577         (revision "0"))
6578     (package
6579       (name "sbcl-trivial-indent")
6580       (version (git-version "1.0.0" revision commit))
6581       (source
6582        (origin
6583          (method git-fetch)
6584          (uri
6585           (git-reference
6586            (url "https://github.com/Shinmera/trivial-indent")
6587            (commit commit)))
6588          (file-name (git-file-name name version))
6589          (sha256
6590           (base32
6591            "1sj90nqz17w4jq0ixz00gb9g5g6d2s7l8r17zdby27gxxh51w266"))))
6592       (build-system asdf-build-system/sbcl)
6593       (synopsis "Simple Common Lisp library to allow indentation hints for SWANK")
6594       (description
6595        "This library allows you to define custom indentation hints for your
6596 macros if the one recognised by SLIME automatically produces unwanted
6597 results.")
6598       (home-page "https://shinmera.github.io/trivial-indent/")
6599       (license license:zlib))))
6600
6601 (define-public cl-trivial-indent
6602   (sbcl-package->cl-source-package sbcl-trivial-indent))
6603
6604 (define-public ecl-trivial-indent
6605   (sbcl-package->ecl-package sbcl-trivial-indent))
6606
6607 (define-public sbcl-documentation-utils
6608   (let ((commit "98630dd5f7e36ae057fa09da3523f42ccb5d1f55")
6609         (revision "0"))
6610     (package
6611       (name "sbcl-documentation-utils")
6612       (version (git-version "1.2.0" revision commit))
6613       (source
6614        (origin
6615          (method git-fetch)
6616          (uri
6617           (git-reference
6618            (url "https://github.com/Shinmera/documentation-utils")
6619            (commit commit)))
6620          (file-name (git-file-name name version))
6621          (sha256
6622           (base32
6623            "098qhkqskmmrh4wix34mawf7p5c87yql28r51r75yjxj577k5idq"))))
6624       (build-system asdf-build-system/sbcl)
6625       (inputs
6626        `(("trivial-indent" ,sbcl-trivial-indent)))
6627       (synopsis "Few simple tools to document Common Lisp libraries")
6628       (description
6629        "This is a small library to help you with managing the Common Lisp
6630 docstrings for your library.")
6631       (home-page "https://shinmera.github.io/documentation-utils/")
6632       (license license:zlib))))
6633
6634 (define-public cl-documentation-utils
6635   (sbcl-package->cl-source-package sbcl-documentation-utils))
6636
6637 (define-public ecl-documentation-utils
6638   (sbcl-package->ecl-package sbcl-documentation-utils))
6639
6640 (define-public sbcl-form-fiddle
6641   (let ((commit "e0c23599dbb8cff3e83e012f3d86d0764188ad18")
6642         (revision "0"))
6643     (package
6644       (name "sbcl-form-fiddle")
6645       (version (git-version "1.1.0" revision commit))
6646       (source
6647        (origin
6648          (method git-fetch)
6649          (uri
6650           (git-reference
6651            (url "https://github.com/Shinmera/form-fiddle")
6652            (commit commit)))
6653          (file-name (git-file-name name version))
6654          (sha256
6655           (base32
6656            "041iznc9mpfyrl0sv5893ys9pbb2pvbn9g3clarqi7gsfj483jln"))))
6657       (build-system asdf-build-system/sbcl)
6658       (inputs
6659        `(("documentation-utils" ,sbcl-documentation-utils)))
6660       (synopsis "Utilities to destructure Common Lisp lambda forms")
6661       (description
6662        "Often times we need to destructure a form definition in a Common Lisp
6663 macro.  This library provides a set of simple utilities to help with that.")
6664       (home-page "https://shinmera.github.io/form-fiddle/")
6665       (license license:zlib))))
6666
6667 (define-public cl-form-fiddle
6668   (sbcl-package->cl-source-package sbcl-form-fiddle))
6669
6670 (define-public ecl-form-fiddle
6671   (sbcl-package->ecl-package sbcl-form-fiddle))
6672
6673 (define-public sbcl-parachute
6674   (let ((commit "ca04dd8e43010a6dfffa26dbe1d62af86008d666")
6675         (revision "0"))
6676     (package
6677       (name "sbcl-parachute")
6678       (version (git-version "1.1.1" revision commit))
6679       (source
6680        (origin
6681          (method git-fetch)
6682          (uri
6683           (git-reference
6684            (url "https://github.com/Shinmera/parachute")
6685            (commit commit)))
6686          (file-name (git-file-name name version))
6687          (sha256
6688           (base32
6689            "1mvsm3r0r6a2bg75nw0q7n9vlby3ch45qjl7hnb5k1z2n5x5lh60"))))
6690       (build-system asdf-build-system/sbcl)
6691       (inputs
6692        `(("documentation-utils" ,sbcl-documentation-utils)
6693          ("form-fiddle" ,sbcl-form-fiddle)))
6694       (synopsis "Extensible and cross-compatible testing framework for Common Lisp")
6695       (description
6696        "Parachute is a simple-to-use and extensible testing framework.
6697 In Parachute, things are organised as a bunch of named tests within a package.
6698 Each test can contain a bunch of test forms that make up its body.")
6699       (home-page "https://shinmera.github.io/parachute/")
6700       (license license:zlib))))
6701
6702 (define-public cl-parachute
6703   (sbcl-package->cl-source-package sbcl-parachute))
6704
6705 (define-public ecl-parachute
6706   (sbcl-package->ecl-package sbcl-parachute))
6707
6708 (define-public sbcl-array-utils
6709   (let ((commit "f90eb9070d0b2205af51126a35033574725e5c56")
6710         (revision "0"))
6711     (package
6712       (name "sbcl-array-utils")
6713       (version (git-version "1.1.1" revision commit))
6714       (source
6715        (origin
6716          (method git-fetch)
6717          (uri
6718           (git-reference
6719            (url "https://github.com/Shinmera/array-utils")
6720            (commit commit)))
6721          (file-name (git-file-name name version))
6722          (sha256
6723           (base32
6724            "0zhwfbpr53vs1ii4sx75dz2k9yhh1xpwdqqpg8nmfndxkmhpbi3x"))))
6725       (build-system asdf-build-system/sbcl)
6726       (native-inputs
6727        `(("parachute" ,sbcl-parachute)))
6728       (inputs
6729        `(("documentation-utils" ,sbcl-documentation-utils)))
6730       (synopsis "Tiny collection of array and vector utilities for Common Lisp")
6731       (description
6732        "A miniature toolkit that contains some useful shifting/popping/pushing
6733 functions for arrays and vectors.  Originally from Plump.")
6734       (home-page "https://shinmera.github.io/array-utils/")
6735       (license license:zlib))))
6736
6737 (define-public cl-array-utils
6738   (sbcl-package->cl-source-package sbcl-array-utils))
6739
6740 (define-public ecl-array-utils
6741   (sbcl-package->ecl-package sbcl-array-utils))
6742
6743 (define-public sbcl-plump
6744   (let ((commit "34f890fe46efdebe7bb70d218f1937e98f632bf9")
6745         (revision "1"))
6746     (package
6747       (name "sbcl-plump")
6748       (version (git-version "2.0.0" revision commit))
6749       (source
6750        (origin
6751          (method git-fetch)
6752          (uri
6753           (git-reference
6754            (url "https://github.com/Shinmera/plump")
6755            (commit commit)))
6756          (file-name (git-file-name name version))
6757          (sha256
6758           (base32
6759            "0a0x8wn6vv1ylxcwck12k18gy0a366kdm6ddxxk7yynl4mwnqgkh"))))
6760       (build-system asdf-build-system/sbcl)
6761       (inputs
6762        `(("array-utils" ,sbcl-array-utils)
6763          ("documentation-utils" ,sbcl-documentation-utils)))
6764       (synopsis "Lenient XML / XHTML / HTML parser for Common Lisp")
6765       (description
6766        "Plump is a parser for HTML/XML-like documents, focusing on being
6767 lenient towards invalid markup.  It can handle things like invalid attributes,
6768 bad closing tag order, unencoded entities, inexistent tag types, self-closing
6769 tags and so on.  It parses documents to a class representation and offers a
6770 small set of DOM functions to manipulate it.  It can be extended to parse to
6771 your own classes.")
6772       (home-page "https://shinmera.github.io/plump/")
6773       (license license:zlib))))
6774
6775 (define-public cl-plump
6776   (sbcl-package->cl-source-package sbcl-plump))
6777
6778 (define-public ecl-plump
6779   (sbcl-package->ecl-package sbcl-plump))
6780
6781 ;;; Split the antik package in two to work around the circular dependency
6782 ;;; between antik/antik and antik/gsll.
6783 (define-public sbcl-antik-base
6784   (let ((commit "e4711a69b3d6bf37b5727af05c3cfd03e8428ba3")
6785         (revision "1"))
6786     (package
6787       (name "sbcl-antik-base")
6788       (version (git-version "0.0.0" revision commit))
6789       (source
6790        (origin
6791          (method git-fetch)
6792          (uri (git-reference
6793                (url "https://gitlab.common-lisp.net/antik/antik.git")
6794                (commit commit)))
6795          (file-name (git-file-name name version))
6796          (sha256
6797           (base32
6798            "047ga2c38par2xbgg4qx6hwv06qhf1c1f67as8xvir6s80lip1km"))))
6799       (build-system asdf-build-system/sbcl)
6800       (inputs
6801        `(("alexandria" ,sbcl-alexandria)
6802          ("cffi" ,sbcl-cffi)
6803          ("cl-ppcre" ,sbcl-cl-ppcre)
6804          ("drakma" ,sbcl-drakma)
6805          ("fare-utils" ,sbcl-fare-utils)
6806          ("iterate" ,sbcl-iterate)
6807          ("metabang-bind" ,sbcl-metabang-bind)
6808          ("named-readtables" ,sbcl-named-readtables)
6809          ("split-sequence" ,sbcl-split-sequence)
6810          ("static-vectors" ,sbcl-static-vectors)
6811          ("trivial-garbage" ,sbcl-trivial-garbage)
6812          ("trivial-utf-8" ,sbcl-trivial-utf-8)))
6813       (native-inputs
6814        `(("lisp-unit" ,sbcl-lisp-unit)))
6815       (arguments
6816        '(#:asd-systems '("antik-base"
6817                          "foreign-array"
6818                          "physical-dimension"
6819                          "science-data")
6820          #:phases
6821          (modify-phases %standard-phases
6822            (add-after 'unpack 'fix-build
6823              (lambda _
6824                (delete-file "antik.asd")
6825                #t)))))
6826       (synopsis "Scientific and engineering computation in Common Lisp")
6827       (description
6828        "Antik provides a foundation for scientific and engineering
6829 computation in Common Lisp.  It is designed not only to facilitate
6830 numerical computations, but to permit the use of numerical computation
6831 libraries and the interchange of data and procedures, whether
6832 foreign (non-Lisp) or Lisp libraries.  It is named after the
6833 Antikythera mechanism, one of the oldest examples of a scientific
6834 computer known.")
6835       (home-page "https://common-lisp.net/project/antik/")
6836       (license license:gpl3))))
6837
6838 (define-public cl-antik-base
6839   (sbcl-package->cl-source-package sbcl-antik-base))
6840
6841 (define-public sbcl-gsll
6842   (let ((commit "1a8ada22f9cf5ed7372d352b2317f4ccdb6ab308")
6843         (revision "1"))
6844     (package
6845       (name "sbcl-gsll")
6846       (version (git-version "0.0.0" revision commit))
6847       (source
6848        (origin
6849          (method git-fetch)
6850          (uri (git-reference
6851                (url "https://gitlab.common-lisp.net/antik/gsll.git")
6852                (commit commit)))
6853          (file-name (git-file-name name version))
6854          (sha256
6855           (base32
6856            "0z5nypfk26hxihb08p085644afawicrgb4xvadh3lmrn46qbjfn4"))))
6857       (build-system asdf-build-system/sbcl)
6858       (native-inputs
6859        `(("lisp-unit" ,sbcl-lisp-unit)))
6860       (inputs
6861        `(("alexandria" ,sbcl-alexandria)
6862          ("antik-base" ,sbcl-antik-base)
6863          ("cffi" ,sbcl-cffi)
6864          ("gsl" ,gsl)
6865          ("metabang-bind" ,sbcl-metabang-bind)
6866          ("trivial-features" ,sbcl-trivial-features)
6867          ("trivial-garbage" ,sbcl-trivial-garbage)))
6868       (arguments
6869        `(#:tests? #f
6870          #:phases
6871          (modify-phases %standard-phases
6872            (add-after 'unpack 'fix-cffi-paths
6873              (lambda* (#:key inputs #:allow-other-keys)
6874                (substitute* "gsll.asd"
6875                  ((":depends-on \\(#:foreign-array")
6876                   ":depends-on (#:foreign-array #:cffi-libffi"))
6877                (substitute* "init/init.lisp"
6878                  (("libgslcblas.so" all)
6879                   (string-append
6880                    (assoc-ref inputs "gsl") "/lib/" all)))
6881                (substitute* "init/init.lisp"
6882                  (("libgsl.so" all)
6883                   (string-append
6884                    (assoc-ref inputs "gsl") "/lib/" all))))))))
6885       (synopsis "GNU Scientific Library for Lisp")
6886       (description
6887        "The GNU Scientific Library for Lisp (GSLL) allows the use of the
6888 GNU Scientific Library (GSL) from Common Lisp.  This library provides a
6889 full range of common mathematical operations useful to scientific and
6890 engineering applications.  The design of the GSLL interface is such
6891 that access to most of the GSL library is possible in a Lisp-natural
6892 way; the intent is that the user not be hampered by the restrictions
6893 of the C language in which GSL has been written.  GSLL thus provides
6894 interactive use of GSL for getting quick answers, even for someone not
6895 intending to program in Lisp.")
6896       (home-page "https://common-lisp.net/project/gsll/")
6897       (license license:gpl3))))
6898
6899 (define-public cl-gsll
6900   (sbcl-package->cl-source-package sbcl-gsll))
6901
6902 (define-public sbcl-antik
6903   (package
6904     (inherit sbcl-antik-base)
6905     (name "sbcl-antik")
6906     (inputs
6907      `(("antik-base" ,sbcl-antik-base)
6908        ("gsll" ,sbcl-gsll)))
6909     (arguments
6910      '(#:phases
6911          (modify-phases %standard-phases
6912            (add-after 'unpack 'fix-build
6913              (lambda _
6914                (for-each delete-file
6915                          '("antik-base.asd"
6916                            "foreign-array.asd"
6917                            "physical-dimension.asd"
6918                            "science-data.asd"))
6919                #t)))))))
6920
6921 (define-public cl-antik
6922   (sbcl-package->cl-source-package sbcl-antik))
6923
6924 (define-public sbcl-cl-interpol
6925   (let ((commit "1fd288d861db85bc4677cff3cdd6af75fda1afb4")
6926         (revision "1"))
6927     (package
6928       (name "sbcl-cl-interpol")
6929       (version (git-version "0.2.6" revision commit))
6930       (source
6931        (origin
6932          (method git-fetch)
6933          (uri (git-reference
6934                (url "https://github.com/edicl/cl-interpol")
6935                (commit commit)))
6936          (file-name (git-file-name name version))
6937          (sha256
6938           (base32
6939            "1hnikak52hmcq1r5f616m6qq1108qnkw80pja950nv1fq5p0ppjn"))))
6940       (build-system asdf-build-system/sbcl)
6941       (inputs
6942        `(("cl-unicode" ,sbcl-cl-unicode)
6943          ("named-readtables" ,sbcl-named-readtables)))
6944       (native-inputs
6945        `(("flexi-streams" ,sbcl-flexi-streams)))
6946       (synopsis "String interpolation for Common Lisp")
6947       (description
6948        "CL-INTERPOL is a library for Common Lisp which modifies the
6949 reader so that you can have interpolation within strings similar to
6950 Perl or Unix Shell scripts.  It also provides various ways to insert
6951 arbitrary characters into literal strings even if your editor/IDE
6952 doesn't support them.")
6953       (home-page "https://edicl.github.io/cl-interpol/")
6954       (license license:bsd-3))))
6955
6956 (define-public cl-interpol
6957   (sbcl-package->cl-source-package sbcl-cl-interpol))
6958
6959 (define-public ecl-cl-interpol
6960   (sbcl-package->ecl-package sbcl-cl-interpol))
6961
6962 (define-public sbcl-symbol-munger
6963   (let ((commit "97598d4c3c53fd5da72ab78908fbd5d8c7a13416")
6964         (revision "1"))
6965     (package
6966       (name "sbcl-symbol-munger")
6967       (version (git-version "0.0.1" revision commit))
6968       (source
6969        (origin
6970          (method git-fetch)
6971          (uri (git-reference
6972                (url "https://github.com/AccelerationNet/symbol-munger")
6973                (commit commit)))
6974          (file-name (git-file-name name version))
6975          (sha256
6976           (base32
6977            "0y8jywjy0ldyhp7bxf16fdvdd2qgqnd7nlhlqfpfnzxcqk4xy1km"))))
6978       (build-system asdf-build-system/sbcl)
6979       (inputs
6980        `(("alexandria" ,sbcl-alexandria)
6981          ("iterate" ,sbcl-iterate)))
6982       (arguments
6983        ;; There is a cyclical dependency between symbol-munger and lisp-unit2.
6984        ;; See https://github.com/AccelerationNet/symbol-munger/issues/4
6985        '(#:tests? #f))
6986       (synopsis
6987        "Capitalization and spacing conversion functions for Common Lisp")
6988       (description
6989        "This is a Common Lisp library to change the capitalization and spacing
6990 of a string or a symbol.  It can convert to and from Lisp, english, underscore
6991 and camel-case rules.")
6992       (home-page "https://github.com/AccelerationNet/symbol-munger")
6993       ;; The package declares a BSD license, but all of the license
6994       ;; text is MIT.
6995       ;; See https://github.com/AccelerationNet/symbol-munger/issues/5
6996       (license license:expat))))
6997
6998 (define-public cl-symbol-munger
6999   (sbcl-package->cl-source-package sbcl-symbol-munger))
7000
7001 (define-public ecl-symbol-munger
7002   (sbcl-package->ecl-package sbcl-symbol-munger))
7003
7004 (define-public sbcl-lisp-unit2
7005   ;; There is a cyclical dependency between symbol-munger and lisp-unit2.
7006   ;; See https://github.com/AccelerationNet/symbol-munger/issues/4
7007   (let ((commit "fb9721524d1e4e73abb223ee036d74ce14a5505c")
7008         (revision "1"))
7009     (package
7010       (name "sbcl-lisp-unit2")
7011       (version (git-version "0.2.0" revision commit))
7012       (source
7013        (origin
7014          (method git-fetch)
7015          (uri (git-reference
7016                (url "https://github.com/AccelerationNet/lisp-unit2")
7017                (commit commit)))
7018          (file-name (git-file-name name version))
7019          (sha256
7020           (base32
7021            "1rsqy8y0jqll6xn9a593848f5wvd5ribv4csry1ly0hmdhfnqzlp"))))
7022       (build-system asdf-build-system/sbcl)
7023       (inputs
7024        `(("alexandria" ,sbcl-alexandria)
7025          ("cl-interpol" ,sbcl-cl-interpol)
7026          ("iterate" ,sbcl-iterate)
7027          ("symbol-munger" ,sbcl-symbol-munger)))
7028       (synopsis "Test Framework for Common Lisp")
7029       (description
7030        "LISP-UNIT2 is a Common Lisp library that supports unit testing in the
7031 style of JUnit for Java.  It is a new version of the lisp-unit library written
7032 by Chris Riesbeck.")
7033       (home-page "https://github.com/AccelerationNet/lisp-unit2")
7034       (license license:expat))))
7035
7036 (define-public cl-lisp-unit2
7037   (sbcl-package->cl-source-package sbcl-lisp-unit2))
7038
7039 (define-public ecl-lisp-unit2
7040   (sbcl-package->ecl-package sbcl-lisp-unit2))
7041
7042 (define-public sbcl-cl-csv
7043   (let ((commit "3eba29c8364b033fbe0d189c2500559278b6a362")
7044         (revision "1"))
7045     (package
7046       (name "sbcl-cl-csv")
7047       (version (git-version "1.0.6" revision commit))
7048       (source
7049        (origin
7050          (method git-fetch)
7051          (uri (git-reference
7052                (url "https://github.com/AccelerationNet/cl-csv")
7053                (commit commit)))
7054          (file-name (git-file-name name version))
7055          (sha256
7056           (base32
7057            "07h4ni89jzx93clx453hlnnb5g53hhlcmz5hghqv6ysam48lc8g6"))))
7058       (build-system asdf-build-system/sbcl)
7059       (arguments
7060        ;; See: https://github.com/AccelerationNet/cl-csv/pull/34
7061        `(#:tests? #f))
7062       (inputs
7063        `(("alexandria" ,sbcl-alexandria)
7064          ("cl-interpol" ,sbcl-cl-interpol)
7065          ("iterate" ,sbcl-iterate)))
7066       (native-inputs
7067        `(("lisp-unit2" ,sbcl-lisp-unit2)))
7068       (synopsis "Common lisp library for comma-separated values")
7069       (description
7070        "This is a Common Lisp library providing functions to read/write CSV
7071 from/to strings, streams and files.")
7072       (home-page "https://github.com/AccelerationNet/cl-csv")
7073       (license license:bsd-3))))
7074
7075 (define-public cl-csv
7076   (sbcl-package->cl-source-package sbcl-cl-csv))
7077
7078 (define-public ecl-cl-csv
7079   (sbcl-package->ecl-package sbcl-cl-csv))
7080
7081 (define-public sbcl-external-program
7082   (let ((commit "5888b8f1fd3953feeeacecbba4384ddda584a749")
7083         (revision "1"))
7084     (package
7085       (name "sbcl-external-program")
7086       (version (git-version "0.0.6" revision commit))
7087       (source
7088        (origin
7089          (method git-fetch)
7090          (uri (git-reference
7091                (url "https://github.com/sellout/external-program")
7092                (commit commit)))
7093          (file-name (git-file-name name version))
7094          (sha256
7095           (base32
7096            "0vww1x3yilb3bjwg6k184vaj4vxyxw4vralhnlm6lk4xac67kc9z"))))
7097       (build-system asdf-build-system/sbcl)
7098       (inputs
7099        `(("trivial-features" ,sbcl-trivial-features)))
7100       (native-inputs
7101        `(("fiveam" ,sbcl-fiveam)))
7102       (synopsis "Common Lisp library for running external programs")
7103       (description
7104        "EXTERNAL-PROGRAM enables running programs outside the Lisp
7105 process.  It is an attempt to make the RUN-PROGRAM functionality in
7106 implementations like SBCL and CCL as portable as possible without
7107 sacrificing much in the way of power.")
7108       (home-page "https://github.com/sellout/external-program")
7109       (license license:llgpl))))
7110
7111 (define-public cl-external-program
7112   (sbcl-package->cl-source-package sbcl-external-program))
7113
7114 (define-public ecl-external-program
7115   (sbcl-package->ecl-package sbcl-external-program))
7116
7117 (define-public sbcl-cl-ana
7118   (let ((commit "fa7cee4c50aa1c859652813049ba0da7c18a0df9")
7119         (revision "1"))
7120     (package
7121      (name "sbcl-cl-ana")
7122      (version (git-version "0.0.0" revision commit))
7123      (source
7124       (origin
7125        (method git-fetch)
7126        (uri (git-reference
7127              (url "https://github.com/ghollisjr/cl-ana")
7128              (commit commit)))
7129        (file-name (git-file-name name version))
7130        (sha256
7131         (base32 "0mr47l57m276dbpap7irr4fcnk5fgknhf6mgv4043s8h73amk5qh"))))
7132      (build-system asdf-build-system/sbcl)
7133      (native-inputs
7134       `(("cl-fad" ,sbcl-cl-fad)))
7135      (inputs
7136       `(("alexandria" ,sbcl-alexandria)
7137         ("antik" ,sbcl-antik)
7138         ("cffi" ,sbcl-cffi)
7139         ("cl-csv" ,sbcl-cl-csv)
7140         ("closer-mop" ,sbcl-closer-mop)
7141         ("external-program" ,sbcl-external-program)
7142         ("gsl" ,gsl)
7143         ("gsll" ,sbcl-gsll)
7144         ("hdf5" ,hdf5-parallel-openmpi)
7145         ("iterate" ,sbcl-iterate)
7146         ("libffi" ,libffi)
7147         ("split-sequence" ,sbcl-split-sequence)))
7148      (arguments
7149       `(#:phases
7150         (modify-phases %standard-phases
7151           (add-after 'unpack 'fix-paths
7152             (lambda* (#:key inputs #:allow-other-keys)
7153               (substitute* "hdf-cffi/hdf-cffi.lisp"
7154                 (("/usr/lib/i386-linux-gnu/hdf5/serial/libhdf5.so")
7155                  (string-append (assoc-ref inputs "hdf5")
7156                                 "/lib/libhdf5.so")))
7157               (substitute* "gsl-cffi/gsl-cffi.lisp"
7158                 (("define-foreign-library gsl-cffi" all)
7159                  (string-append all " (:unix "
7160                                 (assoc-ref inputs "gsl")
7161                                 "/lib/libgsl.so)")))
7162               #t)))))
7163      (synopsis "Common Lisp data analysis library")
7164      (description
7165       "CL-ANA is a data analysis library in Common Lisp providing tabular and
7166 binned data analysis along with nonlinear least squares fitting and
7167 visualization.")
7168      (home-page "https://github.com/ghollisjr/cl-ana")
7169      (license license:gpl3))))
7170
7171 (define-public cl-ana
7172   (sbcl-package->cl-source-package sbcl-cl-ana))
7173
7174 (define-public sbcl-archive
7175   (let ((commit "631271c091ed02994bec3980cb288a2cf32c7cdc")
7176         (revision "1"))
7177     (package
7178       (name "sbcl-archive")
7179       (version (git-version "0.9" revision commit))
7180       (source (origin
7181                 (method git-fetch)
7182                 (uri (git-reference
7183                       (url "https://github.com/sharplispers/archive")
7184                       (commit commit)))
7185                 (file-name (git-file-name name version))
7186                 (sha256
7187                  (base32
7188                   "0pvsc9fmybx7rxd0kmzq4shi6hszdpwdc1sfy7jwyfxf8n3hnv4p"))))
7189       (build-system asdf-build-system/sbcl)
7190       (inputs
7191        `(("cl-fad" ,sbcl-cl-fad)
7192          ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
7193       (synopsis "Common Lisp library for tar and cpio archives")
7194       (description
7195        "This is a Common Lisp library to read and write disk-based file
7196 archives such as those generated by the tar and cpio programs on Unix.")
7197       (home-page "https://github.com/sharplispers/archive")
7198       (license license:bsd-3))))
7199
7200 (define-public cl-archive
7201   (sbcl-package->cl-source-package sbcl-archive))
7202
7203 (define-public ecl-archive
7204   (sbcl-package->ecl-package sbcl-archive))
7205
7206 (define-public sbcl-misc-extensions
7207   (let ((commit "101c05112bf2f1e1bbf527396822d2f50ca6327a")
7208         (revision "1"))
7209     (package
7210       (name "sbcl-misc-extensions")
7211       (version (git-version "3.3" revision commit))
7212       (source
7213        (origin
7214          (method git-fetch)
7215          (uri (git-reference
7216                (url "https://gitlab.common-lisp.net/misc-extensions/devel.git")
7217                (commit commit)))
7218          (file-name (git-file-name name version))
7219          (sha256
7220           (base32
7221            "0gz5f4p70qzilnxsnf5lih2n9m4wjcw8hlw4w8mpn9jyhyppyyv0"))))
7222       (build-system asdf-build-system/sbcl)
7223       (synopsis "Collection of small macros and extensions for Common Lisp")
7224       (description
7225        "This project is intended as a catchall for small, general-purpose
7226 extensions to Common Lisp.  It contains:
7227
7228 @itemize
7229 @item @code{new-let}, a macro that combines and generalizes @code{let},
7230 @code{let*} and @code{multiple-value-bind},
7231 @item @code{gmap}, an iteration macro that generalizes @code{map}.
7232 @end itemize\n")
7233       (home-page "https://common-lisp.net/project/misc-extensions/")
7234       (license license:public-domain))))
7235
7236 (define-public cl-misc-extensions
7237   (sbcl-package->cl-source-package sbcl-misc-extensions))
7238
7239 (define-public ecl-misc-extensions
7240   (sbcl-package->ecl-package sbcl-misc-extensions))
7241
7242 (define-public sbcl-mt19937
7243   (package
7244     (name "sbcl-mt19937")
7245     (version "1.1")
7246     (source
7247      (origin
7248        (method url-fetch)
7249        (uri (string-append "https://common-lisp.net/project/asdf-packaging/"
7250                            "mt19937-latest.tar.gz"))
7251        (sha256
7252         (base32
7253          "1iw636b0iw5ygkv02y8i41lh7xj0acglv0hg5agryn0zzi2nf1xv"))))
7254     (build-system asdf-build-system/sbcl)
7255     (synopsis "Mersenne Twister pseudo-random number generator")
7256     (description
7257      "MT19937 is a portable Mersenne Twister pseudo-random number generator
7258 for Common Lisp.")
7259     (home-page "https://www.cliki.net/mt19937")
7260     (license license:public-domain)))
7261
7262 (define-public cl-mt19937
7263   (sbcl-package->cl-source-package sbcl-mt19937))
7264
7265 (define-public ecl-mt19937
7266   (sbcl-package->ecl-package sbcl-mt19937))
7267
7268 (define-public sbcl-fset
7269   (let ((commit "6d2f9ded8934d2b42f2571a0ba5bda091037d852")
7270         (revision "1"))
7271     (package
7272       (name "sbcl-fset")
7273       (version (git-version "1.3.2" revision commit))
7274       (source
7275        (origin
7276          (method git-fetch)
7277          (uri (git-reference
7278                (url "https://github.com/slburson/fset")
7279                (commit commit)))
7280          (file-name (git-file-name name version))
7281          (sha256
7282           (base32
7283            "127acblwrbqicx47h6sgvknz1cqyfn8p4xkhkn1m7hxh8w5gk1zy"))
7284          (snippet '(begin
7285                      ;; Remove obsolete copy of system definition.
7286                      (delete-file "Code/fset.asd")
7287                      #t))))
7288       (build-system asdf-build-system/sbcl)
7289       (inputs
7290        `(("misc-extensions" ,sbcl-misc-extensions)
7291          ("mt19937" ,sbcl-mt19937)
7292          ("named-readtables" ,sbcl-named-readtables)))
7293       (synopsis "Functional set-theoretic collections library")
7294       (description
7295        "FSet is a functional set-theoretic collections library for Common Lisp.
7296 Functional means that all update operations return a new collection rather than
7297 modifying an existing one in place.  Set-theoretic means that collections may
7298 be nested arbitrarily with no additional programmer effort; for instance, sets
7299 may contain sets, maps may be keyed by sets, etc.")
7300       (home-page "https://common-lisp.net/project/fset/Site/index.html")
7301       (license license:llgpl))))
7302
7303 (define-public cl-fset
7304   (sbcl-package->cl-source-package sbcl-fset))
7305
7306 (define-public ecl-fset
7307   (package
7308     (inherit (sbcl-package->ecl-package sbcl-fset))
7309     (arguments
7310      ;; Tests fails on ECL with "The function FSET::MAKE-CHAR is undefined".
7311      '(#:tests? #f))))
7312
7313 (define-public sbcl-cl-cont
7314   (let ((commit "fc1fa7e6eb64894fdca13e688e6015fad5290d2a")
7315         (revision "1"))
7316     (package
7317       (name "sbcl-cl-cont")
7318       (version (git-version "0.3.8" revision commit))
7319       (source
7320        (origin
7321          (method git-fetch)
7322          (uri (git-reference
7323                (url "https://gitlab.common-lisp.net/cl-cont/cl-cont.git")
7324                (commit commit)))
7325          (file-name (git-file-name name version))
7326          (sha256
7327           (base32
7328            "1zf8zvb0i6jm3hhfks4w74hibm6avgc6f9s1qwgjrn2bcik8lrvz"))))
7329       (build-system asdf-build-system/sbcl)
7330       (inputs
7331        `(("alexandria" ,sbcl-alexandria)
7332          ("closer-mop" ,sbcl-closer-mop)))
7333       (native-inputs
7334        `(("rt" ,sbcl-rt)))
7335       (synopsis "Delimited continuations for Common Lisp")
7336       (description
7337        "This is a library that implements delimited continuations by
7338 transforming Common Lisp code to continuation passing style.")
7339       (home-page "https://common-lisp.net/project/cl-cont/")
7340       (license license:llgpl))))
7341
7342 (define-public cl-cont
7343   (sbcl-package->cl-source-package sbcl-cl-cont))
7344
7345 (define-public ecl-cl-cont
7346   (sbcl-package->ecl-package sbcl-cl-cont))
7347
7348 (define-public sbcl-cl-coroutine
7349   (let ((commit "de098f8d5debd8b14ef6864b5bdcbbf5ddbcfd72")
7350         (revision "1"))
7351     (package
7352       (name "sbcl-cl-coroutine")
7353       (version (git-version "0.1" revision commit))
7354       (source
7355        (origin
7356          (method git-fetch)
7357          (uri (git-reference
7358                (url "https://github.com/takagi/cl-coroutine")
7359                (commit commit)))
7360          (file-name (git-file-name name version))
7361          (sha256
7362           (base32
7363            "1cqdhdjxffgfs116l1swjlsmcbly0xgcgrckvaajd566idj9yj4l"))))
7364       (build-system asdf-build-system/sbcl)
7365       (inputs
7366        `(("alexandria" ,sbcl-alexandria)
7367          ("cl-cont" ,sbcl-cl-cont)))
7368       (native-inputs
7369        `(("prove" ,sbcl-prove)))
7370       (arguments
7371        `(;; TODO: Fix the tests. They fail with:
7372          ;; "Component CL-COROUTINE-ASD::CL-COROUTINE-TEST not found"
7373          #:tests? #f
7374          #:phases
7375          (modify-phases %standard-phases
7376            (add-after 'unpack 'fix-tests
7377              (lambda _
7378                (substitute* "cl-coroutine-test.asd"
7379                  (("cl-test-more")
7380                   "prove"))
7381                #t)))))
7382       (synopsis "Coroutine library for Common Lisp")
7383       (description
7384        "This is a coroutine library for Common Lisp implemented using the
7385 continuations of the @code{cl-cont} library.")
7386       (home-page "https://github.com/takagi/cl-coroutine")
7387       (license license:llgpl))))
7388
7389 (define-public cl-coroutine
7390   (sbcl-package->cl-source-package sbcl-cl-coroutine))
7391
7392 (define-public ecl-cl-coroutine
7393   (sbcl-package->ecl-package sbcl-cl-coroutine))
7394
7395 (define-public sbcl-vom
7396   (let ((commit "1aeafeb5b74c53741b79497e0ef4acf85c92ff24")
7397         (revision "1"))
7398     (package
7399       (name "sbcl-vom")
7400       (version (git-version "0.1.4" revision commit))
7401       (source
7402        (origin
7403          (method git-fetch)
7404          (uri (git-reference
7405                (url "https://github.com/orthecreedence/vom")
7406                (commit commit)))
7407          (file-name (git-file-name name version))
7408          (sha256
7409           (base32
7410            "0536kppj76ax4lrxhv42npkfjsmx45km2g439vf9jmw3apinz9cy"))))
7411       (build-system asdf-build-system/sbcl)
7412       (synopsis "Tiny logging utility for Common Lisp")
7413       (description
7414        "Vom is a logging library for Common Lisp.  It's goal is to be useful
7415 and small.  It does not provide a lot of features as other loggers do, but
7416 has a small codebase that's easy to understand and use.")
7417       (home-page "https://github.com/orthecreedence/vom")
7418       (license license:expat))))
7419
7420 (define-public cl-vom
7421   (sbcl-package->cl-source-package sbcl-vom))
7422
7423 (define-public ecl-vom
7424   (sbcl-package->ecl-package sbcl-vom))
7425
7426 (define-public sbcl-cl-libuv
7427   (let ((commit "32100c023c518038d0670a103eaa4d50dd785d29")
7428         (revision "1"))
7429     (package
7430       (name "sbcl-cl-libuv")
7431       (version (git-version "0.1.6" revision commit))
7432       (source
7433        (origin
7434          (method git-fetch)
7435          (uri (git-reference
7436                (url "https://github.com/orthecreedence/cl-libuv")
7437                (commit commit)))
7438          (file-name (git-file-name name version))
7439          (sha256
7440           (base32
7441            "1kwix4si8a8hza34ab2k7whrh7z0yrmx39v2wc3qblv9m244jkh1"))))
7442       (build-system asdf-build-system/sbcl)
7443       (inputs
7444        `(("alexandria" ,sbcl-alexandria)
7445          ("cffi" ,sbcl-cffi)
7446          ("libuv" ,libuv)))
7447       (arguments
7448        `(#:phases
7449          (modify-phases %standard-phases
7450            (add-after 'unpack 'fix-paths
7451              (lambda* (#:key inputs #:allow-other-keys)
7452                (substitute* "lib.lisp"
7453                  (("/usr/lib/libuv.so")
7454                   (string-append (assoc-ref inputs "libuv")
7455                                  "/lib/libuv.so")))
7456                #t))
7457            (add-after 'fix-paths 'fix-system-definition
7458              (lambda _
7459                (substitute* "cl-libuv.asd"
7460                  (("#:cffi #:alexandria")
7461                   "#:cffi #:cffi-grovel #:alexandria"))
7462                #t)))))
7463       (synopsis "Common Lisp bindings to libuv")
7464       (description
7465        "This library provides low-level libuv bindings for Common Lisp.")
7466       (home-page "https://github.com/orthecreedence/cl-libuv")
7467       (license license:expat))))
7468
7469 (define-public cl-libuv
7470   (sbcl-package->cl-source-package sbcl-cl-libuv))
7471
7472 (define-public ecl-cl-libuv
7473   (sbcl-package->ecl-package sbcl-cl-libuv))
7474
7475 (define-public sbcl-cl-async
7476   (let ((commit "f6423e44404a44434d803605e0d2e17199158e28")
7477         (revision "1"))
7478     (package
7479       (name "sbcl-cl-async")
7480       (version (git-version "0.6.1" revision commit))
7481       (source
7482        (origin
7483          (method git-fetch)
7484          (uri (git-reference
7485                (url "https://github.com/orthecreedence/cl-async")
7486                (commit commit)))
7487          (file-name (git-file-name name version))
7488          (sha256
7489           (base32
7490            "11xi9dxb8mjgwzrkj88i0xkgk26z9w9ddxzbv6xsvfc1d4x5cf4x"))))
7491       (build-system asdf-build-system/sbcl)
7492       (inputs
7493        `(("babel" ,sbcl-babel)
7494          ("bordeaux-threads" ,sbcl-bordeaux-threads)
7495          ("cffi" ,sbcl-cffi)
7496          ("cl-libuv" ,sbcl-cl-libuv)
7497          ("cl-ppcre" ,sbcl-cl-ppcre)
7498          ("fast-io" ,sbcl-fast-io)
7499          ("openssl" ,openssl)
7500          ("static-vectors" ,sbcl-static-vectors)
7501          ("trivial-features" ,sbcl-trivial-features)
7502          ("trivial-gray-streams" ,sbcl-trivial-gray-streams)
7503          ("vom" ,sbcl-vom)))
7504       (arguments
7505        `(#:asd-systems '("cl-async"
7506                          "cl-async-repl"
7507                          "cl-async-ssl")
7508          #:phases
7509          (modify-phases %standard-phases
7510            (add-after 'unpack 'fix-paths
7511              (lambda* (#:key inputs #:allow-other-keys)
7512                (substitute* "src/ssl/package.lisp"
7513                  (("libcrypto\\.so")
7514                   (string-append (assoc-ref inputs "openssl")
7515                                  "/lib/libcrypto.so"))
7516                  (("libssl\\.so")
7517                   (string-append (assoc-ref inputs "openssl")
7518                                  "/lib/libssl.so")))
7519                #t)))))
7520       (synopsis "Asynchronous operations for Common Lisp")
7521       (description
7522        "Cl-async is a library for general purpose, non-blocking programming in
7523 Common Lisp.  It uses the libuv library as backend.")
7524       (home-page "https://orthecreedence.github.io/cl-async/")
7525       (license license:expat))))
7526
7527 (define-public cl-async
7528   (sbcl-package->cl-source-package sbcl-cl-async))
7529
7530 (define-public ecl-cl-async
7531   (sbcl-package->ecl-package sbcl-cl-async))
7532
7533 (define-public sbcl-blackbird
7534   (let ((commit "d361f81c1411dec07f6c2dcb11c78f7aea9aaca8")
7535         (revision "1"))
7536     (package
7537       (name "sbcl-blackbird")
7538       (version (git-version "0.5.2" revision commit))
7539       (source
7540        (origin
7541          (method git-fetch)
7542          (uri (git-reference
7543                (url "https://github.com/orthecreedence/blackbird")
7544                (commit commit)))
7545          (file-name (git-file-name name version))
7546          (sha256
7547           (base32
7548            "0xfds5yaya64arzr7w1x38karyz11swzbhxx1afldpradj9dh19c"))))
7549       (build-system asdf-build-system/sbcl)
7550       (inputs
7551        `(("vom" ,sbcl-vom)))
7552       (native-inputs
7553        `(("cl-async" ,sbcl-cl-async)
7554          ("fiveam" ,sbcl-fiveam)))
7555       (synopsis "Promise implementation for Common Lisp")
7556       (description
7557        "This is a standalone promise implementation for Common Lisp.  It is
7558 the successor to the now-deprecated cl-async-future project.")
7559       (home-page "https://orthecreedence.github.io/blackbird/")
7560       (license license:expat))))
7561
7562 (define-public cl-blackbird
7563   (sbcl-package->cl-source-package sbcl-blackbird))
7564
7565 (define-public ecl-blackbird
7566   (sbcl-package->ecl-package sbcl-blackbird))
7567
7568 (define-public sbcl-cl-async-future
7569   (let ((commit "ee36c22a69a9516407458d2ed8b475f1fc473959")
7570         (revision "1"))
7571     (package
7572       (name "sbcl-cl-async-future")
7573       (version (git-version "0.4.4.1" revision commit))
7574       (source
7575        (origin
7576          (method git-fetch)
7577          (uri (git-reference
7578                (url "https://github.com/orthecreedence/cl-async-future")
7579                (commit commit)))
7580          (file-name (git-file-name name version))
7581          (sha256
7582           (base32
7583            "0z0sc7qlzzxk99f4l26zp6rai9kv0kj0f599sxai5s44p17zbbvh"))))
7584       (build-system asdf-build-system/sbcl)
7585       (inputs
7586        `(("blackbird" ,sbcl-blackbird)))
7587       (native-inputs
7588        `(("cl-async" ,sbcl-cl-async)
7589          ("eos" ,sbcl-eos)))
7590       (synopsis "Futures implementation for Common Lisp")
7591       (description
7592        "This is futures implementation for Common Lisp.  It plugs in nicely
7593 to cl-async.")
7594       (home-page "https://orthecreedence.github.io/cl-async/future")
7595       (license license:expat))))
7596
7597 (define-public cl-async-future
7598   (sbcl-package->cl-source-package sbcl-cl-async-future))
7599
7600 (define-public ecl-cl-async-future
7601   (sbcl-package->ecl-package sbcl-cl-async-future))
7602
7603 (define-public sbcl-green-threads
7604   (let ((commit "fff5ebecb441a37e5c511773716aafd84a3c5840")
7605         (revision "1"))
7606     (package
7607       (name "sbcl-green-threads")
7608       (version (git-version "0.3" revision commit))
7609       (source
7610        (origin
7611          (method git-fetch)
7612          (uri (git-reference
7613                (url "https://github.com/thezerobit/green-threads")
7614                (commit commit)))
7615          (file-name (git-file-name name version))
7616          (sha256
7617           (base32
7618            "1czw7nr0dwfps76h8hjvglk1wdh53yqbfbvv30whwbgqx33iippz"))))
7619       (build-system asdf-build-system/sbcl)
7620       (inputs
7621        `(("cl-async-future" ,sbcl-cl-async-future)
7622          ("cl-cont" ,sbcl-cl-cont)))
7623       (native-inputs
7624        `(("prove" ,sbcl-prove)))
7625       (arguments
7626        `(;; TODO: Fix the tests. They fail with:
7627          ;; "The function BLACKBIRD::PROMISE-VALUES is undefined"
7628          #:tests? #f
7629          #:phases
7630          (modify-phases %standard-phases
7631            (add-after 'unpack 'fix-tests
7632              (lambda _
7633                (substitute* "green-threads-test.asd"
7634                  (("cl-test-more")
7635                   "prove"))
7636                #t)))))
7637       (synopsis "Cooperative multitasking library for Common Lisp")
7638       (description
7639        "This library allows for cooperative multitasking with help of cl-cont
7640 for continuations.  It tries to mimic the API of bordeaux-threads as much as
7641 possible.")
7642       (home-page "https://github.com/thezerobit/green-threads")
7643       (license license:bsd-3))))
7644
7645 (define-public cl-green-threads
7646   (sbcl-package->cl-source-package sbcl-green-threads))
7647
7648 (define-public ecl-green-threads
7649   (sbcl-package->ecl-package sbcl-green-threads))
7650
7651 (define-public sbcl-cl-base32
7652   (let ((commit "8cdee06fab397f7b0a19583b57e7f0c98405be85")
7653         (revision "1"))
7654     (package
7655       (name "sbcl-cl-base32")
7656       (version (git-version "0.1" revision commit))
7657       (source
7658        (origin
7659          (method git-fetch)
7660          (uri (git-reference
7661                (url "https://github.com/hargettp/cl-base32")
7662                (commit commit)))
7663          (file-name (git-file-name name version))
7664          (sha256
7665           (base32 "17jrng8jb05d64ggyd11hp308c2fl5drvf9g175blgrkkl8l4mf8"))))
7666       (build-system asdf-build-system/sbcl)
7667       (native-inputs
7668        `(("lisp-unit" ,sbcl-lisp-unit)))
7669       (synopsis "Common Lisp library for base32 encoding and decoding")
7670       (description
7671        "This package provides functions for base32 encoding and decoding as
7672 defined in RFC4648.")
7673       (home-page "https://github.com/hargettp/cl-base32")
7674       (license license:expat))))
7675
7676 (define-public cl-base32
7677   (sbcl-package->cl-source-package sbcl-cl-base32))
7678
7679 (define-public ecl-cl-base32
7680   (sbcl-package->ecl-package sbcl-cl-base32))
7681
7682 (define-public sbcl-cl-z85
7683   (let ((commit "85b3951a9cfa2603acb6aee15567684f9a108098")
7684         (revision "1"))
7685     (package
7686       (name "sbcl-cl-z85")
7687       (version (git-version "1.0" revision commit))
7688       (source
7689        (origin
7690          (method git-fetch)
7691          (uri (git-reference
7692                (url "https://github.com/glv2/cl-z85")
7693                (commit commit)))
7694          (file-name (git-file-name name version))
7695          (sha256
7696           (base32 "0r27pidjaxbm7k1rr90nnajwl5xm2kp65g1fv0fva17lzy45z1mp"))))
7697       (build-system asdf-build-system/sbcl)
7698       (native-inputs
7699        `(("cl-octet-streams" ,sbcl-cl-octet-streams)
7700          ("fiveam" ,sbcl-fiveam)))
7701       (synopsis "Common Lisp library for Z85 encoding and decoding")
7702       (description
7703        "This package provides functions to encode or decode byte vectors or
7704 byte streams using the Z85 format, which is a base-85 encoding used by
7705 ZeroMQ.")
7706       (home-page "https://github.com/glv2/cl-z85")
7707       (license license:gpl3+))))
7708
7709 (define-public cl-z85
7710   (sbcl-package->cl-source-package sbcl-cl-z85))
7711
7712 (define-public ecl-cl-z85
7713   (sbcl-package->ecl-package sbcl-cl-z85))
7714
7715 (define-public sbcl-ltk
7716   (package
7717     (name "sbcl-ltk")
7718     (version "0.992")
7719     (source
7720      (origin
7721        (method git-fetch)
7722        (uri (git-reference
7723              (url "https://github.com/herth/ltk")
7724              (commit version)))
7725        (file-name (git-file-name name version))
7726        (sha256
7727         (base32 "13l2q4mskzilya9xh5wy2xvy30lwn104bd8wrq6ifds56r82iy3x"))))
7728     (build-system asdf-build-system/sbcl)
7729     (inputs
7730      `(("imagemagick" ,imagemagick)
7731        ("tk" ,tk)))
7732     (arguments
7733      `(#:asd-systems '("ltk"
7734                        "ltk-mw"
7735                        "ltk-remote")
7736        #:tests? #f
7737        #:phases
7738        (modify-phases %standard-phases
7739          (add-after 'unpack 'fix-paths
7740            (lambda* (#:key inputs #:allow-other-keys)
7741              (substitute* "ltk/ltk.lisp"
7742                (("#-freebsd \"wish\"")
7743                 (string-append "#-freebsd \""
7744                                (assoc-ref inputs "tk")
7745                                "/bin/wish\""))
7746                (("do-execute \"convert\"")
7747                 (string-append "do-execute \""
7748                                (assoc-ref inputs "imagemagick")
7749                                "/bin/convert\"")))
7750              #t))
7751          (add-after 'unpack 'fix-build
7752            (lambda _
7753              (substitute* "ltk/ltk-remote.lisp"
7754                (("\\(:export")
7755                 "(:shadow #:raise) (:export"))
7756              #t)))))
7757     (synopsis "Common Lisp bindings for the Tk GUI toolkit")
7758     (description
7759      "LTK is a Common Lisp binding for the Tk graphics toolkit.  It is written
7760 in pure Common Lisp and does not require any Tk knowledge for its usage.")
7761     (home-page "http://www.peter-herth.de/ltk/")
7762     (license license:llgpl)))
7763
7764 (define-public cl-ltk
7765   (sbcl-package->cl-source-package sbcl-ltk))
7766
7767 (define-public ecl-ltk
7768   (sbcl-package->ecl-package sbcl-ltk))
7769
7770 (define-public sbcl-cl-lex
7771   (let ((commit "f2dbbe25ef553005fb402d9a6203180c3fa1093b")
7772         (revision "1"))
7773     (package
7774       (name "sbcl-cl-lex")
7775       (version (git-version "1.1.3" revision commit))
7776       (source
7777        (origin
7778          (method git-fetch)
7779          (uri (git-reference
7780                (url "https://github.com/djr7C4/cl-lex")
7781                (commit commit)))
7782          (file-name (git-file-name name version))
7783          (sha256
7784           (base32 "1kg50f76bfpfxcv4dfivq1n9a0xlsra2ajb0vd68lxwgbidgyc2y"))))
7785       (build-system asdf-build-system/sbcl)
7786       (inputs
7787        `(("cl-ppcre" ,sbcl-cl-ppcre)))
7788       (synopsis "Common Lisp macros for generating lexical analyzers")
7789       (description
7790        "This is a Common Lisp library providing a set of macros for generating
7791 lexical analyzers automatically.  The lexers generated using @code{cl-lex} can
7792 be used with @code{cl-yacc}.")
7793       (home-page "https://github.com/djr7C4/cl-lex")
7794       (license license:gpl3))))
7795
7796 (define-public cl-lex
7797   (sbcl-package->cl-source-package sbcl-cl-lex))
7798
7799 (define-public ecl-cl-lex
7800   (sbcl-package->ecl-package sbcl-cl-lex))
7801
7802 (define-public sbcl-clunit2
7803   (let ((commit "5e28343734eb9b7aee39306a614af92c1062d50b")
7804         (revision "1"))
7805     (package
7806       (name "sbcl-clunit2")
7807       (version (git-version "0.2.4" revision commit))
7808       (source
7809        (origin
7810          (method git-fetch)
7811          (uri (git-reference
7812                (url "https://notabug.org/cage/clunit2.git")
7813                (commit commit)))
7814          (file-name (git-file-name name version))
7815          (sha256
7816           (base32 "1ngiapfki6nm8a555mzhb5p7ch79i3w665za5bmb5j7q34fy80vw"))))
7817       (build-system asdf-build-system/sbcl)
7818       (synopsis "Unit testing framework for Common Lisp")
7819       (description
7820        "CLUnit is a Common Lisp unit testing framework.  It is designed to be
7821 easy to use so that you can quickly start testing.")
7822       (home-page "https://notabug.org/cage/clunit2")
7823       (license license:expat))))
7824
7825 (define-public cl-clunit2
7826   (sbcl-package->cl-source-package sbcl-clunit2))
7827
7828 (define-public ecl-clunit2
7829   (sbcl-package->ecl-package sbcl-clunit2))
7830
7831 (define-public sbcl-cl-colors2
7832   (let ((commit "795aedee593b095fecde574bd999b520dd03ed24")
7833         (revision "1"))
7834     (package
7835       (name "sbcl-cl-colors2")
7836       (version (git-version "0.2.1" revision commit))
7837       (source
7838        (origin
7839          (method git-fetch)
7840          (uri (git-reference
7841                (url "https://notabug.org/cage/cl-colors2.git")
7842                (commit commit)))
7843          (file-name (git-file-name name version))
7844          (sha256
7845           (base32 "0hlyf4h5chkjdp9armla5w4kw5acikk159sym7y8c4jbjp9x47ih"))))
7846       (build-system asdf-build-system/sbcl)
7847       (native-inputs
7848        `(("clunit2" ,sbcl-clunit2)))
7849       (inputs
7850        `(("alexandria" ,sbcl-alexandria)
7851          ("cl-ppcre" ,sbcl-cl-ppcre)))
7852       (synopsis "Color library for Common Lisp")
7853       (description
7854        "This is a very simple color library for Common Lisp, providing:
7855
7856 @itemize
7857 @item Types for representing colors in HSV and RGB spaces.
7858 @item Simple conversion functions between the above types (and also
7859 hexadecimal representation for RGB).
7860 @item Some predefined colors (currently X11 color names -- of course
7861 the library does not depend on X11).
7862 @end itemize\n")
7863       (home-page "https://notabug.org/cage/cl-colors2")
7864       (license license:boost1.0))))
7865
7866 (define-public cl-colors2
7867   (sbcl-package->cl-source-package sbcl-cl-colors2))
7868
7869 (define-public ecl-cl-colors2
7870   (sbcl-package->ecl-package sbcl-cl-colors2))
7871
7872 (define-public sbcl-cl-jpeg
7873   (let ((commit "ec557038128df6895fbfb743bfe8faf8ec2534af")
7874         (revision "1"))
7875     (package
7876       (name "sbcl-cl-jpeg")
7877       (version (git-version "2.8" revision commit))
7878       (source
7879        (origin
7880          (method git-fetch)
7881          (uri (git-reference
7882                (url "https://github.com/sharplispers/cl-jpeg")
7883                (commit commit)))
7884          (file-name (git-file-name name version))
7885          (sha256
7886           (base32 "1bkkiqz8fqldlj1wbmrccjsvxcwj98h6s4b6gslr3cg2wmdv5xmy"))))
7887       (build-system asdf-build-system/sbcl)
7888       (synopsis "JPEG image library for Common Lisp")
7889       (description
7890        "This is a baseline JPEG codec written in Common Lisp.  It can be used
7891 for reading and writing JPEG image files.")
7892       (home-page "https://github.com/sharplispers/cl-jpeg")
7893       (license license:bsd-3))))
7894
7895 (define-public cl-jpeg
7896   (sbcl-package->cl-source-package sbcl-cl-jpeg))
7897
7898 (define-public ecl-cl-jpeg
7899   (sbcl-package->ecl-package sbcl-cl-jpeg))
7900
7901 (define-public sbcl-nodgui
7902   (let ((commit "bc59ed9b787dfc9e68ae3bd7f7e8507c5c619212")
7903         (revision "1"))
7904     (package
7905       (name "sbcl-nodgui")
7906       (version (git-version "0.0.5" revision commit))
7907       (source
7908        (origin
7909          (method git-fetch)
7910          (uri (git-reference
7911                (url "https://notabug.org/cage/nodgui.git")
7912                (commit commit)))
7913          (file-name (git-file-name name version))
7914          (sha256
7915           (base32 "0xx0dk54d882i598ydnwmy7mnfk0b7vib3ddsgpqxhjck1rwq8l8"))))
7916       (build-system asdf-build-system/sbcl)
7917       (inputs
7918        `(("alexandria" ,sbcl-alexandria)
7919          ("bordeaux-threads" ,sbcl-bordeaux-threads)
7920          ("cl-colors2" ,sbcl-cl-colors2)
7921          ("cl-jpeg" ,sbcl-cl-jpeg)
7922          ("cl-lex" ,sbcl-cl-lex)
7923          ("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)
7924          ("cl-unicode" ,sbcl-cl-unicode)
7925          ("cl-yacc" ,sbcl-cl-yacc)
7926          ("clunit2" ,sbcl-clunit2)
7927          ("named-readtables" ,sbcl-named-readtables)
7928          ("parse-number" ,sbcl-parse-number)
7929          ("tk" ,tk)))
7930       (arguments
7931        `(#:phases (modify-phases %standard-phases
7932                     (add-after 'unpack 'fix-paths
7933                       (lambda* (#:key inputs #:allow-other-keys)
7934                         (substitute* "src/wish-communication.lisp"
7935                           (("#-freebsd \"wish\"")
7936                            (string-append "#-freebsd \""
7937                                           (assoc-ref inputs "tk")
7938                                           "/bin/wish\"")))
7939                         #t)))))
7940       (synopsis "Common Lisp bindings for the Tk GUI toolkit")
7941       (description
7942        "Nodgui (@emph{No Drama GUI}) is a Common Lisp binding for the Tk GUI
7943 toolkit.  It also provides a few additional widgets more than the standard Tk
7944 ones.")
7945       (home-page "https://www.autistici.org/interzona/nodgui.html")
7946       (license license:llgpl))))
7947
7948 (define-public cl-nodgui
7949   (sbcl-package->cl-source-package sbcl-nodgui))
7950
7951 (define-public ecl-nodgui
7952   (sbcl-package->ecl-package sbcl-nodgui))
7953
7954 (define-public sbcl-salza2
7955   (package
7956     (name "sbcl-salza2")
7957     (version "2.0.9")
7958     (source
7959      (origin
7960        (method git-fetch)
7961        (uri (git-reference
7962              (url "https://github.com/xach/salza2")
7963              (commit (string-append "release-" version))))
7964        (file-name (git-file-name name version))
7965        (sha256
7966         (base32 "0p38rj4gq7j5k807php7hrz7l2zyyfshv8i9yms7i8lkgg3433ki"))))
7967     (build-system asdf-build-system/sbcl)
7968     (synopsis "Common Lisp library for zlib, deflate and gzip compression")
7969     (description
7970      "Salza2 is a Common Lisp library for creating compressed data in the zlib,
7971 deflate, or gzip data formats, described in RFC 1950, RFC 1951, and RFC 1952,
7972 respectively.")
7973     (home-page "https://www.xach.com/lisp/salza2/")
7974     (license license:bsd-2)))
7975
7976 (define-public cl-salza2
7977   (sbcl-package->cl-source-package sbcl-salza2))
7978
7979 (define-public ecl-salza2
7980   (sbcl-package->ecl-package sbcl-salza2))
7981
7982 (define-public sbcl-png-read
7983   (let ((commit "ec29f38a689972b9f1373f13bbbcd6b05deada88")
7984         (revision "1"))
7985     (package
7986       (name "sbcl-png-read")
7987       (version (git-version "0.3.1" revision commit))
7988       (source
7989        (origin
7990          (method git-fetch)
7991          (uri (git-reference
7992                (url "https://github.com/Ramarren/png-read")
7993                (commit commit)))
7994          (file-name (git-file-name name version))
7995          (sha256
7996           (base32 "0vyczbcwskrygrf1hgrsnk0jil8skmvf1kiaalw5jps4fjrfdkw0"))))
7997       (build-system asdf-build-system/sbcl)
7998       (inputs
7999        `(("babel" ,sbcl-babel)
8000          ("chipz" ,sbcl-chipz)
8001          ("iterate" ,sbcl-iterate)))
8002       (synopsis "PNG decoder for Common Lisp")
8003       (description "This is a Common Lisp library for reading PNG images.")
8004       (home-page "https://github.com/Ramarren/png-read")
8005       (license license:bsd-3))))
8006
8007 (define-public cl-png-read
8008   (sbcl-package->cl-source-package sbcl-png-read))
8009
8010 (define-public ecl-png-read
8011   (sbcl-package->ecl-package sbcl-png-read))
8012
8013 (define-public sbcl-zpng
8014   (package
8015     (name "sbcl-zpng")
8016     (version "1.2.2")
8017     (source
8018      (origin
8019        (method git-fetch)
8020        (uri (git-reference
8021              (url "https://github.com/xach/zpng")
8022              (commit (string-append "release-" version))))
8023        (file-name (git-file-name name version))
8024        (sha256
8025         (base32 "0b3ag3jhl3z7kdls3ahdsdxsfhhw5qrizk769984f4wkxhb69rcm"))))
8026     (build-system asdf-build-system/sbcl)
8027     (inputs
8028      `(("salza2" ,sbcl-salza2)))
8029     (synopsis "PNG encoder for Common Lisp")
8030     (description "This is a Common Lisp library for creating PNG images.")
8031     (home-page "https://www.xach.com/lisp/zpng/")
8032     (license license:bsd-2)))
8033
8034 (define-public cl-zpng
8035   (sbcl-package->cl-source-package sbcl-zpng))
8036
8037 (define-public ecl-zpng
8038   (sbcl-package->ecl-package sbcl-zpng))
8039
8040 (define-public sbcl-cl-qrencode
8041   (package
8042     (name "sbcl-cl-qrencode")
8043     (version "0.1.2")
8044     (source
8045      (origin
8046        (method git-fetch)
8047        (uri (git-reference
8048              (url "https://github.com/jnjcc/cl-qrencode")
8049              (commit (string-append "v" version))))
8050        (file-name (git-file-name name version))
8051        (sha256
8052         (base32 "1l5k131dchbf6cj8a8xqa731790p01p3qa1kdy2wa9dawy3ymkxr"))))
8053     (build-system asdf-build-system/sbcl)
8054     (native-inputs
8055      `(("lisp-unit" ,sbcl-lisp-unit)))
8056     (inputs
8057      `(("zpng" ,sbcl-zpng)))
8058     (synopsis "QR code encoder for Common Lisp")
8059     (description
8060      "This Common Lisp library provides function to make QR codes and to save
8061 them as PNG files.")
8062     (home-page "https://github.com/jnjcc/cl-qrencode")
8063     (license license:gpl2+)))
8064
8065 (define-public cl-qrencode
8066   (sbcl-package->cl-source-package sbcl-cl-qrencode))
8067
8068 (define-public ecl-cl-qrencode
8069   (sbcl-package->ecl-package sbcl-cl-qrencode))
8070
8071 (define-public sbcl-hdf5-cffi
8072   (let ((commit "5b5c88f191e470e4fe96b462334e3ce0806eed5c")
8073         (revision "1"))
8074     (package
8075       (name "sbcl-hdf5-cffi")
8076       (version (git-version "1.8.18" revision commit))
8077       (source
8078        (origin
8079          (method git-fetch)
8080          (uri (git-reference
8081                (url "https://github.com/hdfgroup/hdf5-cffi")
8082                (commit commit)))
8083          (file-name (git-file-name name version))
8084          (sha256
8085           (base32
8086            "0vda3075423xz83qky998lpac5b04dwfv7bwgh9jq8cs5v0zrxjf"))))
8087       (build-system asdf-build-system/sbcl)
8088       (synopsis "Common Lisp bindings for the HDF5 library")
8089       (description
8090        "@code{hdf5-cffi} is a CFFI wrapper for the HDF5 library.")
8091       (home-page "https://github.com/hdfgroup/hdf5-cffi")
8092       (license (license:non-copyleft
8093                 (string-append "https://github.com/HDFGroup/hdf5-cffi/raw/"
8094                                commit
8095                                "/LICENSE")))
8096       (inputs
8097        `(("cffi" ,sbcl-cffi)
8098          ("hdf5" ,hdf5-1.10)))
8099       (native-inputs
8100        `(("fiveam" ,sbcl-fiveam)))
8101       (arguments
8102        `(#:test-asd-file "hdf5-cffi.test.asd"
8103          ;; Tests depend on hdf5-cffi.examples.asd in addition to hdf5-cffi.asd,
8104          ;; I don't know if there is a way to tell asdf-build-system to load
8105          ;; an additional system first, so tests are disabled.
8106          #:tests? #f
8107          #:phases
8108          (modify-phases %standard-phases
8109            (add-after 'unpack 'fix-paths
8110              (lambda* (#:key inputs #:allow-other-keys)
8111                (substitute* "src/library.lisp"
8112                  (("libhdf5.so")
8113                   (string-append
8114                    (assoc-ref inputs "hdf5")
8115                    "/lib/libhdf5.so")))))
8116            (add-after 'unpack 'fix-dependencies
8117              (lambda* (#:key inputs #:allow-other-keys)
8118                (substitute* "hdf5-cffi.asd"
8119                  ((":depends-on \\(:cffi\\)")
8120                   ":depends-on (:cffi :cffi-grovel)"))
8121                (substitute* "hdf5-cffi.test.asd"
8122                  ((":depends-on \\(:cffi :hdf5-cffi")
8123                   ":depends-on (:cffi :cffi-grovel :hdf5-cffi"))))))))))
8124
8125 (define-public cl-hdf5-cffi
8126   (sbcl-package->cl-source-package sbcl-hdf5-cffi))
8127
8128 (define-public ecl-hdf5-cffi
8129   (sbcl-package->ecl-package sbcl-hdf5-cffi))
8130
8131 (define-public sbcl-cl-randist
8132   (package
8133     (name "sbcl-cl-randist")
8134     (version "0.4.2")
8135     (source
8136      (origin
8137        (method git-fetch)
8138        (uri (git-reference
8139              (url "https://github.com/lvaruzza/cl-randist")
8140              (commit "f088a54b540a7adefab7c04094a6103f9edda3d0")))
8141        (file-name (git-file-name name version))
8142        (sha256
8143         (base32
8144          "0l8hyd6nbxb7f50vyxz3rbbm7kgr1fnadc40jywy4xj5vi5kpj5g"))))
8145     (build-system asdf-build-system/sbcl)
8146     (synopsis "Random distributions for Common Lisp")
8147     (description
8148      "Manual translation from C to Common Lisp of some random number
8149 generation functions from the GSL library.")
8150     (home-page "https://github.com/lvaruzza/cl-randist")
8151     (license license:bsd-2)
8152     (arguments
8153      `(#:tests? #f))))
8154
8155 (define-public cl-randist
8156   (sbcl-package->cl-source-package sbcl-cl-randist))
8157
8158 (define-public ecl-cl-randist
8159   (sbcl-package->ecl-package sbcl-cl-randist))
8160
8161 (define-public sbcl-float-features
8162   (package
8163     (name "sbcl-float-features")
8164     (version "1.0.0")
8165     (source
8166      (origin
8167        (method git-fetch)
8168        (uri (git-reference
8169              (url "https://github.com/Shinmera/float-features")
8170              (commit "d3ef60181635b0849aa28cfc238053b7ca4644b0")))
8171        (file-name (git-file-name name version))
8172        (sha256
8173         (base32
8174          "0yj419k7n59x6rh3grwr6frgwwyria2il6f7wxpfazm8cskv4lzr"))))
8175     (build-system asdf-build-system/sbcl)
8176     (synopsis "Common Lisp IEEE float portability library")
8177     (description
8178      "Portability library for IEEE float features that are not
8179 covered by the Common Lisp standard.")
8180     (home-page "https://github.com/Shinmera/float-features")
8181     (license license:zlib)
8182     (inputs
8183      `(("documentation-utils" ,sbcl-documentation-utils)))
8184     (arguments
8185      `(#:tests? #f))))
8186
8187 (define-public cl-float-features
8188   (sbcl-package->cl-source-package sbcl-float-features))
8189
8190 (define-public ecl-float-features
8191   (sbcl-package->ecl-package sbcl-float-features))
8192
8193 (define-public sbcl-function-cache
8194   (package
8195     (name "sbcl-function-cache")
8196     (version "1.0.3")
8197     (source
8198      (origin
8199        (method git-fetch)
8200        (uri (git-reference
8201              (url "https://github.com/AccelerationNet/function-cache")
8202              (commit "6a5ada401e57da2c8abf046f582029926e61fce8")))
8203        (file-name (git-file-name name version))
8204        (sha256
8205         (base32
8206          "000vmd3f5rx5hs9nvphfric0gkzaadns31c6mxaslpv0k7pkrmc6"))))
8207     (build-system asdf-build-system/sbcl)
8208     (synopsis "Function caching / memoization library for Common Lisp")
8209     (description
8210      "A common lisp library that provides extensible function result
8211 caching based on arguments (an expanded form of memoization).")
8212     (home-page "https://github.com/AccelerationNet/function-cache")
8213     (license
8214      (license:non-copyleft
8215       "https://github.com/AccelerationNet/function-cache/blob/master/README.md"))
8216     (inputs
8217      `(("alexandria" ,sbcl-alexandria)
8218        ("cl-interpol" ,sbcl-cl-interpol)
8219        ("iterate" ,sbcl-iterate)
8220        ("symbol-munger" ,sbcl-symbol-munger)
8221        ("closer-mop" ,sbcl-closer-mop)))
8222     (arguments
8223      `(#:tests? #f))))
8224
8225 (define-public cl-function-cache
8226   (sbcl-package->cl-source-package sbcl-function-cache))
8227
8228 (define-public ecl-function-cache
8229   (sbcl-package->ecl-package sbcl-function-cache))
8230
8231 (define-public sbcl-type-r
8232   (let ((commit "83c89e38f2f7a7b16f1012777ecaf878cfa6a267")
8233         (revision "1"))
8234     (package
8235       (name "sbcl-type-r")
8236       (version (git-version "0.0.0" revision commit))
8237       (source
8238        (origin
8239          (method git-fetch)
8240          (uri (git-reference
8241                (url "https://github.com/guicho271828/type-r")
8242                (commit commit)))
8243          (file-name (git-file-name name version))
8244          (sha256
8245           (base32
8246            "1arsxc2539rg8vbrdirz4xxj1b06mc6g6rqndz7a02g127qvk2sm"))))
8247       (build-system asdf-build-system/sbcl)
8248       (synopsis "Parser interface for Common Lisp built-in compound types")
8249       (description
8250        "Collections of accessor functions and patterns to access
8251 the elements in compound type specifier, e.g. @code{dimensions} in
8252 @code{(array element-type dimensions)}")
8253       (home-page "https://github.com/guicho271828/type-r")
8254       (license license:lgpl3+)
8255       (inputs
8256        `(("trivia" ,sbcl-trivia)
8257          ("alexandria" ,sbcl-alexandria)))
8258       (native-inputs
8259        `(("fiveam" ,sbcl-fiveam)))
8260       (arguments
8261        `(#:test-asd-file "type-r.test.asd")))))
8262
8263 (define-public cl-type-r
8264   (sbcl-package->cl-source-package sbcl-type-r))
8265
8266 (define-public ecl-type-r
8267   (sbcl-package->ecl-package sbcl-type-r))
8268
8269 (define-public sbcl-trivialib-type-unify
8270   (let ((commit "62492ebf04db567dcf435ae84c50b7b8202ecf99")
8271         (revision "1"))
8272     (package
8273       (name "sbcl-trivialib-type-unify")
8274       (version (git-version "0.1" revision commit))
8275       (source
8276        (origin
8277          (method git-fetch)
8278          (uri (git-reference
8279                (url "https://github.com/guicho271828/trivialib.type-unify")
8280                (commit commit)))
8281          (file-name (git-file-name name version))
8282          (sha256
8283           (base32
8284            "1bkyfzbwv75p50zp8n1n9rh2r29pw3vgz91gmn2gzzkyq3khj1vh"))))
8285       (build-system asdf-build-system/sbcl)
8286       (synopsis "Common Lisp type unification")
8287       (description
8288        "Unifies a parametrized type specifier against an actual type specifier.
8289 Importantly, it handles complicated array-subtypes and number-related types
8290 correctly.")
8291       (home-page "https://github.com/guicho271828/trivialib.type-unify")
8292       (license license:lgpl3+)
8293       (inputs
8294        `(("alexandria" ,sbcl-alexandria)
8295          ("trivia" ,sbcl-trivia)
8296          ("introspect-environment" ,sbcl-introspect-environment)
8297          ("type-r" ,sbcl-type-r)))
8298       (native-inputs
8299        `(("fiveam" ,sbcl-fiveam)))
8300       (arguments
8301        `(#:asd-systems '("trivialib.type-unify")
8302          #:test-asd-file "trivialib.type-unify.test.asd")))))
8303
8304 (define-public cl-trivialib-type-unify
8305   (sbcl-package->cl-source-package sbcl-trivialib-type-unify))
8306
8307 (define-public ecl-trivialib-type-unify
8308   (sbcl-package->ecl-package sbcl-trivialib-type-unify))
8309
8310 (define-public sbcl-specialized-function
8311   (let ((commit "b96b6afaf8358bf91cc0703e62a5a4ee20d2b7bc")
8312         (revision "1"))
8313     (package
8314       (name "sbcl-specialized-function")
8315       (version (git-version "0.0.0" revision commit))
8316       (source
8317        (origin
8318          (method git-fetch)
8319          (uri (git-reference
8320                (url "https://github.com/numcl/specialized-function")
8321                (commit commit)))
8322          (file-name (git-file-name name version))
8323          (sha256
8324           (base32
8325            "12j45ff0n26578vmfbhb9mfbdchw4wy023k0m2ppgl9s0z4bhjaj"))))
8326       (build-system asdf-build-system/sbcl)
8327       (synopsis "Julia-like dispatch for Common Lisp")
8328       (description
8329        "This library is part of NUMCL.  It provides a macro
8330 @code{SPECIALIZED} that performs a Julia-like dispatch on the arguments,
8331 lazily compiling a type-specific version of the function from the same
8332 code.  The main target of this macro is speed.")
8333       (home-page "https://github.com/numcl/specialized-function")
8334       (license license:lgpl3+)
8335       (inputs
8336        `(("trivia" ,sbcl-trivia)
8337          ("alexandria" ,sbcl-alexandria)
8338          ("iterate" ,sbcl-iterate)
8339          ("lisp-namespace" ,sbcl-lisp-namespace)
8340          ("type-r" ,sbcl-type-r)
8341          ("trivial-cltl2" ,sbcl-trivial-cltl2)))
8342       (native-inputs
8343        `(("fiveam" ,sbcl-fiveam)))
8344       (arguments
8345        `(#:asd-files '("specialized-function.asd")
8346          #:test-asd-file "specialized-function.test.asd")))))
8347
8348 (define-public cl-specialized-function
8349   (sbcl-package->cl-source-package sbcl-specialized-function))
8350
8351 (define-public sbcl-constantfold
8352   (let ((commit "0ff1d97a3fbcb89264f6a2af6ce62b73e7b421f4")
8353         (revision "1"))
8354     (package
8355       (name "sbcl-constantfold")
8356       (version (git-version "0.1" revision commit))
8357       (source
8358        (origin
8359          (method git-fetch)
8360          (uri (git-reference
8361                (url "https://github.com/numcl/constantfold")
8362                (commit commit)))
8363          (file-name (git-file-name name version))
8364          (sha256
8365           (base32
8366            "153h0569z6bff1qbad0bdssplwwny75l7ilqwcfqfdvzsxf9jh06"))))
8367       (build-system asdf-build-system/sbcl)
8368       (synopsis "Support library for numcl")
8369       (description
8370        "Support library for numcl.  Registers a function as an
8371 additional form that is considered as a candidate for a constant.")
8372       (home-page "https://github.com/numcl/constantfold")
8373       (license license:lgpl3+)
8374       (inputs
8375        `(("trivia" ,sbcl-trivia)
8376          ("alexandria" ,sbcl-alexandria)
8377          ("iterate" ,sbcl-iterate)
8378          ("lisp-namespace" ,sbcl-lisp-namespace)))
8379       (native-inputs
8380        `(("fiveam" ,sbcl-fiveam)))
8381       (arguments
8382        `(#:asd-files '("constantfold.asd")
8383          #:test-asd-file "constantfold.test.asd")))))
8384
8385 (define-public cl-constantfold
8386   (sbcl-package->cl-source-package sbcl-constantfold))
8387
8388 (define-public ecl-constantfold
8389   (sbcl-package->ecl-package sbcl-constantfold))
8390
8391 (define-public sbcl-gtype
8392   (let ((commit "42275e3606242ae91e9c8dfa30c18ced50a35b66")
8393         (revision "1"))
8394     (package
8395       (name "sbcl-gtype")
8396       (version (git-version "0.1" revision commit))
8397       (source
8398        (origin
8399          (method git-fetch)
8400          (uri (git-reference
8401                (url "https://github.com/numcl/gtype")
8402                (commit commit)))
8403          (file-name (git-file-name name version))
8404          (sha256
8405           (base32
8406            "1f56dba998v945jcxhha391557n6md1ql25b7icfwwfivhmlaa9b"))))
8407       (build-system asdf-build-system/sbcl)
8408       (synopsis "C++/Julia-like parametric types in Common Lisp")
8409       (description
8410        "Support library for numcl that provides Julia-like runtime parametric
8411 type correctness in Common Lisp.  It is based on CLtL2 extensions.")
8412       (home-page "https://github.com/numcl/gtype")
8413       (license license:lgpl3+)
8414       (inputs
8415        `(("trivialib.type-unify" ,sbcl-trivialib-type-unify)
8416          ("trivial-cltl2" ,sbcl-trivial-cltl2)
8417          ("trivia" ,sbcl-trivia)
8418          ("alexandria" ,sbcl-alexandria)
8419          ("iterate" ,sbcl-iterate)
8420          ("type-r" ,sbcl-type-r)))
8421       (native-inputs
8422        `(("fiveam" ,sbcl-fiveam)))
8423       (arguments
8424        `(#:asd-files '("gtype.asd")
8425          #:test-asd-file "gtype.test.asd")))))
8426
8427 (define-public cl-gtype
8428   (sbcl-package->cl-source-package sbcl-gtype))
8429
8430 (define-public sbcl-numcl
8431   (let ((commit "1cf7dfa59f763a24a501092870e9c5ee745d0c17")
8432         (revision "1"))
8433     (package
8434       (name "sbcl-numcl")
8435       (version (git-version "0.1.0" revision commit))
8436       (source
8437        (origin
8438          (method git-fetch)
8439          (uri (git-reference
8440                (url "https://github.com/numcl/numcl")
8441                (commit commit)))
8442          (file-name (git-file-name name version))
8443          (sha256
8444           (base32
8445            "0i3jby9hf4ii7blivgyza80g0vmjfhk8537i5i7kqqk0i5sdnym2"))))
8446       (build-system asdf-build-system/sbcl)
8447       (synopsis "Numpy clone in Common Lisp")
8448       (description
8449        "This is a Numpy clone in Common Lisp.  At the moment the
8450 library is written in pure Common Lisp, focusing more on correctness
8451 and usefulness, not speed.  Track the progress at
8452 @url{https://github.com/numcl/numcl/projects/1}.")
8453       (home-page "https://github.com/numcl/numcl")
8454       (license license:lgpl3+)
8455       (inputs
8456        `(("trivia" ,sbcl-trivia)
8457          ("alexandria" ,sbcl-alexandria)
8458          ("iterate" ,sbcl-iterate)
8459          ("lisp-namespace" ,sbcl-lisp-namespace)
8460          ("type-r" ,sbcl-type-r)
8461          ("constantfold" ,sbcl-constantfold)
8462          ("cl-randist" ,sbcl-cl-randist)
8463          ("float-features" ,sbcl-float-features)
8464          ("function-cache" ,sbcl-function-cache)
8465          ("specialized-function" ,sbcl-specialized-function)
8466          ("gtype" ,sbcl-gtype)))
8467       (native-inputs
8468        `(("fiveam" ,sbcl-fiveam)))
8469       (arguments
8470        `(#:asd-files '("numcl.asd")
8471          #:test-asd-file "numcl.test.asd")))))
8472
8473 (define-public cl-numcl
8474   (sbcl-package->cl-source-package sbcl-numcl))
8475
8476 (define-public sbcl-pzmq
8477   (let ((commit "7c7390eedc469d033c72dc497984d1536ee75826")
8478         (revision "1"))
8479     (package
8480       (name "sbcl-pzmq")
8481       (version (git-version "0.0.0" revision commit))
8482       (source
8483        (origin
8484          (method git-fetch)
8485          (uri (git-reference
8486                (url "https://github.com/orivej/pzmq")
8487                (commit commit)))
8488          (file-name (git-file-name name version))
8489          (sha256
8490           (base32 "0gmwzf7h90wa7v4wnk49g0hv2mdalljpwhyigxcb967wzv8lqci9"))))
8491       (build-system asdf-build-system/sbcl)
8492       (native-inputs
8493        `(("bordeaux-threads" ,sbcl-bordeaux-threads)
8494          ("fiveam" ,sbcl-fiveam)
8495          ("let-plus" ,sbcl-let-plus)))
8496       (inputs
8497        `(("cffi" ,sbcl-cffi)
8498          ("zeromq" ,zeromq)))
8499       (arguments
8500        `(#:phases (modify-phases %standard-phases
8501                     (add-after 'unpack 'fix-paths
8502                       (lambda* (#:key inputs #:allow-other-keys)
8503                         (substitute* "c-api.lisp"
8504                           (("\"libzmq")
8505                            (string-append "\""
8506                                           (assoc-ref inputs "zeromq")
8507                                           "/lib/libzmq")))
8508                         #t)))))
8509       (synopsis "Common Lisp bindings for the ZeroMQ library")
8510       (description "This Common Lisp library provides bindings for the ZeroMQ
8511 lightweight messaging kernel.")
8512       (home-page "https://github.com/orivej/pzmq")
8513       (license license:unlicense))))
8514
8515 (define-public cl-pzmq
8516   (sbcl-package->cl-source-package sbcl-pzmq))
8517
8518 (define-public ecl-pzmq
8519   (sbcl-package->ecl-package sbcl-pzmq))
8520
8521 (define-public sbcl-clss
8522   (let ((revision "1")
8523         (commit "2a8e8615ab55870d4ca01928f3ed3bbeb4e75c8d"))
8524     (package
8525       (name "sbcl-clss")
8526       (version (git-version "0.3.1" revision commit))
8527       (source
8528        (origin
8529          (method git-fetch)
8530          (uri
8531           (git-reference
8532            (url "https://github.com/Shinmera/clss")
8533            (commit commit)))
8534          (sha256
8535           (base32 "0la4dbcda78x29szanylccrsljqrn9d1mhh569sqkyp44ni5fv91"))
8536          (file-name (git-file-name name version))))
8537       (inputs
8538        `(("array-utils" ,sbcl-array-utils)
8539          ("plump" ,sbcl-plump)))
8540       (build-system asdf-build-system/sbcl)
8541       (synopsis "DOM tree searching engine based on CSS selectors")
8542       (description "CLSS is a DOM traversal engine based on CSS
8543 selectors.  It makes use of the Plump-DOM and is used by lQuery.")
8544       (home-page "https://github.com/Shinmera/clss")
8545       (license license:zlib))))
8546
8547 (define-public cl-clss
8548   (sbcl-package->cl-source-package sbcl-clss))
8549
8550 (define-public ecl-clss
8551   (sbcl-package->ecl-package sbcl-clss))
8552
8553 (define-public sbcl-lquery
8554   (let ((revision "1")
8555         (commit "8048111c6b83956daa632e7a3ffbd8c9c203bd8d"))
8556     (package
8557       (name "sbcl-lquery")
8558       (version (git-version "3.2.1" revision commit))
8559       (source
8560        (origin
8561          (method git-fetch)
8562          (uri
8563           (git-reference
8564            (url "https://github.com/Shinmera/lquery")
8565            (commit commit)))
8566          (sha256
8567           (base32 "0520mcpxc2d6fdm8z61arpgd2z38kan7cf06qs373n5r64rakz6w"))
8568          (file-name (git-file-name name version))))
8569       (native-inputs
8570        `(("fiveam" ,sbcl-fiveam)))
8571       (inputs
8572        `(("array-utils" ,sbcl-array-utils)
8573          ("form-fiddle" ,sbcl-form-fiddle)
8574          ("plump" ,sbcl-plump)
8575          ("clss" ,sbcl-clss)))
8576       (build-system asdf-build-system/sbcl)
8577       (synopsis "Library to allow jQuery-like HTML/DOM manipulation")
8578       (description "@code{lQuery} is a DOM manipulation library written in
8579 Common Lisp, inspired by and based on the jQuery syntax and
8580 functions.  It uses Plump and CLSS as DOM and selector engines.  The
8581 main idea behind lQuery is to provide a simple interface for crawling
8582 and modifying HTML sites, as well as to allow for an alternative
8583 approach to templating.")
8584       (home-page "https://github.com/Shinmera/lquery")
8585       (license license:zlib))))
8586
8587 (define-public cl-lquery
8588   (sbcl-package->cl-source-package sbcl-lquery))
8589
8590 (define-public ecl-lquery
8591   (sbcl-package->ecl-package sbcl-lquery))
8592
8593 (define-public sbcl-cl-mysql
8594   (let ((commit "ab56c279c1815aec6ca0bfe85164ff7e85cfb6f9")
8595         (revision "1"))
8596     (package
8597       (name "sbcl-cl-mysql")
8598       (version (git-version "0.1" revision commit))
8599       (source
8600        (origin
8601          (method git-fetch)
8602          (uri (git-reference
8603                (url "https://github.com/hackinghat/cl-mysql")
8604                (commit commit)))
8605          (file-name (git-file-name name version))
8606          (sha256
8607           (base32 "0dg5ynx2ww94d0qfwrdrm7plkn43h64hs4iiq9mj2s1s4ixnp3lr"))))
8608       (build-system asdf-build-system/sbcl)
8609       (native-inputs
8610        `(("stefil" ,sbcl-stefil)))
8611       (inputs
8612        `(("cffi" ,sbcl-cffi)
8613          ("mariadb-lib" ,mariadb "lib")))
8614       (arguments
8615        `(#:tests? #f ; TODO: Tests require a running server
8616          #:phases
8617          (modify-phases %standard-phases
8618            (add-after 'unpack 'fix-paths
8619              (lambda* (#:key inputs #:allow-other-keys)
8620                (substitute* "system.lisp"
8621                  (("libmysqlclient_r" all)
8622                   (string-append (assoc-ref inputs "mariadb-lib")
8623                                  "/lib/"
8624                                  all)))
8625                #t)))))
8626       (synopsis "Common Lisp wrapper for MySQL")
8627       (description
8628        "@code{cl-mysql} is a Common Lisp implementation of a MySQL wrapper.")
8629       (home-page "http://www.hackinghat.com/index.php/cl-mysql")
8630       (license license:expat))))
8631
8632 (define-public cl-mysql
8633   (sbcl-package->cl-source-package sbcl-cl-mysql))
8634
8635 (define-public ecl-cl-mysql
8636   (sbcl-package->ecl-package sbcl-cl-mysql))
8637
8638 (define-public sbcl-postmodern
8639   (let ((commit "74469b25bbda990ec9b77e0d0eccdba0cd7e721a")
8640         (revision "1"))
8641     (package
8642       (name "sbcl-postmodern")
8643       (version (git-version "1.19" revision commit))
8644       (source
8645        (origin
8646          (method git-fetch)
8647          (uri (git-reference
8648                (url "https://github.com/marijnh/Postmodern")
8649                (commit commit)))
8650          (file-name (git-file-name name version))
8651          (sha256
8652           (base32 "0im7ymnyxjhn2w74jfg76k5gpr0gl33n31akx33hl28722ljd0hd"))))
8653       (build-system asdf-build-system/sbcl)
8654       (native-inputs
8655        `(("fiveam" ,sbcl-fiveam)))
8656       (inputs
8657        `(("alexandria" ,sbcl-alexandria)
8658          ("bordeaux-threads" ,sbcl-bordeaux-threads)
8659          ("closer-mop" ,sbcl-closer-mop)
8660          ("global-vars" ,sbcl-global-vars)
8661          ("md5" ,sbcl-md5)
8662          ("split-sequence" ,sbcl-split-sequence)
8663          ("usocket" ,sbcl-usocket)))
8664       (arguments
8665        ;; TODO: Fix missing dependency errors for simple-date/postgres-glue,
8666        ;; cl-postgres/tests and s-sql/tests.
8667        `(#:tests? #f
8668          #:asd-systems '("postmodern"
8669                          "simple-date/postgres-glue")))
8670       (synopsis "Common Lisp library for interacting with PostgreSQL")
8671       (description
8672        "@code{postmodern} is a Common Lisp library for interacting with
8673 PostgreSQL databases.  It provides the following features:
8674
8675 @itemize
8676 @item Efficient communication with the database server without need for
8677 foreign libraries.
8678 @item Support for UTF-8 on Unicode-aware Lisp implementations.
8679 @item A syntax for mixing SQL and Lisp code.
8680 @item Convenient support for prepared statements and stored procedures.
8681 @item A metaclass for simple database-access objects.
8682 @end itemize\n")
8683       (home-page "https://marijnhaverbeke.nl/postmodern/")
8684       (license license:zlib))))
8685
8686 (define-public cl-postmodern
8687   (sbcl-package->cl-source-package sbcl-postmodern))
8688
8689 (define-public ecl-postmodern
8690   (package
8691     (inherit (sbcl-package->ecl-package sbcl-postmodern))
8692     (arguments
8693      `(#:tests? #f
8694        #:asd-systems '("postmodern"
8695                        "simple-date/postgres-glue")
8696        #:phases
8697        (modify-phases %standard-phases
8698          (add-after 'unpack 'fix-build
8699            (lambda _
8700              (substitute* "cl-postgres.asd"
8701                (("\\) \"usocket\"")
8702                 " :ecl) \"usocket\""))
8703              #t)))))))
8704
8705 (define-public sbcl-dbi
8706   ;; Master includes a breaking change which other packages depend on since
8707   ;; Quicklisp decided to follow it:
8708   ;; https://github.com/fukamachi/cl-dbi/commit/31c46869722f77fd5292a81b5b101f1347d7fce1
8709   (let ((commit "31c46869722f77fd5292a81b5b101f1347d7fce1"))
8710     (package
8711       (name "sbcl-dbi")
8712       (version (git-version "0.9.4" "1" commit))
8713       (source
8714        (origin
8715          (method git-fetch)
8716          (uri (git-reference
8717                (url "https://github.com/fukamachi/cl-dbi")
8718                (commit commit)))
8719          (file-name (git-file-name name version))
8720          (sha256
8721           (base32 "0r3n4rw12qqxad0cryym2ibm4ddl49gbq4ra227afibsr43nw5k3"))))
8722       (build-system asdf-build-system/sbcl)
8723       (native-inputs
8724        `(("rove" ,sbcl-rove)
8725          ("trivial-types" ,sbcl-trivial-types)))
8726       (inputs
8727        `(("bordeaux-threads" ,sbcl-bordeaux-threads)
8728          ("cl-mysql" ,sbcl-cl-mysql)
8729          ("cl-sqlite" ,sbcl-cl-sqlite)
8730          ("closer-mop" ,sbcl-closer-mop)
8731          ("postmodern" ,sbcl-postmodern)
8732          ("split-sequence" ,sbcl-split-sequence)
8733          ("trivial-garbage" ,sbcl-trivial-garbage)))
8734       (arguments
8735        `(#:asd-systems '("dbi"
8736                          "dbd-mysql"
8737                          "dbd-postgres"
8738                          "dbd-sqlite3")))
8739       (synopsis "Database independent interface for Common Lisp")
8740       (description
8741        "@code{dbi} is a Common Lisp library providing a database independent
8742 interface for MySQL, PostgreSQL and SQLite.")
8743       (home-page "https://github.com/fukamachi/cl-dbi")
8744       (license license:llgpl))))
8745
8746 (define-public cl-dbi
8747   (sbcl-package->cl-source-package sbcl-dbi))
8748
8749 (define-public ecl-dbi
8750   (sbcl-package->ecl-package sbcl-dbi))
8751
8752 (define-public sbcl-uffi
8753   (package
8754     (name "sbcl-uffi")
8755     (version "2.1.2")
8756     (source
8757      (origin
8758        (method git-fetch)
8759        (uri (git-reference
8760              (url "http://git.kpe.io/uffi.git")
8761              (commit (string-append "v" version))))
8762        (file-name (git-file-name name version))
8763        (sha256
8764         (base32 "1hqszvz0a3wk4s9faa83sc3vjxcb5rxmjclyr17yzwg55z733kry"))))
8765     (build-system asdf-build-system/sbcl)
8766     (arguments
8767      `(#:tests? #f ; TODO: Fix use of deprecated ASDF functions
8768        #:asd-files '("uffi.asd")
8769        #:phases
8770        (modify-phases %standard-phases
8771          (add-after 'unpack 'fix-permissions
8772            (lambda _
8773              (make-file-writable "doc/html.tar.gz")
8774              #t)))))
8775     (synopsis "Universal foreign function library for Common Lisp")
8776     (description
8777      "UFFI provides a universal foreign function interface (FFI)
8778  for Common Lisp.")
8779     (home-page "http://quickdocs.org/uffi/")
8780     (license license:llgpl)))
8781
8782 (define-public cl-uffi
8783   (package
8784     (inherit (sbcl-package->cl-source-package sbcl-uffi))
8785     (arguments
8786      `(#:phases
8787        ;; asdf-build-system/source has its own phases and does not inherit
8788        ;; from asdf-build-system/sbcl phases.
8789        (modify-phases %standard-phases/source
8790          ;; Already done in SBCL package.
8791          (delete 'reset-gzip-timestamps))))))
8792
8793 (define-public sbcl-clsql
8794   (package
8795     (name "sbcl-clsql")
8796     (version "6.7.0")
8797     (source
8798      (origin
8799        (method git-fetch)
8800        (uri (git-reference
8801              (url "http://git.kpe.io/clsql.git")
8802              (commit (string-append "v" version))))
8803        (file-name (git-file-name name version))
8804        (sha256
8805         (base32 "1v1k3s5bsy3lgd9gk459bzpb1r0kdjda25s29samxw4gsgf1fqvp"))
8806        (snippet
8807         '(begin
8808            ;; Remove precompiled libraries.
8809            (delete-file "db-mysql/clsql_mysql.dll")
8810            (delete-file "uffi/clsql_uffi.dll")
8811            (delete-file "uffi/clsql_uffi.lib")
8812            #t))))
8813     (build-system asdf-build-system/sbcl)
8814     (native-inputs
8815      `(("rt" ,sbcl-rt)))
8816     (inputs
8817      `(("cffi" ,sbcl-cffi)
8818        ("md5" ,sbcl-md5)
8819        ("mysql" ,mysql)
8820        ("postgresql" ,postgresql)
8821        ("postmodern" ,sbcl-postmodern)
8822        ("sqlite" ,sqlite)
8823        ("uffi" ,sbcl-uffi)
8824        ("zlib" ,zlib)))
8825     (arguments
8826      `(#:asd-files '("clsql.asd"
8827                      "clsql-uffi.asd"
8828                      "clsql-sqlite3.asd"
8829                      "clsql-postgresql.asd"
8830                      "clsql-postgresql-socket3.asd"
8831                      "clsql-mysql.asd")
8832        #:asd-systems '("clsql"
8833                        "clsql-sqlite3"
8834                        "clsql-postgresql"
8835                        "clsql-postgresql-socket3"
8836                        "clsql-mysql")
8837        #:phases
8838        (modify-phases %standard-phases
8839          (add-after 'unpack 'fix-permissions
8840            (lambda _
8841              (make-file-writable "doc/html.tar.gz")
8842              #t))
8843          (add-after 'unpack 'fix-build
8844            (lambda _
8845              (substitute* "clsql-uffi.asd"
8846                (("\\(:version uffi \"2.0\"\\)")
8847                 "uffi"))
8848              (substitute* "db-postgresql/postgresql-api.lisp"
8849                (("\\(data :cstring\\)")
8850                 "(data :string)"))
8851              #t))
8852          (add-after 'unpack 'fix-paths
8853            (lambda* (#:key inputs outputs #:allow-other-keys)
8854              (substitute* "db-sqlite3/sqlite3-loader.lisp"
8855                (("libsqlite3")
8856                 (string-append (assoc-ref inputs "sqlite")
8857                                "/lib/libsqlite3")))
8858              (substitute* "db-postgresql/postgresql-loader.lisp"
8859                (("libpq")
8860                 (string-append (assoc-ref inputs "postgresql")
8861                                "/lib/libpq")))
8862              (let ((lib (string-append "#p\""
8863                                        (assoc-ref outputs "out")
8864                                        "/lib/\"")))
8865                (substitute* "clsql-mysql.asd"
8866                  (("#p\"/usr/lib/clsql/clsql_mysql\\.so\"")
8867                   lib))
8868                (substitute* "db-mysql/mysql-loader.lisp"
8869                  (("libmysqlclient" all)
8870                   (string-append (assoc-ref inputs "mysql") "/lib/" all))
8871                  (("clsql-mysql-system::\\*library-file-dir\\*")
8872                   lib)))
8873              #t))
8874          (add-before 'build 'build-helper-library
8875            (lambda* (#:key inputs outputs #:allow-other-keys)
8876              (let* ((mysql (assoc-ref inputs "mysql"))
8877                     (inc-dir (string-append mysql "/include/mysql"))
8878                     (lib-dir (string-append mysql "/lib"))
8879                     (shared-lib-dir (string-append (assoc-ref outputs "out")
8880                                                    "/lib"))
8881                     (shared-lib (string-append shared-lib-dir
8882                                                "/clsql_mysql.so")))
8883                (mkdir-p shared-lib-dir)
8884                (invoke "gcc" "-fPIC" "-shared"
8885                        "-I" inc-dir
8886                        "db-mysql/clsql_mysql.c"
8887                        "-Wl,-soname=clsql_mysql"
8888                        "-L" lib-dir "-lmysqlclient" "-lz"
8889                        "-o" shared-lib)
8890                #t)))
8891          (add-after 'unpack 'fix-tests
8892            (lambda _
8893              (substitute* "clsql.asd"
8894                (("clsql-tests :force t")
8895                 "clsql-tests"))
8896              #t)))))
8897     (synopsis "Common Lisp SQL Interface library")
8898     (description
8899      "@code{clsql} is a Common Lisp interface to SQL RDBMS based on the
8900 Xanalys CommonSQL interface for Lispworks.  It provides low-level database
8901 interfaces as well as a functional and an object oriented interface.")
8902     (home-page "http://clsql.kpe.io/")
8903     (license license:llgpl)))
8904
8905 (define-public cl-clsql
8906   (package
8907     (inherit (sbcl-package->cl-source-package sbcl-clsql))
8908     (native-inputs
8909      `(("rt" ,cl-rt)))
8910     (inputs
8911      `(("mysql" ,mysql)
8912        ("postgresql" ,postgresql)
8913        ("sqlite" ,sqlite)
8914        ("zlib" ,zlib)))
8915     (propagated-inputs
8916      `(("cffi" ,cl-cffi)
8917        ("md5" ,cl-md5)
8918        ("postmodern" ,cl-postmodern)
8919        ("uffi" ,cl-uffi)))
8920     (arguments
8921      `(#:phases
8922        ;; asdf-build-system/source has its own phases and does not inherit
8923        ;; from asdf-build-system/sbcl phases.
8924        (modify-phases %standard-phases/source
8925          (add-after 'unpack 'fix-permissions
8926            (lambda _
8927              (make-file-writable "doc/html.tar.gz")
8928              #t)))))))
8929
8930 (define-public ecl-clsql
8931   (let ((pkg (sbcl-package->ecl-package sbcl-clsql)))
8932     (package
8933       (inherit pkg)
8934       (inputs
8935        (alist-delete "uffi" (package-inputs pkg)))
8936       (arguments
8937        (substitute-keyword-arguments (package-arguments pkg)
8938          ((#:asd-files asd-files '())
8939           `(cons "clsql-cffi.asd" ,asd-files)))))))
8940
8941 (define-public sbcl-sycamore
8942   (let ((commit "fd2820fec165ad514493426dea209728f64e6d18"))
8943     (package
8944       (name "sbcl-sycamore")
8945       (version "0.0.20120604")
8946       (source
8947        (origin
8948          (method git-fetch)
8949          (uri (git-reference
8950                (url "https://github.com/ndantam/sycamore/")
8951                (commit commit)))
8952          (file-name (git-file-name name version))
8953          (sha256
8954           (base32 "00bv1aj89q5vldmq92zp2364jq312zjq2mbd3iyz1s2b4widzhl7"))))
8955       (build-system asdf-build-system/sbcl)
8956       (inputs
8957        `(("alexandria" ,sbcl-alexandria)
8958          ("cl-ppcre" ,sbcl-cl-ppcre)))
8959       (synopsis "Purely functional data structure library in Common Lisp")
8960       (description
8961        "Sycamore is a fast, purely functional data structure library in Common Lisp.
8962 If features:
8963
8964 @itemize
8965 @item Fast, purely functional weight-balanced binary trees.
8966 @item Leaf nodes are simple-vectors, greatly reducing tree height.
8967 @item Interfaces for tree Sets and Maps (dictionaries).
8968 @item Ropes.
8969 @item Purely functional pairing heaps.
8970 @item Purely functional amortized queue.
8971 @end itemize\n")
8972       (home-page "http://ndantam.github.io/sycamore/")
8973       (license license:bsd-3))))
8974
8975 (define-public cl-sycamore
8976   (sbcl-package->cl-source-package sbcl-sycamore))
8977
8978 (define-public ecl-sycamore
8979   (sbcl-package->ecl-package sbcl-sycamore))
8980
8981 (define-public sbcl-trivial-package-local-nicknames
8982   (package
8983     (name "sbcl-trivial-package-local-nicknames")
8984     (version "0.2")
8985     (home-page "https://github.com/phoe/trivial-package-local-nicknames")
8986     (source
8987      (origin
8988        (method git-fetch)
8989        (uri (git-reference
8990              (url home-page)
8991              (commit "16b7ad4c2b120f50da65154191f468ea5598460e")))
8992        (file-name (git-file-name name version))
8993        (sha256
8994         (base32 "18qc27xkjzdcqrilpk3pm7djldwq5rm3ggd5h9cr8hqcd54i2fqg"))))
8995     (build-system asdf-build-system/sbcl)
8996     (synopsis "Common Lisp compatibility library for package local nicknames")
8997     (description
8998      "This library is a portable compatibility layer around package local nicknames (PLN).
8999 This was done so there is a portability library for the PLN API not included
9000 in DEFPACKAGE.")
9001     (license license:unlicense)))
9002
9003 (define-public cl-trivial-package-local-nicknames
9004   (sbcl-package->cl-source-package sbcl-trivial-package-local-nicknames))
9005
9006 (define-public ecl-trivial-package-local-nicknames
9007   (sbcl-package->ecl-package sbcl-trivial-package-local-nicknames))
9008
9009 (define-public sbcl-enchant
9010   (let ((commit "6af162a7bf10541cbcfcfa6513894900329713fa"))
9011     (package
9012       (name "sbcl-enchant")
9013       (version (git-version "0.0.0" "1" commit))
9014       (home-page "https://github.com/tlikonen/cl-enchant")
9015       (source
9016        (origin
9017          (method git-fetch)
9018          (uri (git-reference
9019                (url home-page)
9020                (commit commit)))
9021          (file-name (git-file-name name version))
9022          (sha256
9023           (base32 "19yh5ihirzi1d8xqy1cjqipzd6ly3245cfxa5s9xx496rryz0s01"))))
9024       (build-system asdf-build-system/sbcl)
9025       (inputs
9026        `(("enchant" ,enchant)
9027          ("cffi" ,sbcl-cffi)))
9028       (arguments
9029        `(#:phases
9030          (modify-phases %standard-phases
9031            (add-after 'unpack 'fix-paths
9032              (lambda* (#:key inputs #:allow-other-keys)
9033                (substitute* "load-enchant.lisp"
9034                  (("libenchant")
9035                   (string-append
9036                    (assoc-ref inputs "enchant") "/lib/libenchant-2"))))))))
9037       (synopsis "Common Lisp interface for the Enchant spell-checker library")
9038       (description
9039        "Enchant is a Common Lisp interface for the Enchant spell-checker
9040 library.  The Enchant library is a generic spell-checker library which uses
9041 other spell-checkers transparently as back-end.  The library supports the
9042 multiple checkers, including Aspell and Hunspell.")
9043       (license license:public-domain))))
9044
9045 (define-public cl-enchant
9046   (sbcl-package->cl-source-package sbcl-enchant))
9047
9048 (define-public ecl-enchant
9049   (sbcl-package->ecl-package sbcl-enchant))
9050
9051 (define-public sbcl-cl-change-case
9052   (let ((commit "5ceff2a5f8bd845b6cb510c6364176b27a238fd3"))
9053     (package
9054       (name "sbcl-cl-change-case")
9055       (version (git-version "0.1.0" "1" commit))
9056       (home-page "https://github.com/rudolfochrist/cl-change-case")
9057       (source
9058        (origin
9059          (method git-fetch)
9060          (uri (git-reference
9061                (url home-page)
9062                (commit commit)))
9063          (file-name (git-file-name name version))
9064          (sha256
9065           (base32 "1afyglglk9z3yg8gylcl301bl2r8vq3sllyznzj9s5xi5gs6qyf2"))))
9066       (build-system asdf-build-system/sbcl)
9067       (inputs
9068        `(("cl-ppcre" ,sbcl-cl-ppcre)
9069          ("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)))
9070       (native-inputs
9071        `(("fiveam" ,sbcl-fiveam)))
9072       (arguments
9073        '(;; FIXME: Test pass but phase fails with 'Component
9074          ;; "cl-change-case-test" not found, required by'.
9075          #:tests? #f
9076          #:test-asd-file "cl-change-case-test.asd"))
9077       (synopsis "Convert Common Lisp strings between camelCase, PascalCase and more")
9078       (description
9079        "@code{cl-change-case} is library to convert strings between camelCase,
9080 PascalCase, snake_case, param-case, CONSTANT_CASE and more.")
9081       (license license:llgpl))))
9082
9083 (define-public cl-change-case
9084   (sbcl-package->cl-source-package sbcl-cl-change-case))
9085
9086 (define-public ecl-cl-change-case
9087   (sbcl-package->ecl-package sbcl-cl-change-case))
9088
9089 (define-public sbcl-moptilities
9090   (let ((commit "a436f16b357c96b82397ec018ea469574c10dd41"))
9091     (package
9092       (name "sbcl-moptilities")
9093       (version (git-version "0.3.13" "1" commit))
9094       (home-page "https://github.com/gwkkwg/moptilities/")
9095       (source
9096        (origin
9097          (method git-fetch)
9098          (uri (git-reference
9099                (url home-page)
9100                (commit commit)))
9101          (file-name (git-file-name name version))
9102          (sha256
9103           (base32 "1q12bqjbj47lx98yim1kfnnhgfhkl80102fkgp9pdqxg0fp6g5fc"))))
9104       (build-system asdf-build-system/sbcl)
9105       (inputs
9106        `(("closer-mop" ,sbcl-closer-mop)))
9107       (native-inputs
9108        `(("lift" ,sbcl-lift)))
9109       (arguments
9110        `(#:phases
9111          (modify-phases %standard-phases
9112            (add-after 'unpack 'fix-tests
9113              (lambda _
9114                (substitute* "lift-standard.config"
9115                  ((":relative-to lift-test")
9116                   ":relative-to moptilities-test"))
9117                #t)))))
9118       (synopsis "Compatibility layer for Common Lisp MOP implementation differences")
9119       (description
9120        "MOP utilities provide a common interface between Lisps and make the
9121 MOP easier to use.")
9122       (license license:expat))))
9123
9124 (define-public cl-moptilities
9125   (sbcl-package->cl-source-package sbcl-moptilities))
9126
9127 (define-public sbcl-osicat
9128   (let ((commit "de0c18a367eedc857e1902a7319828af072a0d97"))
9129     (package
9130       (name "sbcl-osicat")
9131       (version (git-version "0.7.0" "1" commit))
9132       (home-page "http://www.common-lisp.net/project/osicat/")
9133       (source
9134        (origin
9135          (method git-fetch)
9136          (uri (git-reference
9137                (url "https://github.com/osicat/osicat")
9138                (commit commit)))
9139          (file-name (git-file-name name version))
9140          (sha256
9141           (base32 "15viw5pi5sa7qq9b4n2rr3dj2jkqr180rh9z1lh8w3rgl42i2adc"))))
9142       (build-system asdf-build-system/sbcl)
9143       (inputs
9144        `(("alexandria" ,sbcl-alexandria)
9145          ("cffi" ,sbcl-cffi)
9146          ("trivial-features" ,sbcl-trivial-features)))
9147       (native-inputs
9148        `(("rt" ,sbcl-rt)))
9149       (synopsis "Operating system interface for Common Lisp")
9150       (description
9151        "Osicat is a lightweight operating system interface for Common Lisp on
9152 Unix-platforms.  It is not a POSIX-style API, but rather a simple lispy
9153 accompaniment to the standard ANSI facilities.")
9154       (license license:expat))))
9155
9156 (define-public cl-osicat
9157   (sbcl-package->cl-source-package sbcl-osicat))
9158
9159 (define-public ecl-osicat
9160   (sbcl-package->ecl-package sbcl-osicat))
9161
9162 (define-public sbcl-clx-xembed
9163   (let ((commit "a5c4b844d31ee68ffa58c933cc1cdddde6990743")
9164         (revision "1"))
9165     (package
9166       (name "sbcl-clx-xembed")
9167       (version (git-version "0.1" revision commit))
9168       (home-page "https://github.com/laynor/clx-xembed")
9169       (source
9170        (origin
9171          (method git-fetch)
9172          (uri (git-reference
9173                (url "https://github.com/laynor/clx-xembed")
9174                (commit commit)))
9175          (file-name (git-file-name name version))
9176          (sha256
9177           (base32 "1abx4v36ycmfjdwpjk4hh8058ya8whwia7ds9vd96q2qsrs57f12"))))
9178       (build-system asdf-build-system/sbcl)
9179       (arguments
9180        `(#:asd-systems '("xembed")))
9181       (inputs
9182        `(("sbcl-clx" ,sbcl-clx)))
9183       (synopsis "CL(x) xembed protocol implementation ")
9184       (description "CL(x) xembed protocol implementation")
9185       ;; MIT License
9186       (license license:expat))))
9187
9188 (define-public cl-clx-xembed
9189   (sbcl-package->cl-source-package sbcl-clx-xembed))
9190
9191 (define-public ecl-clx-xembed
9192   (sbcl-package->ecl-package sbcl-clx-xembed))
9193
9194 (define-public sbcl-quantile-estimator
9195   (package
9196     (name "sbcl-quantile-estimator")
9197     (version "0.0.1")
9198     (source
9199      (origin
9200        (method git-fetch)
9201        (uri (git-reference
9202              (url "https://github.com/deadtrickster/quantile-estimator.cl")
9203              (commit "84d0ea405d793f5e808c68c4ddaf25417b0ff8e5")))
9204        (file-name (git-file-name name version))
9205        (sha256
9206         (base32
9207          "0rlswkf0siaabsvvch3dgxmg45fw5w8pd9b7ri2w7a298aya52z9"))))
9208     (build-system asdf-build-system/sbcl)
9209     (arguments
9210      '(#:asd-files '("quantile-estimator.asd")))
9211     (inputs
9212      `(("alexandria" ,sbcl-alexandria)))
9213     (home-page "https://github.com/deadtrickster/quantile-estimator.cl")
9214     (synopsis
9215      "Effective computation of biased quantiles over data streams")
9216     (description
9217      "Common Lisp implementation of Graham Cormode and S.
9218 Muthukrishnan's Effective Computation of Biased Quantiles over Data
9219 Streams in ICDE’05.")
9220     (license license:expat)))
9221
9222 (define-public cl-quantile-estimator
9223   (sbcl-package->cl-source-package sbcl-quantile-estimator))
9224
9225 (define-public ecl-quantile-estimator
9226   (sbcl-package->ecl-package sbcl-quantile-estimator))
9227
9228 (define-public sbcl-prometheus
9229   (package
9230     (name "sbcl-prometheus")
9231     (version "0.4.1")
9232     (source
9233      (origin
9234        (method git-fetch)
9235        (uri (git-reference
9236              (url "https://github.com/deadtrickster/prometheus.cl")
9237              (commit "7352b92296996ff383503e19bdd3bcea30409a15")))
9238        (file-name (git-file-name name version))
9239        (sha256
9240         (base32
9241          "0fzczls2kfgdx18pja4lqxjrz72i583185d8nq0pb3s331hhzh0z"))))
9242     (build-system asdf-build-system/sbcl)
9243     (inputs
9244      `(("alexandria" ,sbcl-alexandria)
9245        ("bordeaux-threads" ,sbcl-bordeaux-threads)
9246        ("cffi" ,sbcl-cffi)
9247        ("cl-fad" ,sbcl-cl-fad)
9248        ("cl-ppcre" ,sbcl-cl-ppcre)
9249        ("drakma" ,sbcl-drakma)
9250        ("hunchentoot" ,sbcl-hunchentoot)
9251        ("local-time" ,sbcl-local-time)
9252        ("quantile-estimator" ,sbcl-quantile-estimator)
9253        ("salza2" ,sbcl-salza2)
9254        ("split-sequence" ,sbcl-split-sequence)
9255        ("trivial-utf-8" ,sbcl-trivial-utf-8)))
9256     (arguments
9257      '(#:asd-files '("prometheus.asd"
9258                      "prometheus.collectors.sbcl.asd"
9259                      "prometheus.collectors.process.asd"
9260                      "prometheus.formats.text.asd"
9261                      "prometheus.exposers.hunchentoot.asd"
9262                      "prometheus.pushgateway.asd")
9263        #:asd-systems '("prometheus"
9264                        "prometheus.collectors.sbcl"
9265                        "prometheus.collectors.process"
9266                        "prometheus.formats.text"
9267                        "prometheus.exposers.hunchentoot"
9268                        "prometheus.pushgateway")))
9269     (home-page "https://github.com/deadtrickster/prometheus.cl")
9270     (synopsis "Prometheus.io Common Lisp client")
9271     (description "Prometheus.io Common Lisp client.")
9272     (license license:expat)))
9273
9274 (define-public cl-prometheus
9275   (sbcl-package->cl-source-package sbcl-prometheus))
9276
9277 (define-public ecl-prometheus
9278   (sbcl-package->ecl-package sbcl-prometheus))
9279
9280 (define-public sbcl-uuid
9281   (let ((commit "e7d6680c3138385c0708f7aaf0c96622eeb140e8"))
9282     (package
9283       (name "sbcl-uuid")
9284       (version (git-version "2012.12.26" "1" commit))
9285       (source
9286        (origin
9287          (method git-fetch)
9288          (uri (git-reference
9289                (url "https://github.com/dardoria/uuid")
9290                (commit commit)))
9291          (file-name (git-file-name name version))
9292          (sha256
9293           (base32
9294            "0jnyp2kibcf5cwi60l6grjrj8wws9chasjvsw7xzwyym2lyid46f"))))
9295       (build-system asdf-build-system/sbcl)
9296       (inputs
9297        `(("ironclad" ,sbcl-ironclad)
9298          ("trivial-utf-8" ,sbcl-trivial-utf-8)))
9299       (home-page "https://github.com/dardoria/uuid")
9300       (synopsis
9301        "Common Lisp implementation of UUIDs according to RFC4122")
9302       (description
9303        "Common Lisp implementation of UUIDs according to RFC4122.")
9304       (license license:llgpl))))
9305
9306 (define-public cl-uuid
9307   (sbcl-package->cl-source-package sbcl-uuid))
9308
9309 (define-public ecl-uuid
9310   (sbcl-package->ecl-package sbcl-uuid))
9311
9312 (define-public sbcl-dissect
9313   (let ((commit "cffd38479f0e64e805f167bbdb240b783ecc8d45"))
9314     (package
9315       (name "sbcl-dissect")
9316       (version (git-version "1.0.0" "1" commit))
9317       (source
9318        (origin
9319          (method git-fetch)
9320          (uri (git-reference
9321                (url "https://github.com/Shinmera/dissect")
9322                (commit commit)))
9323          (file-name (git-file-name name version))
9324          (sha256
9325           (base32
9326            "0rmsjkgjl90gl6ssvgd60hb0d5diyhsiyypvw9hbc0ripvbmk5r5"))))
9327       (build-system asdf-build-system/sbcl)
9328       (inputs
9329        `(("cl-ppcre" ,sbcl-cl-ppcre)))
9330       (home-page "https://shinmera.github.io/dissect/")
9331       (synopsis
9332        "Introspection library for the call stack and restarts")
9333       (description
9334        "Dissect is a small Common Lisp library for introspecting the call stack
9335 and active restarts.")
9336       (license license:zlib))))
9337
9338 (define-public cl-dissect
9339   (sbcl-package->cl-source-package sbcl-dissect))
9340
9341 (define-public ecl-dissect
9342   (sbcl-package->ecl-package sbcl-dissect))
9343
9344 (define-public sbcl-rove
9345   (package
9346     (name "sbcl-rove")
9347     (version "0.9.6")
9348     (source
9349      (origin
9350        (method git-fetch)
9351        (uri (git-reference
9352              (url "https://github.com/fukamachi/rove")
9353              (commit "f3695db08203bf26f3b861dc22ac0f4257d3ec21")))
9354        (file-name (git-file-name name version))
9355        (sha256
9356         (base32
9357          "07ala4l2fncxf540fzxj3h5mhi9i4wqllhj0rqk8m2ljl5zbz89q"))))
9358     (build-system asdf-build-system/sbcl)
9359     (inputs
9360      `(("bordeaux-threads" ,sbcl-bordeaux-threads)
9361        ("dissect" ,sbcl-dissect)
9362        ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
9363     (home-page "https://github.com/fukamachi/rove")
9364     (synopsis
9365      "Yet another common lisp testing library")
9366     (description
9367      "Rove is a unit testing framework for Common Lisp applications.
9368 This is intended to be a successor of Prove.")
9369     (license license:bsd-3)))
9370
9371 (define-public cl-rove
9372   (sbcl-package->cl-source-package sbcl-rove))
9373
9374 (define-public ecl-rove
9375   (sbcl-package->ecl-package sbcl-rove))
9376
9377 (define-public sbcl-exponential-backoff
9378   (let ((commit "8d9e8444d8b3184a524c12ce3449f91613ab714f"))
9379     (package
9380       (name "sbcl-exponential-backoff")
9381       (version (git-version "0" "1" commit))
9382       (source
9383        (origin
9384          (method git-fetch)
9385          (uri (git-reference
9386                (url "https://github.com/death/exponential-backoff")
9387                (commit commit)))
9388          (file-name (git-file-name name version))
9389          (sha256
9390           (base32
9391            "1389hm9hxv85s0125ja4js1bvh8ay4dsy9q1gaynjv27ynik6gmv"))))
9392       (build-system asdf-build-system/sbcl)
9393       (home-page "https://github.com/death/exponential-backoff")
9394       (synopsis "Exponential backoff algorithm in Common Lisp")
9395       (description
9396        "An implementation of the exponential backoff algorithm in Common Lisp.
9397 Inspired by the implementation found in Chromium.  Read the header file to
9398 learn about each of the parameters.")
9399       (license license:expat))))
9400
9401 (define-public cl-exponential-backoff
9402   (sbcl-package->cl-source-package sbcl-exponential-backoff))
9403
9404 (define-public ecl-exponential-backoff
9405   (sbcl-package->ecl-package sbcl-exponential-backoff))
9406
9407 (define-public sbcl-sxql
9408   (let ((commit "5aa8b739492c5829e8623432b5d46482263990e8"))
9409     (package
9410       (name "sbcl-sxql")
9411       (version (git-version "0.1.0" "1" commit))
9412       (source
9413        (origin
9414          (method git-fetch)
9415          (uri (git-reference
9416                (url "https://github.com/fukamachi/sxql")
9417                (commit commit)))
9418          (file-name (git-file-name name version))
9419          (sha256
9420           (base32
9421            "0k25p6w2ld9cn8q8s20lda6yjfyp4q89219sviayfgixnj27avnj"))))
9422       (build-system asdf-build-system/sbcl)
9423       (arguments
9424        `(#:test-asd-file "sxql-test.asd"))
9425       (inputs
9426        `(("alexandria" ,sbcl-alexandria)
9427          ("cl-syntax" ,sbcl-cl-syntax)
9428          ("iterate" ,sbcl-iterate)
9429          ("optima" ,sbcl-optima)
9430          ("split-sequence" ,sbcl-split-sequence)
9431          ("trivial-types" ,sbcl-trivial-types)))
9432       (native-inputs
9433        `(("prove" ,sbcl-prove)))
9434       (home-page "https://github.com/fukamachi/sxql")
9435       (synopsis "SQL generator for Common Lisp")
9436       (description "SQL generator for Common Lisp.")
9437       (license license:bsd-3))))
9438
9439 (define-public cl-sxql
9440   (sbcl-package->cl-source-package sbcl-sxql))
9441
9442 (define-public ecl-sxql
9443   (sbcl-package->ecl-package sbcl-sxql))
9444
9445 (define-public sbcl-1am
9446   (let ((commit "8b1da94eca4613fd8a20bdf63f0e609e379b0ba5"))
9447     (package
9448       (name "sbcl-1am")
9449       (version (git-version "0.0" "1" commit))
9450       (source
9451        (origin
9452          (method git-fetch)
9453          (uri (git-reference
9454                (url "https://github.com/lmj/1am")
9455                (commit commit)))
9456          (file-name (git-file-name name version))
9457          (sha256
9458           (base32
9459            "05ss4nz1jb9kb796295482b62w5cj29msfj8zis33sp2rw2vmv2g"))))
9460       (build-system asdf-build-system/sbcl)
9461       (arguments
9462        `(#:asd-systems '("1am")))
9463       (home-page "https://github.com/lmj/1am")
9464       (synopsis "Minimal testing framework for Common Lisp")
9465       (description "A minimal testing framework for Common Lisp.")
9466       (license license:expat))))
9467
9468 (define-public cl-1am
9469   (sbcl-package->cl-source-package sbcl-1am))
9470
9471 (define-public ecl-1am
9472   (sbcl-package->ecl-package sbcl-1am))
9473
9474 (define-public sbcl-cl-ascii-table
9475   (let ((commit "d9f5e774a56fad1b416e4dadb8f8a5b0e84094e2")
9476         (revision "1"))
9477     (package
9478       (name "sbcl-cl-ascii-table")
9479       (version (git-version "0.0.0" revision commit))
9480       (source
9481        (origin
9482          (method git-fetch)
9483          (uri (git-reference
9484                (url "https://github.com/telephil/cl-ascii-table")
9485                (commit commit)))
9486          (file-name (git-file-name name version))
9487          (sha256
9488           (base32 "125fdif9sgl7k0ngjhxv0wjas2q27d075025hvj2rx1b1x948z4s"))))
9489       (build-system asdf-build-system/sbcl)
9490       (synopsis "Library to make ascii-art tables")
9491       (description
9492        "This is a Common Lisp library to present tabular data in ascii-art
9493 tables.")
9494       (home-page "https://github.com/telephil/cl-ascii-table")
9495       (license license:expat))))
9496
9497 (define-public cl-ascii-table
9498   (sbcl-package->cl-source-package sbcl-cl-ascii-table))
9499
9500 (define-public ecl-cl-ascii-table
9501   (sbcl-package->ecl-package sbcl-cl-ascii-table))
9502
9503 (define-public sbcl-cl-rdkafka
9504   (package
9505     (name "sbcl-cl-rdkafka")
9506     (version "1.0.2")
9507     (source
9508      (origin
9509        (method git-fetch)
9510        (uri (git-reference
9511              (url "https://github.com/SahilKang/cl-rdkafka")
9512              (commit (string-append "v" version))))
9513        (file-name (git-file-name name version))
9514        (sha256
9515         (base32
9516          "1qcgfd4h7syilzmrmd4z2vknbvawda3q3ykw7xm8n381syry4g82"))))
9517     (build-system asdf-build-system/sbcl)
9518     (arguments
9519      `(#:tests? #f ; Attempts to connect to locally running Kafka
9520        #:phases
9521        (modify-phases %standard-phases
9522          (add-after 'unpack 'fix-paths
9523            (lambda* (#:key inputs #:allow-other-keys)
9524              (substitute* "src/low-level/librdkafka-bindings.lisp"
9525                (("librdkafka" all)
9526                 (string-append (assoc-ref inputs "librdkafka") "/lib/"
9527                                all))))))))
9528     (inputs
9529      `(("bordeaux-threads" ,sbcl-bordeaux-threads)
9530        ("cffi" ,sbcl-cffi)
9531        ("librdkafka" ,librdkafka)
9532        ("lparallel" ,sbcl-lparallel)
9533        ("trivial-garbage" ,sbcl-trivial-garbage)))
9534     (home-page "https://github.com/SahilKang/cl-rdkafka")
9535     (synopsis "Common Lisp client library for Apache Kafka")
9536     (description "A Common Lisp client library for Apache Kafka.")
9537     (license license:gpl3)))
9538
9539 (define-public cl-rdkafka
9540   (sbcl-package->cl-source-package sbcl-cl-rdkafka))
9541
9542 (define-public ecl-cl-rdkafka
9543   (sbcl-package->ecl-package sbcl-cl-rdkafka))
9544
9545 (define-public sbcl-acclimation
9546   (let ((commit "4d51150902568fcd59335f4cc4cfa022df6116a5"))
9547     (package
9548       (name "sbcl-acclimation")
9549       (version (git-version "0.0.0" "1" commit))
9550       (source
9551        (origin
9552          (method git-fetch)
9553          (uri (git-reference
9554                (url "https://github.com/robert-strandh/Acclimation")
9555                (commit commit)))
9556          (file-name (git-file-name name version))
9557          (sha256
9558           (base32
9559            "1aw7rarjl8ai57h0jxnp9hr3dka7qrs55mmbl1p6rhd6xj8mp9wq"))))
9560       (build-system asdf-build-system/sbcl)
9561       (home-page "https://github.com/robert-strandh/Acclimation")
9562       (synopsis "Internationalization library for Common Lisp")
9563       (description "This project is meant to provide tools for
9564 internationalizing Common Lisp programs.
9565
9566 One important aspect of internationalization is of course the language used in
9567 error messages, documentation strings, etc.  But with this project we provide
9568 tools for all other aspects of internationalization as well, including dates,
9569 weight, temperature, names of physical quantitites, etc.")
9570       (license license:bsd-2))))
9571
9572 (define-public cl-acclimation
9573   (sbcl-package->cl-source-package sbcl-acclimation))
9574
9575 (define-public ecl-acclimation
9576   (sbcl-package->ecl-package sbcl-acclimation))
9577
9578 (define-public sbcl-clump
9579   (let ((commit "1ea4dbac1cb86713acff9ae58727dd187d21048a"))
9580     (package
9581       (name "sbcl-clump")
9582       (version (git-version "0.0.0" "1" commit))
9583       (source
9584        (origin
9585          (method git-fetch)
9586          (uri (git-reference
9587                (url "https://github.com/robert-strandh/Clump")
9588                (commit commit)))
9589          (file-name (git-file-name name version))
9590          (sha256
9591           (base32
9592            "1639msyagsswj85gc0wd90jgh8588j3qg5q70by9s2brf2q6w4lh"))))
9593       (inputs
9594        `(("acclimation" ,sbcl-acclimation)))
9595       (build-system asdf-build-system/sbcl)
9596       (home-page "https://github.com/robert-strandh/Clump")
9597       (synopsis "Collection of tree implementations for Common Lisp")
9598       (description "The purpose of this library is to provide a collection of
9599 implementations of trees.
9600
9601 In contrast to existing libraries such as cl-containers, it does not impose a
9602 particular use for the trees.  Instead, it aims for a stratified design,
9603 allowing client code to choose between different levels of abstraction.
9604
9605 As a consequence of this policy, low-level interfaces are provided where
9606 the concrete representation is exposed, but also high level interfaces
9607 where the trees can be used as search trees or as trees that represent
9608 sequences of objects.")
9609       (license license:bsd-2))))
9610
9611 (define-public cl-clump
9612   (sbcl-package->cl-source-package sbcl-clump))
9613
9614 (define-public ecl-clump
9615   (sbcl-package->ecl-package sbcl-clump))
9616
9617 (define-public sbcl-cluffer
9618   (let ((commit "4aad29c276a58a593064e79972ee4d77cae0af4a"))
9619     (package
9620       (name "sbcl-cluffer")
9621       (version (git-version "0.0.0" "1" commit))
9622       (source
9623        (origin
9624          (method git-fetch)
9625          (uri (git-reference
9626                (url "https://github.com/robert-strandh/cluffer")
9627                (commit commit)))
9628          (file-name (git-file-name name version))
9629          (sha256
9630           (base32
9631            "1bcg13g7qb3dr8z50aihdjqa6miz5ivlc9wsj2csgv1km1mak2kj"))))
9632       (build-system asdf-build-system/sbcl)
9633       (inputs
9634        `(("acclimation" ,sbcl-acclimation)
9635          ("clump" ,sbcl-clump)))
9636       (home-page "https://github.com/robert-strandh/cluffer")
9637       (synopsis "Common Lisp library providing a protocol for text-editor buffers")
9638       (description "Cluffer is a library for representing the buffer of a text
9639 editor.  As such, it defines a set of CLOS protocols for client code to
9640 interact with the buffer contents in various ways, and it supplies different
9641 implementations of those protocols for different purposes.")
9642       (license license:bsd-2))))
9643
9644 (define-public cl-cluffer
9645   (sbcl-package->cl-source-package sbcl-cluffer))
9646
9647 (define-public ecl-cluffer
9648   (sbcl-package->ecl-package sbcl-cluffer))
9649
9650 (define-public sbcl-cl-libsvm-format
9651   (let ((commit "3300f84fd8d9f5beafc114f543f9d83417c742fb")
9652         (revision "0"))
9653     (package
9654       (name "sbcl-cl-libsvm-format")
9655       (version (git-version "0.1.0" revision commit))
9656       (source
9657        (origin
9658          (method git-fetch)
9659          (uri (git-reference
9660                (url "https://github.com/masatoi/cl-libsvm-format")
9661                (commit commit)))
9662          (file-name (git-file-name name version))
9663          (sha256
9664           (base32
9665            "0284aj84xszhkhlivaigf9qj855fxad3mzmv3zfr0qzb5k0nzwrg"))))
9666       (build-system asdf-build-system/sbcl)
9667       (native-inputs
9668        `(("prove" ,sbcl-prove)))
9669       (inputs
9670        `(("alexandria" ,sbcl-alexandria)))
9671       (synopsis "LibSVM data format reader for Common Lisp")
9672       (description
9673        "This Common Lisp library provides a fast reader for data in LibSVM
9674 format.")
9675       (home-page "https://github.com/masatoi/cl-libsvm-format")
9676       (license license:expat))))
9677
9678 (define-public cl-libsvm-format
9679   (sbcl-package->cl-source-package sbcl-cl-libsvm-format))
9680
9681 (define-public ecl-cl-libsvm-format
9682   (sbcl-package->ecl-package sbcl-cl-libsvm-format))
9683
9684 (define-public sbcl-cl-online-learning
9685   (let ((commit "fc7a34f4f161cd1c7dd747d2ed8f698947781423")
9686         (revision "0"))
9687     (package
9688       (name "sbcl-cl-online-learning")
9689       (version (git-version "0.5" revision commit))
9690       (source
9691        (origin
9692          (method git-fetch)
9693          (uri (git-reference
9694                (url "https://github.com/masatoi/cl-online-learning")
9695                (commit commit)))
9696          (file-name (git-file-name name version))
9697          (sha256
9698           (base32
9699            "14x95rlg80ay5hv645ki57pqvy12v28hz4k1w0f6bsfi2rmpxchq"))))
9700       (build-system asdf-build-system/sbcl)
9701       (native-inputs
9702        `(("prove" ,sbcl-prove)))
9703       (inputs
9704        `(("cl-libsvm-format" ,sbcl-cl-libsvm-format)
9705          ("cl-store" ,sbcl-cl-store)))
9706       (arguments
9707        `(;; FIXME: Tests pass but then the check phase crashes
9708          #:tests? #f))
9709       (synopsis "Online Machine Learning for Common Lisp")
9710       (description
9711        "This library contains a collection of machine learning algorithms for
9712 online linear classification written in Common Lisp.")
9713       (home-page "https://github.com/masatoi/cl-online-learning")
9714       (license license:expat))))
9715
9716 (define-public cl-online-learning
9717   (sbcl-package->cl-source-package sbcl-cl-online-learning))
9718
9719 (define-public ecl-cl-online-learning
9720   (sbcl-package->ecl-package sbcl-cl-online-learning))
9721
9722 (define-public sbcl-cl-random-forest
9723   (let ((commit "fedb36ce99bb6f4d7e3a7dd6d8b058f331308f91")
9724         (revision "1"))
9725     (package
9726       (name "sbcl-cl-random-forest")
9727       (version (git-version "0.1" revision commit))
9728       (source
9729        (origin
9730          (method git-fetch)
9731          (uri (git-reference
9732                (url "https://github.com/masatoi/cl-random-forest")
9733                (commit commit)))
9734          (file-name (git-file-name name version))
9735          (sha256
9736           (base32
9737            "0wqh4dxy5hrvm14jgyfypwhdw35f24rsksid4blz5a6l2z16rlmq"))))
9738       (build-system asdf-build-system/sbcl)
9739       (native-inputs
9740        `(("prove" ,sbcl-prove)
9741          ("trivial-garbage" ,sbcl-trivial-garbage)))
9742       (inputs
9743        `(("alexandria" ,sbcl-alexandria)
9744          ("cl-libsvm-format" ,sbcl-cl-libsvm-format)
9745          ("cl-online-learning" ,sbcl-cl-online-learning)
9746          ("lparallel" ,sbcl-lparallel)))
9747       (arguments
9748        `(#:tests? #f)) ; The tests download data from the Internet
9749       (synopsis "Random Forest and Global Refinement for Common Lisp")
9750       (description
9751        "CL-random-forest is an implementation of Random Forest for multiclass
9752 classification and univariate regression written in Common Lisp.  It also
9753 includes an implementation of Global Refinement of Random Forest.")
9754       (home-page "https://github.com/masatoi/cl-random-forest")
9755       (license license:expat))))
9756
9757 (define-public cl-random-forest
9758   (sbcl-package->cl-source-package sbcl-cl-random-forest))
9759
9760 (define-public ecl-cl-random-forest
9761   (sbcl-package->ecl-package sbcl-cl-random-forest))
9762
9763 (define-public sbcl-bordeaux-fft
9764   (let ((commit "4a1f5600cae59bdabcb32de4ee2d7d73a9450d6e")
9765         (revision "0"))
9766     (package
9767       (name "sbcl-bordeaux-fft")
9768       (version (git-version "1.0.1" revision commit))
9769       (source
9770        (origin
9771          (method git-fetch)
9772          (uri (git-reference
9773                (url "https://github.com/ahefner/bordeaux-fft")
9774                (commit commit)))
9775          (file-name (git-file-name name version))
9776          (sha256
9777           (base32 "0j584w6kq2k6r8lp2i14f9605rxhp3r15s33xs08iz1pndn6iwqf"))))
9778       (build-system asdf-build-system/sbcl)
9779       (home-page "http://vintage-digital.com/hefner/software/bordeaux-fft/")
9780       (synopsis "Fast Fourier Transform for Common Lisp")
9781       (description
9782        "The Bordeaux-FFT library provides a reasonably efficient implementation
9783 of the Fast Fourier Transform and its inverse for complex-valued inputs, in
9784 portable Common Lisp.")
9785       (license license:gpl2+))))
9786
9787 (define-public cl-bordeaux-fft
9788   (sbcl-package->cl-source-package sbcl-bordeaux-fft))
9789
9790 (define-public ecl-bordeaux-fft
9791   (sbcl-package->ecl-package sbcl-bordeaux-fft))
9792
9793 (define-public sbcl-napa-fft3
9794   (let ((commit "f2d9614c7167da327c9ceebefb04ff6eae2d2236")
9795         (revision "0"))
9796     (package
9797       (name "sbcl-napa-fft3")
9798       (version (git-version "0.0.1" revision commit))
9799       (source
9800        (origin
9801          (method git-fetch)
9802          (uri (git-reference
9803                (url "https://github.com/pkhuong/Napa-FFT3")
9804                (commit commit)))
9805          (file-name (git-file-name name version))
9806          (sha256
9807           (base32 "1hxjf599xgwm28gbryy7q96j9ys6hfszmv0qxpr5698hxnhknscp"))))
9808       (build-system asdf-build-system/sbcl)
9809       (home-page "https://github.com/pkhuong/Napa-FFT3")
9810       (synopsis "Fast Fourier Transform routines in Common Lisp")
9811       (description
9812        "Napa-FFT3 provides Discrete Fourier Transform (DFT) routines, but also
9813 buildings blocks to express common operations that involve DFTs: filtering,
9814 convolutions, etc.")
9815       (license license:bsd-3))))
9816
9817 (define-public cl-napa-fft3
9818   (sbcl-package->cl-source-package sbcl-napa-fft3))
9819
9820 (define-public sbcl-cl-tga
9821   (let ((commit "4dc2f7b8a259b9360862306640a07a23d4afaacc")
9822         (revision "0"))
9823     (package
9824       (name "sbcl-cl-tga")
9825       (version (git-version "0.0.0" revision commit))
9826       (source
9827        (origin
9828          (method git-fetch)
9829          (uri (git-reference
9830                (url "https://github.com/fisxoj/cl-tga")
9831                (commit commit)))
9832          (file-name (git-file-name name version))
9833          (sha256
9834           (base32 "03k3npmn0xd3fd2m7vwxph82av2xrfb150imqrinlzqmzvz1v1br"))))
9835       (build-system asdf-build-system/sbcl)
9836       (home-page "https://github.com/fisxoj/cl-tga")
9837       (synopsis "TGA file loader for Common Lisp")
9838       (description
9839        "Cl-tga was written to facilitate loading @emph{.tga} files into OpenGL
9840 programs.  It's a very simple library, and, at the moment, only supports
9841 non-RLE encoded forms of the files.")
9842       (license license:expat))))
9843
9844 (define-public cl-tga
9845   (sbcl-package->cl-source-package sbcl-cl-tga))
9846
9847 (define-public ecl-cl-tga
9848   (sbcl-package->ecl-package sbcl-cl-tga))
9849
9850 (define-public sbcl-com.gigamonkeys.binary-data
9851   (let ((commit "22e908976d7f3e2318b7168909f911b4a00963ee")
9852         (revision "0"))
9853     (package
9854       (name "sbcl-com.gigamonkeys.binary-data")
9855       (version (git-version "0.0.0" revision commit))
9856       (source
9857        (origin
9858          (method git-fetch)
9859          (uri (git-reference
9860                (url "https://github.com/gigamonkey/monkeylib-binary-data")
9861                (commit commit)))
9862          (file-name (git-file-name name version))
9863          (sha256
9864           (base32 "072v417vmcnvmyh8ddq9vmwwrizm7zwz9dpzi14qy9nsw8q649zw"))))
9865       (build-system asdf-build-system/sbcl)
9866       (inputs
9867        `(("alexandria" ,sbcl-alexandria)))
9868       (home-page "https://github.com/gigamonkey/monkeylib-binary-data")
9869       (synopsis "Common Lisp library for reading and writing binary data")
9870       (description
9871        "This a Common Lisp library for reading and writing binary data.  It is
9872 based on code from chapter 24 of the book @emph{Practical Common Lisp}.")
9873       (license license:bsd-3))))
9874
9875 (define-public cl-com.gigamonkeys.binary-data
9876   (sbcl-package->cl-source-package sbcl-com.gigamonkeys.binary-data))
9877
9878 (define-public ecl-com.gigamonkeys.binary-data
9879   (sbcl-package->ecl-package sbcl-com.gigamonkeys.binary-data))
9880
9881 (define-public sbcl-deflate
9882   (package
9883     (name "sbcl-deflate")
9884     (version "1.0.3")
9885     (source
9886      (origin
9887        (method git-fetch)
9888        (uri (git-reference
9889              (url "https://github.com/pmai/Deflate")
9890              (commit (string-append "release-" version))))
9891        (file-name (git-file-name name version))
9892        (sha256
9893         (base32 "1jpdjnxh6cw2d8hk70r2sxn92is52s9b855irvwkdd777fdciids"))))
9894     (build-system asdf-build-system/sbcl)
9895     (home-page "https://github.com/pmai/Deflate")
9896     (synopsis "Native deflate decompression for Common Lisp")
9897     (description
9898      "This library is an implementation of Deflate (RFC 1951) decompression,
9899 with optional support for ZLIB-style (RFC 1950) and gzip-style (RFC 1952)
9900 wrappers of deflate streams.  It currently does not handle compression.")
9901     (license license:expat)))
9902
9903 (define-public cl-deflate
9904   (sbcl-package->cl-source-package sbcl-deflate))
9905
9906 (define-public ecl-deflate
9907   (sbcl-package->ecl-package sbcl-deflate))
9908
9909 (define-public sbcl-skippy
9910   (let ((commit "e456210202ca702c792292c5060a264d45e47090")
9911         (revision "0"))
9912     (package
9913       (name "sbcl-skippy")
9914       (version (git-version "1.3.12" revision commit))
9915       (source
9916        (origin
9917          (method git-fetch)
9918          (uri (git-reference
9919                (url "https://github.com/xach/skippy")
9920                (commit commit)))
9921          (file-name (git-file-name name version))
9922          (sha256
9923           (base32 "1sxbn5nh24qpx9w64x8mhp259cxcl1x8p126wk3b91ijjsj7l5vj"))))
9924       (build-system asdf-build-system/sbcl)
9925       (home-page "https://xach.com/lisp/skippy/")
9926       (synopsis "Common Lisp library for GIF images")
9927       (description
9928        "Skippy is a Common Lisp library to read and write GIF image files.")
9929       (license license:bsd-2))))
9930
9931 (define-public cl-skippy
9932   (sbcl-package->cl-source-package sbcl-skippy))
9933
9934 (define-public ecl-skippy
9935   (sbcl-package->ecl-package sbcl-skippy))
9936
9937 (define-public sbcl-cl-freetype2
9938   (let ((commit "96058da730b4812df916c1f4ee18c99b3b15a3de")
9939         (revision "0"))
9940     (package
9941       (name "sbcl-cl-freetype2")
9942       (version (git-version "1.1" revision commit))
9943       (source
9944        (origin
9945          (method git-fetch)
9946          (uri (git-reference
9947                (url "https://github.com/rpav/cl-freetype2")
9948                (commit commit)))
9949          (file-name (git-file-name name version))
9950          (sha256
9951           (base32 "0f8darhairgxnb5bzqcny7nh7ss3471bdzix5rzcyiwdbr5kymjl"))))
9952       (build-system asdf-build-system/sbcl)
9953       (native-inputs
9954        `(("fiveam" ,sbcl-fiveam)))
9955       (inputs
9956        `(("alexandria" ,sbcl-alexandria)
9957          ("cffi" ,sbcl-cffi)
9958          ("freetype" ,freetype)
9959          ("trivial-garbage" ,sbcl-trivial-garbage)))
9960       (arguments
9961        `(#:phases
9962          (modify-phases %standard-phases
9963            (add-after 'unpack 'fix-paths
9964              (lambda* (#:key inputs #:allow-other-keys)
9965                (substitute* "src/ffi/ft2-lib.lisp"
9966                  (("\"libfreetype\"")
9967                   (string-append "\"" (assoc-ref inputs "freetype")
9968                                  "/lib/libfreetype\"")))
9969                (substitute* "src/ffi/grovel/grovel-freetype2.lisp"
9970                  (("-I/usr/include/freetype")
9971                   (string-append "-I" (assoc-ref inputs "freetype")
9972                                  "/include/freetype")))
9973                #t)))))
9974       (home-page "https://github.com/rpav/cl-freetype2")
9975       (synopsis "Common Lisp bindings for Freetype 2")
9976       (description
9977        "This is a general Freetype 2 wrapper for Common Lisp using CFFI.  It's
9978 geared toward both using Freetype directly by providing a simplified API, as
9979 well as providing access to the underlying C structures and functions for use
9980 with other libraries which may also use Freetype.")
9981       (license license:bsd-3))))
9982
9983 (define-public cl-freetype2
9984   (sbcl-package->cl-source-package sbcl-cl-freetype2))
9985
9986 (define-public ecl-cl-freetype2
9987   (sbcl-package->ecl-package sbcl-cl-freetype2))
9988
9989 (define-public sbcl-opticl-core
9990   (let ((commit "b7cd13d26df6b824b216fbc360dc27bfadf04999")
9991         (revision "0"))
9992     (package
9993       (name "sbcl-opticl-core")
9994       (version (git-version "0.0.0" revision commit))
9995       (source
9996        (origin
9997          (method git-fetch)
9998          (uri (git-reference
9999                (url "https://github.com/slyrus/opticl-core")
10000                (commit commit)))
10001          (file-name (git-file-name name version))
10002          (sha256
10003           (base32 "0458bllabcdjghfrqx6aki49c9qmvfmkk8jl75cfpi7q0i12kh95"))))
10004       (build-system asdf-build-system/sbcl)
10005       (inputs
10006        `(("alexandria" ,sbcl-alexandria)))
10007       (home-page "https://github.com/slyrus/opticl-core")
10008       (synopsis "Core classes and pixel access macros for Opticl")
10009       (description
10010        "This Common Lisp library contains the core classes and pixel access
10011 macros for the Opticl image processing library.")
10012       (license license:bsd-2))))
10013
10014 (define-public cl-opticl-core
10015   (sbcl-package->cl-source-package sbcl-opticl-core))
10016
10017 (define-public ecl-opticl-core
10018   (sbcl-package->ecl-package sbcl-opticl-core))
10019
10020 (define-public sbcl-retrospectiff
10021   (let ((commit "c2a69d77d5010f8cdd9045b3e36a08a73da5d321")
10022         (revision "0"))
10023     (package
10024       (name "sbcl-retrospectiff")
10025       (version (git-version "0.2" revision commit))
10026       (source
10027        (origin
10028          (method git-fetch)
10029          (uri (git-reference
10030                (url "https://github.com/slyrus/retrospectiff")
10031                (commit commit)))
10032          (file-name (git-file-name name version))
10033          (sha256
10034           (base32 "0qsn9hpd8j2kp43dk05j8dczz9zppdff5rrclbp45n3ksk9inw8i"))))
10035       (build-system asdf-build-system/sbcl)
10036       (native-inputs
10037        `(("fiveam" ,sbcl-fiveam)))
10038       (inputs
10039        `(("cl-jpeg" ,sbcl-cl-jpeg)
10040          ("com.gigamonkeys.binary-data" ,sbcl-com.gigamonkeys.binary-data)
10041          ("deflate" ,sbcl-deflate)
10042          ("flexi-streams" ,sbcl-flexi-streams)
10043          ("ieee-floats" ,sbcl-ieee-floats)
10044          ("opticl-core" ,sbcl-opticl-core)))
10045       (home-page "https://github.com/slyrus/retrospectiff")
10046       (synopsis "Common Lisp library for TIFF images")
10047       (description
10048        "Retrospectiff is a common lisp library for reading and writing images
10049 in the TIFF (Tagged Image File Format) format.")
10050       (license license:bsd-2))))
10051
10052 (define-public cl-retrospectif
10053   (sbcl-package->cl-source-package sbcl-retrospectiff))
10054
10055 (define-public ecl-retrospectiff
10056   (sbcl-package->ecl-package sbcl-retrospectiff))
10057
10058 (define-public sbcl-mmap
10059   (let ((commit "ba2e98c67e25f0fb8ff838238561120a23903ce7")
10060         (revision "0"))
10061     (package
10062       (name "sbcl-mmap")
10063       (version (git-version "1.0.0" revision commit))
10064       (source
10065        (origin
10066          (method git-fetch)
10067          (uri (git-reference
10068                (url "https://github.com/Shinmera/mmap")
10069                (commit commit)))
10070          (file-name (git-file-name name version))
10071          (sha256
10072           (base32 "0qd0xp20i1pcfn12kkapv9pirb6hd4ns7kz4zf1mmjwykpsln96q"))))
10073       (build-system asdf-build-system/sbcl)
10074       (native-inputs
10075        `(("alexandria" ,sbcl-alexandria)
10076          ("cffi" ,sbcl-cffi)
10077          ("parachute" ,sbcl-parachute)
10078          ("trivial-features" ,sbcl-trivial-features)))
10079       (inputs
10080        `(("cffi" ,sbcl-cffi)
10081          ("documentation-utils" ,sbcl-documentation-utils)))
10082       (home-page "https://shinmera.github.io/mmap/")
10083       (synopsis "File memory mapping for Common Lisp")
10084       (description
10085        "This is a utility library providing access to the @emph{mmap} family of
10086 functions in a portable way.  It allows you to directly map a file into the
10087 address space of your process without having to manually read it into memory
10088 sequentially.  Typically this is much more efficient for files that are larger
10089 than a few Kb.")
10090       (license license:zlib))))
10091
10092 (define-public cl-mmap
10093   (sbcl-package->cl-source-package sbcl-mmap))
10094
10095 (define-public ecl-mmap
10096   (sbcl-package->ecl-package sbcl-mmap))
10097
10098 (define-public sbcl-3bz
10099   (let ((commit "d6119083b5e0b0a6dd3abc2877936c51f3f3deed")
10100         (revision "0"))
10101     (package
10102       (name "sbcl-3bz")
10103       (version (git-version "0.0.0" revision commit))
10104       (source
10105        (origin
10106          (method git-fetch)
10107          (uri (git-reference
10108                (url "https://github.com/3b/3bz")
10109                (commit commit)))
10110          (file-name (git-file-name name version))
10111          (sha256
10112           (base32 "0fyxzyf2b6sc0w8d9g4nlva861565z6f3xszj0lw29x526dd9rhj"))))
10113       (build-system asdf-build-system/sbcl)
10114       (inputs
10115        `(("alexandria" ,sbcl-alexandria)
10116          ("babel" ,sbcl-babel)
10117          ("cffi" ,sbcl-cffi)
10118          ("mmap" ,sbcl-mmap)
10119          ("nibbles" ,sbcl-nibbles)
10120          ("trivial-features" ,sbcl-trivial-features)))
10121       (arguments
10122        ;; FIXME: Without the following line, the build fails (see issue 41437).
10123        `(#:asd-systems '("3bz")))
10124       (home-page "https://github.com/3b/3bz")
10125       (synopsis "Deflate decompression for Common Lisp")
10126       (description
10127        "3bz is an implementation of Deflate decompression (RFC 1951) optionally
10128 with zlib (RFC 1950) or gzip (RFC 1952) wrappers, with support for reading from
10129 foreign pointers (for use with mmap and similar, etc), and from CL octet
10130 vectors and streams.")
10131       (license license:expat))))
10132
10133 (define-public cl-3bz
10134   (sbcl-package->cl-source-package sbcl-3bz))
10135
10136 (define-public ecl-3bz
10137   (sbcl-package->ecl-package sbcl-3bz))
10138
10139 (define-public sbcl-zpb-exif
10140   (package
10141     (name "sbcl-zpb-exif")
10142     (version "1.2.4")
10143     (source
10144      (origin
10145        (method git-fetch)
10146        (uri (git-reference
10147              (url "https://github.com/xach/zpb-exif")
10148              (commit (string-append "release-" version))))
10149        (file-name (git-file-name name version))
10150        (sha256
10151         (base32 "15s227jhby55cisz14xafb0p1ws2jmrg2rrbbd00lrb97im84hy6"))))
10152     (build-system asdf-build-system/sbcl)
10153     (home-page "https://xach.com/lisp/zpb-exif/")
10154     (synopsis "EXIF information extractor for Common Lisp")
10155     (description
10156      "This is a Common Lisp library to extract EXIF information from image
10157 files.")
10158     (license license:bsd-2)))
10159
10160 (define-public cl-zpb-exif
10161   (sbcl-package->cl-source-package sbcl-zpb-exif))
10162
10163 (define-public ecl-zpb-exif
10164   (sbcl-package->ecl-package sbcl-zpb-exif))
10165
10166 (define-public sbcl-pngload
10167   (package
10168     (name "sbcl-pngload")
10169     (version "2.0.0")
10170     (source
10171      (origin
10172        (method git-fetch)
10173        (uri (git-reference
10174              (url "https://github.com/bufferswap/pngload")
10175              (commit version)))
10176        (file-name (git-file-name name version))
10177        (sha256
10178         (base32 "1ix8dd0fxlf8xm0bszh1s7sx83hn0vqq8b8c9gkrd5m310w8mpvh"))))
10179     (build-system asdf-build-system/sbcl)
10180     (inputs
10181      `(("3bz" ,sbcl-3bz)
10182        ("alexandria" ,sbcl-alexandria)
10183        ("cffi" ,sbcl-cffi)
10184        ("mmap" ,sbcl-mmap)
10185        ("parse-float" ,sbcl-parse-float)
10186        ("static-vectors" ,sbcl-static-vectors)
10187        ("swap-bytes" ,sbcl-swap-bytes)
10188        ("zpb-exif" ,sbcl-zpb-exif)))
10189     (arguments
10190      ;; Test suite disabled because of a dependency cycle.
10191      ;; pngload tests depend on opticl which depends on pngload.
10192      '(#:tests? #f))
10193     (home-page "https://github.com/bufferswap/pngload")
10194     (synopsis "PNG image decoder for Common Lisp")
10195     (description
10196      "This is a Common Lisp library to load images in the PNG image format,
10197 both from files on disk, or streams in memory.")
10198     (license license:expat)))
10199
10200 (define-public cl-pngload
10201   (sbcl-package->cl-source-package sbcl-pngload))
10202
10203 (define-public ecl-pngload
10204   (sbcl-package->ecl-package sbcl-pngload))
10205
10206 (define-public sbcl-opticl
10207   (let ((commit "e8684416eca2e78e82a7b436d436ef2ea24c019d")
10208         (revision "0"))
10209     (package
10210       (name "sbcl-opticl")
10211       (version (git-version "0.0.0" revision commit))
10212       (source
10213        (origin
10214          (method git-fetch)
10215          (uri (git-reference
10216                (url "https://github.com/slyrus/opticl")
10217                (commit commit)))
10218          (file-name (git-file-name name version))
10219          (sha256
10220           (base32 "03rirnnhhisjbimlmpi725h1d3x0cfv00r57988am873dyzawmm1"))))
10221       (build-system asdf-build-system/sbcl)
10222       (native-inputs
10223        `(("fiveam" ,sbcl-fiveam)))
10224       (inputs
10225        `(("alexandria" ,sbcl-alexandria)
10226          ("cl-jpeg" ,sbcl-cl-jpeg)
10227          ("cl-tga" ,sbcl-cl-tga)
10228          ("png-read" ,sbcl-png-read)
10229          ("pngload" ,sbcl-pngload)
10230          ("retrospectiff" ,sbcl-retrospectiff)
10231          ("skippy" ,sbcl-skippy)
10232          ("zpng" ,sbcl-zpng)))
10233       (arguments
10234        '(#:asd-files '("opticl.asd")))
10235       (home-page "https://github.com/slyrus/opticl")
10236       (synopsis "Image processing library for Common Lisp")
10237       (description
10238        "Opticl is a Common Lisp library for representing, processing, loading,
10239 and saving 2-dimensional pixel-based images.")
10240       (license license:bsd-2))))
10241
10242 (define-public cl-opticl
10243   (sbcl-package->cl-source-package sbcl-opticl))
10244
10245 (define-public ecl-opticl
10246   (sbcl-package->ecl-package sbcl-opticl))
10247
10248 (define-public sbcl-mcclim
10249   (let ((commit "27b4d7a667c9b3faa74cabcb57706b888314fff7")
10250         (revision "0"))
10251     (package
10252       (name "sbcl-mcclim")
10253       (version (git-version "0.9.7" revision commit))
10254       (source
10255        (origin
10256          (method git-fetch)
10257          (uri (git-reference
10258                (url "https://github.com/mcclim/mcclim")
10259                (commit commit)))
10260          (file-name (git-file-name name version))
10261          (sha256
10262           (base32 "0jijfgkwas6xnpp5wiii6slcx9pgsalngacb8zm29x6pamx2193h"))))
10263       (build-system asdf-build-system/sbcl)
10264       (native-inputs
10265        `(("fiveam" ,sbcl-fiveam)
10266          ("pkg-config" ,pkg-config)))
10267       (inputs
10268        `(("alexandria" ,sbcl-alexandria)
10269          ("babel" ,sbcl-babel)
10270          ("bordeaux-threads" ,sbcl-bordeaux-threads)
10271          ("cl-freetype2" ,sbcl-cl-freetype2)
10272          ("cl-pdf" ,sbcl-cl-pdf)
10273          ("cffi" ,sbcl-cffi)
10274          ("cl-unicode" ,sbcl-cl-unicode)
10275          ("cl-vectors" ,sbcl-cl-vectors)
10276          ("closer-mop" ,sbcl-closer-mop)
10277          ("clx" ,sbcl-clx)
10278          ("flexi-streams" ,sbcl-flexi-streams)
10279          ("flexichain" ,sbcl-flexichain)
10280          ("font-dejavu" ,font-dejavu)
10281          ("fontconfig" ,fontconfig)
10282          ("freetype" ,freetype)
10283          ("harfbuzz" ,harfbuzz)
10284          ("log4cl" ,sbcl-log4cl)
10285          ("opticl" ,sbcl-opticl)
10286          ("spatial-trees" ,sbcl-spatial-trees)
10287          ("swank" ,sbcl-slime-swank)
10288          ("trivial-features" ,sbcl-trivial-features)
10289          ("trivial-garbage" ,sbcl-trivial-garbage)
10290          ("trivial-gray-streams" ,sbcl-trivial-gray-streams)
10291          ("zpb-ttf" ,sbcl-zpb-ttf)))
10292       (arguments
10293        '(#:asd-systems '("mcclim"
10294                          "clim-examples")
10295          #:phases
10296          (modify-phases %standard-phases
10297            (add-after 'unpack 'fix-paths
10298              (lambda* (#:key inputs #:allow-other-keys)
10299                ;; mcclim-truetype uses DejaVu as default font and
10300                ;; sets the path at build time.
10301                (substitute* "Extensions/fonts/fontconfig.lisp"
10302                  (("/usr/share/fonts/truetype/dejavu/")
10303                   (string-append (assoc-ref inputs "font-dejavu")
10304                                  "/share/fonts/truetype/")))
10305                (substitute* "Extensions/fontconfig/src/functions.lisp"
10306                  (("libfontconfig\\.so")
10307                   (string-append (assoc-ref inputs "fontconfig")
10308                                  "/lib/libfontconfig.so")))
10309                (substitute* "Extensions/harfbuzz/src/functions.lisp"
10310                  (("libharfbuzz\\.so")
10311                   (string-append (assoc-ref inputs "harfbuzz")
10312                                  "/lib/libharfbuzz.so")))
10313                #t))
10314            (add-after 'unpack 'fix-build
10315              (lambda _
10316                ;; The cffi-grovel system does not get loaded automatically,
10317                ;; so we load it explicitly.
10318                (substitute* "Extensions/fontconfig/mcclim-fontconfig.asd"
10319                  (("\\(asdf:defsystem #:mcclim-fontconfig" all)
10320                   (string-append "(asdf:load-system :cffi-grovel)\n" all)))
10321                (substitute* "Extensions/harfbuzz/mcclim-harfbuzz.asd"
10322                  (("\\(asdf:defsystem #:mcclim-harfbuzz" all)
10323                   (string-append "(asdf:load-system :cffi-grovel)\n" all)))
10324                #t)))))
10325       (home-page "https://common-lisp.net/project/mcclim/")
10326       (synopsis "Common Lisp GUI toolkit")
10327       (description
10328        "McCLIM is an implementation of the @emph{Common Lisp Interface Manager
10329 specification}, a toolkit for writing GUIs in Common Lisp.")
10330       (license license:lgpl2.1+))))
10331
10332 (define-public cl-mcclim
10333   (sbcl-package->cl-source-package sbcl-mcclim))
10334
10335 (define-public ecl-mcclim
10336   (sbcl-package->ecl-package sbcl-mcclim))
10337
10338 (define-public sbcl-cl-inflector
10339   (let ((commit "f1ab16919ccce3bd82a0042677d9616dde2034fe")
10340         (revision "1"))
10341     (package
10342       (name "sbcl-cl-inflector")
10343       (version (git-version "0.2" revision commit))
10344       (source
10345        (origin
10346          (method git-fetch)
10347          (uri (git-reference
10348                (url "https://github.com/AccelerationNet/cl-inflector")
10349                (commit commit)))
10350          (file-name (git-file-name name version))
10351          (sha256
10352           (base32 "1xwwlhik1la4fp984qnx2dqq24v012qv4x0y49sngfpwg7n0ya7y"))))
10353       (build-system asdf-build-system/sbcl)
10354       (native-inputs
10355        `(("lisp-unit2" ,sbcl-lisp-unit2)))
10356       (inputs
10357        `(("alexandria" ,sbcl-alexandria)
10358          ("cl-ppcre" ,sbcl-cl-ppcre)))
10359       (home-page "https://github.com/AccelerationNet/cl-inflector")
10360       (synopsis "Library to pluralize/singularize English and Portuguese words")
10361       (description
10362        "This is a common lisp library to easily pluralize and singularize
10363 English and Portuguese words.  This is a port of the ruby ActiveSupport
10364 Inflector module.")
10365       (license license:expat))))
10366
10367 (define-public cl-inflector
10368   (sbcl-package->cl-source-package sbcl-cl-inflector))
10369
10370 (define-public ecl-cl-inflector
10371   (sbcl-package->ecl-package sbcl-cl-inflector))
10372
10373 (define-public sbcl-qbase64
10374   (package
10375     (name "sbcl-qbase64")
10376     (version "0.3.0")
10377     (source
10378      (origin
10379        (method git-fetch)
10380        (uri (git-reference
10381              (url "https://github.com/chaitanyagupta/qbase64")
10382              (commit version)))
10383        (file-name (git-file-name name version))
10384        (sha256
10385         (base32 "1dir0s70ca3hagxv9x15zq4p4ajgl7jrcgqsza2n2y7iqbxh0dwi"))))
10386     (build-system asdf-build-system/sbcl)
10387     (inputs
10388      `(("metabang-bind" ,sbcl-metabang-bind)
10389        ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
10390     (native-inputs
10391      `(("fiveam" ,sbcl-fiveam)))
10392     (home-page "https://github.com/chaitanyagupta/qbase64")
10393     (synopsis "Base64 encoder and decoder for Common Lisp")
10394     (description "@code{qbase64} provides a fast and flexible base64 encoder
10395 and decoder for Common Lisp.")
10396     (license license:bsd-3)))
10397
10398 (define-public cl-qbase64
10399   (sbcl-package->cl-source-package sbcl-qbase64))
10400
10401 (define-public ecl-qbase64
10402   (sbcl-package->ecl-package sbcl-qbase64))
10403
10404 (define-public sbcl-hu.dwim.common-lisp
10405   (package
10406     (name "sbcl-hu.dwim.common-lisp")
10407     (version "2015-07-09")
10408     (source
10409      (origin
10410        (method url-fetch)
10411        (uri (string-append
10412              "http://beta.quicklisp.org/archive/hu.dwim.common-lisp/"
10413              version "/hu.dwim.common-lisp-"
10414              (string-replace-substring version "-" "")
10415              "-darcs.tgz"))
10416        (sha256
10417         (base32 "13cxrvh55rw080mvfir7s7k735l9rcfh3khxp97qfwd5rz0gadb9"))))
10418     (build-system asdf-build-system/sbcl)
10419     (native-inputs
10420      `(("hu.dwim.asdf" ,sbcl-hu.dwim.asdf)))
10421     (home-page "http://dwim.hu/")
10422     (synopsis "Redefine some standard Common Lisp names")
10423     (description "This library is a redefinition of the standard Common Lisp
10424 package that includes a number of renames and shadows. ")
10425     (license license:public-domain)))
10426
10427 (define-public cl-hu.dwim.common-lisp
10428   (sbcl-package->cl-source-package sbcl-hu.dwim.common-lisp))
10429
10430 (define-public ecl-hu.dwim.common-lisp
10431   (sbcl-package->ecl-package sbcl-hu.dwim.common-lisp))
10432
10433 (define-public sbcl-hu.dwim.common
10434   (package
10435     (name "sbcl-hu.dwim.common")
10436     (version "2015-07-09")
10437     (source
10438      (origin
10439        (method url-fetch)
10440        (uri (string-append
10441              "http://beta.quicklisp.org/archive/hu.dwim.common/"
10442              version "/hu.dwim.common-"
10443              (string-replace-substring version "-" "")
10444              "-darcs.tgz"))
10445        (sha256
10446         (base32 "12l1rr6w9m99w0b5gc6hv58ainjfhbc588kz6vwshn4gqsxyzbhp"))))
10447     (build-system asdf-build-system/sbcl)
10448     (native-inputs
10449      `(("hu.dwim.asdf" ,sbcl-hu.dwim.asdf)))
10450     (inputs
10451      `(("alexandria" ,sbcl-alexandria)
10452        ("anaphora" ,sbcl-anaphora)
10453        ("closer-mop" ,sbcl-closer-mop)
10454        ("hu.dwim.common-lisp" ,sbcl-hu.dwim.common-lisp)
10455        ("iterate" ,sbcl-iterate)
10456        ("metabang-bind" ,sbcl-metabang-bind)))
10457     (home-page "http://dwim.hu/")
10458     (synopsis "Common Lisp library shared by other hu.dwim systems")
10459     (description "")
10460     (license license:public-domain)))
10461
10462 (define-public cl-hu.dwim.common
10463   (sbcl-package->cl-source-package sbcl-hu.dwim.common))
10464
10465 (define-public ecl-hu.dwim.common
10466   (sbcl-package->ecl-package sbcl-hu.dwim.common))
10467
10468 (define-public sbcl-hu.dwim.defclass-star
10469   (package
10470     (name "sbcl-hu.dwim.defclass-star")
10471     (version "2015-07-09")
10472     (source
10473      (origin
10474        (method url-fetch)
10475        (uri (string-append
10476              "http://beta.quicklisp.org/archive/hu.dwim.defclass-star/"
10477              version "/hu.dwim.defclass-star-"
10478              (string-replace-substring version "-" "")
10479              "-darcs.tgz"))
10480        (sha256
10481         (base32 "032982lyp0hm0ssxlyh572whi2hr4j1nqkyqlllaj373v0dbs3vs"))))
10482     (build-system asdf-build-system/sbcl)
10483     (native-inputs
10484      `(;; These 2 inputs are only needed tests which are disabled, see below.
10485        ;; ("hu.dwim.common" ,sbcl-hu.dwim.common)
10486        ;; Need cl- package for the :hu.dwim.stefil+hu.dwim.def+swank system.
10487        ;; ("hu.dwim.stefil" ,cl-hu.dwim.stefil)
10488        ("hu.dwim.asdf" ,sbcl-hu.dwim.asdf)))
10489     (arguments
10490      `(#:test-asd-file "hu.dwim.defclass-star.test.asd"
10491        ;; Tests require a circular dependency: hu.dwim.stefil -> hu.dwim.def
10492        ;; -> hu.dwim.util -> hu.dwim.defclass-star.
10493        #:tests? #f))
10494     (home-page "http://dwim.hu/?_x=dfxn&_f=mRIMfonK")
10495     (synopsis "Simplify definitions with defclass* and friends in Common Lisp")
10496     (description "@code{defclass-star} provides defclass* and defcondition* to
10497 simplify class and condition declarations.  Features include:
10498
10499 @itemize
10500 @item Automatically export all or select slots at compile time.
10501 @item Define the @code{:initarg} and @code{:accesor} automatically.
10502 @item Specify a name transformer for both the @code{:initarg} and
10503 @code{:accessor}, etc.
10504 @item Specify the @code{:initform} as second slot value.
10505 @end itemize
10506
10507 See
10508 @url{https://common-lisp.net/project/defclass-star/configuration.lisp.html}
10509 for an example.")
10510     (license license:public-domain)))
10511
10512 (define-public cl-hu.dwim.defclass-star
10513   (sbcl-package->cl-source-package sbcl-hu.dwim.defclass-star))
10514
10515 (define-public ecl-hu.dwim.defclass-star
10516   (sbcl-package->ecl-package sbcl-hu.dwim.defclass-star))
10517
10518 (define-public sbcl-livesupport
10519   (let ((commit "71e6e412df9f3759ad8378fabb203913d82e228a")
10520         (revision "1"))
10521     (package
10522       (name "sbcl-livesupport")
10523       (version (git-version "0.0.0" revision commit))
10524       (source
10525        (origin
10526          (method git-fetch)
10527          (uri (git-reference
10528                (url "https://github.com/cbaggers/livesupport")
10529                (commit commit)))
10530          (file-name (git-file-name name version))
10531          (sha256
10532           (base32 "1rvnl0mncylbx63608pz5llss7y92j7z3ydambk9mcnjg2mjaapg"))))
10533       (build-system asdf-build-system/sbcl)
10534       (home-page "https://github.com/cbaggers/livesupport")
10535       (synopsis "Some helpers that make livecoding a little easier")
10536       (description "This package provides a macro commonly used in livecoding to
10537 enable continuing when errors are raised.  Simply wrap around a chunk of code
10538 and it provides a restart called @code{continue} which ignores the error and
10539 carrys on from the end of the body.")
10540       (license license:bsd-2))))
10541
10542 (define-public cl-livesupport
10543   (sbcl-package->cl-source-package sbcl-livesupport))
10544
10545 (define-public ecl-livesupport
10546   (sbcl-package->ecl-package sbcl-livesupport))
10547
10548 (define-public sbcl-envy
10549   (let ((commit "956321b2852d58ba71c6fe621f5c2924178e9f88")
10550         (revision "1"))
10551     (package
10552       (name "sbcl-envy")
10553       (version (git-version "0.1" revision commit))
10554       (home-page "https://github.com/fukamachi/envy")
10555       (source
10556        (origin
10557          (method git-fetch)
10558          (uri (git-reference
10559                (url home-page)
10560                (commit commit)))
10561          (file-name (git-file-name name version))
10562          (sha256
10563           (base32 "17iwrfxcdinjbb2h6l09qf40s7xkbhrpmnljlwpjy8l8rll8h3vg"))))
10564       (build-system asdf-build-system/sbcl)
10565       ;; (native-inputs ; Only for tests.
10566       ;;  `(("prove" ,sbcl-prove)
10567       ;;    ("osicat" ,sbcl-osicat)))
10568       (arguments
10569        '(#:phases
10570          (modify-phases %standard-phases
10571            (add-after 'unpack 'fix-tests
10572              (lambda _
10573                (substitute* "envy-test.asd"
10574                  (("cl-test-more") "prove"))
10575                #t)))
10576          ;; Tests fail with
10577          ;;   Component ENVY-ASD::ENVY-TEST not found, required by #<SYSTEM "envy">
10578          ;; like xsubseq.  Why?
10579          #:tests? #f))
10580       (synopsis "Common Lisp configuration switcher inspired by Perl's Config::ENV.")
10581       (description "Envy is a configuration manager for various applications.
10582 Envy uses an environment variable to determine a configuration to use.  This
10583 can separate configuration system from an implementation.")
10584       (license license:bsd-2))))
10585
10586 (define-public cl-envy
10587   (sbcl-package->cl-source-package sbcl-envy))
10588
10589 (define-public ecl-envy
10590   (sbcl-package->ecl-package sbcl-envy))
10591
10592 (define-public sbcl-mito
10593   (let ((commit "d3b9e375ef364a65692da2185085a08c969ac88a")
10594         (revision "1"))
10595     (package
10596       (name "sbcl-mito")
10597       (version (git-version "0.1" revision commit))
10598       (home-page "https://github.com/fukamachi/mito")
10599       (source
10600        (origin
10601          (method git-fetch)
10602          (uri (git-reference
10603                (url home-page)
10604                (commit commit)))
10605          (file-name (git-file-name name version))
10606          (sha256
10607           (base32 "08mncgzjnbbsf1a6am3l73iw4lyfvz5ldjg5g84awfaxml4p73mb"))))
10608       (build-system asdf-build-system/sbcl)
10609       (native-inputs
10610        `(("prove" ,sbcl-prove)))
10611       (inputs
10612        `(("alexandria" ,sbcl-alexandria)
10613          ("cl-ppcre" ,sbcl-cl-ppcre)
10614          ("cl-reexport" ,sbcl-cl-reexport)
10615          ("closer-mop" ,sbcl-closer-mop)
10616          ("dbi" ,sbcl-dbi)
10617          ("dissect" ,sbcl-dissect)
10618          ("esrap" ,sbcl-esrap)
10619          ("local-time" ,sbcl-local-time)
10620          ("optima" ,sbcl-optima)
10621          ("sxql" ,sbcl-sxql)
10622          ("uuid" ,sbcl-uuid)))
10623       (arguments
10624        '(#:phases
10625          (modify-phases %standard-phases
10626            (add-after 'unpack 'remove-non-functional-tests
10627              (lambda _
10628                (substitute* "mito-test.asd"
10629                  (("\\(:test-file \"db/mysql\"\\)") "")
10630                  (("\\(:test-file \"db/postgres\"\\)") "")
10631                  (("\\(:test-file \"dao\"\\)") "")
10632                  ;; TODO: migration/sqlite3 should work, re-enable once
10633                  ;; upstream has fixed it:
10634                  ;; https://github.com/fukamachi/mito/issues/70
10635                  (("\\(:test-file \"migration/sqlite3\"\\)") "")
10636                  (("\\(:test-file \"migration/mysql\"\\)") "")
10637                  (("\\(:test-file \"migration/postgres\"\\)") "")
10638                  (("\\(:test-file \"postgres-types\"\\)") "")
10639                  (("\\(:test-file \"mixin\"\\)") ""))
10640                #t)))
10641          ;; TODO: While all enabled tests pass, the phase fails with:
10642          ;; Component MITO-ASD::MITO-TEST not found, required by #<SYSTEM "mito">
10643          #:tests? #f))
10644       (synopsis "ORM for Common Lisp with migrations and relationships support")
10645       (description "Mito is yet another object relational mapper, and it aims
10646 to be a successor of Integral.
10647
10648 @itemize
10649 @item Support MySQL, PostgreSQL and SQLite3.
10650 @item Add id (serial/uuid primary key), created_at and updated_at by default
10651 like Ruby's ActiveRecord.
10652 @item Migrations.
10653 @item Database schema versioning.
10654 @end itemize\n")
10655       (license license:llgpl))))
10656
10657 (define-public cl-mito
10658   (sbcl-package->cl-source-package sbcl-mito))
10659
10660 (define-public ecl-mito
10661   (sbcl-package->ecl-package sbcl-mito))
10662
10663 (define-public sbcl-kebab
10664   (let ((commit "e7f77644c4e46131e7b8039d191d35fe6211f31b")
10665         (revision "1"))
10666     (package
10667       (name "sbcl-kebab")
10668       (version (git-version "0.1" revision commit))
10669       (home-page "https://github.com/pocket7878/kebab")
10670       (source
10671        (origin
10672          (method git-fetch)
10673          (uri (git-reference
10674                (url home-page)
10675                (commit commit)))
10676          (file-name (git-file-name name version))
10677          (sha256
10678           (base32 "0j5haabnvj0vz0rx9mwyfsb3qzpga9nickbjw8xs6vypkdzlqv1b"))))
10679       (build-system asdf-build-system/sbcl)
10680       (inputs
10681        `(("cl-ppcre" ,sbcl-cl-ppcre)
10682          ("alexandria" ,sbcl-alexandria)
10683          ("cl-interpol" ,sbcl-cl-interpol)
10684          ("split-sequence" ,sbcl-split-sequence)))
10685       (native-inputs
10686        `(("prove" ,sbcl-prove)))
10687       (arguments
10688        ;; Tests passes but the phase fails with
10689        ;; Component KEBAB-ASD::KEBAB-TEST not found, required by #<SYSTEM "kebab">.
10690        `(#:tests? #f))
10691       (synopsis "Common Lisp case converter")
10692       (description "This Common Lisp library converts strings, symbols and
10693 keywords between any of the following typographical cases: PascalCase,
10694 camelCase, snake_case, kebab-case (lisp-case).")
10695       (license license:llgpl))))
10696
10697 (define-public cl-kebab
10698   (sbcl-package->cl-source-package sbcl-kebab))
10699
10700 (define-public ecl-kebab
10701   (sbcl-package->ecl-package sbcl-kebab))
10702
10703 (define-public sbcl-datafly
10704   (let ((commit "adece27fcbc4b5ea39ad1a105048b6b7166e3b0d")
10705         (revision "1"))
10706     (package
10707       (name "sbcl-datafly")
10708       (version (git-version "0.1" revision commit))
10709       (home-page "https://github.com/fukamachi/datafly")
10710       (source
10711        (origin
10712          (method git-fetch)
10713          (uri (git-reference
10714                (url home-page)
10715                (commit commit)))
10716          (file-name (git-file-name name version))
10717          (sha256
10718           (base32 "16b78kzmglp2a4nxlxxl7rpf5zaibsgagn0p3c56fsxvx0c4hszv"))))
10719       (build-system asdf-build-system/sbcl)
10720       (inputs
10721        `(("alexandria" ,sbcl-alexandria)
10722          ("iterate" ,sbcl-iterate)
10723          ("optima" ,sbcl-optima)
10724          ("trivial-types" ,sbcl-trivial-types)
10725          ("closer-mop" ,sbcl-closer-mop)
10726          ("cl-syntax" ,sbcl-cl-syntax)
10727          ("sxql" ,sbcl-sxql)
10728          ("dbi" ,sbcl-dbi)
10729          ("babel" ,sbcl-babel)
10730          ("local-time" ,sbcl-local-time)
10731          ("function-cache" ,sbcl-function-cache)
10732          ("jonathan" ,sbcl-jonathan)
10733          ("kebab" ,sbcl-kebab)
10734          ("log4cl" ,sbcl-log4cl)))
10735       (native-inputs
10736        `(("prove" ,sbcl-prove)))
10737       (arguments
10738        ;; TODO: Tests fail with
10739        ;; While evaluating the form starting at line 22, column 0
10740        ;;   of #P"/tmp/guix-build-sbcl-datafly-0.1-1.adece27.drv-0/source/t/datafly.lisp":
10741        ;; Unhandled SQLITE:SQLITE-ERROR in thread #<SB-THREAD:THREAD "main thread" RUNNING
10742        ;; {10009F8083}>:
10743        ;;   Error when binding parameter 1 to value NIL.
10744        ;; Code RANGE: column index out of range.
10745        `(#:tests? #f))
10746       (synopsis "Lightweight database library for Common Lisp")
10747       (description "Datafly is a lightweight database library for Common Lisp.")
10748       (license license:bsd-3))))
10749
10750 (define-public cl-datafly
10751   (sbcl-package->cl-source-package sbcl-datafly))
10752
10753 (define-public ecl-datafly
10754   (sbcl-package->ecl-package sbcl-datafly))
10755
10756 (define-public sbcl-do-urlencode
10757   (let ((commit "199846441dad5dfac5478b8dee4b4e20d107af6a")
10758         (revision "1"))
10759     (package
10760       (name "sbcl-do-urlencode")
10761       (version (git-version "0.0.0" revision commit))
10762       (home-page "https://github.com/drdo/do-urlencode")
10763       (source
10764        (origin
10765          (method git-fetch)
10766          (uri (git-reference
10767                (url home-page)
10768                (commit commit)))
10769          (file-name (git-file-name name version))
10770          (sha256
10771           (base32 "0k2i3d4k9cpci235mwfm0c5a4yqfkijr716bjv7cdlpzx88lazm9"))))
10772       (build-system asdf-build-system/sbcl)
10773       (inputs
10774        `(("alexandria" ,sbcl-alexandria)
10775          ("babel" ,sbcl-babel)))
10776       (synopsis "Percent Encoding (aka URL Encoding) Common Lisp library")
10777       (description "This library provides trivial percent encoding and
10778 decoding functions for URLs.")
10779       (license license:isc))))
10780
10781 (define-public cl-do-urlencode
10782   (sbcl-package->cl-source-package sbcl-do-urlencode))
10783
10784 (define-public ecl-do-urlencode
10785   (sbcl-package->ecl-package sbcl-do-urlencode))
10786
10787 (define-public sbcl-cl-emb
10788   (let ((commit "fd8652174d048d4525a81f38cdf42f4fa519f840")
10789         (revision "1"))
10790     (package
10791       (name "sbcl-cl-emb")
10792       (version (git-version "0.4.3" revision commit))
10793       (home-page "https://common-lisp.net/project/cl-emb/")
10794       (source
10795        (origin
10796          (method git-fetch)
10797          (uri (git-reference
10798                (url "https://github.com/38a938c2/cl-emb")
10799                (commit commit)))
10800          (file-name (git-file-name name version))
10801          (sha256
10802           (base32 "1xcm31n7afh5316lwz8iqbjx7kn5lw0l11arg8mhdmkx42aj4gkk"))))
10803       (build-system asdf-build-system/sbcl)
10804       (inputs
10805        `(("cl-ppcre" ,sbcl-cl-ppcre)))
10806       (synopsis "Templating system for Common Lisp")
10807       (description "A mixture of features from eRuby and HTML::Template.  You
10808 could name it \"Yet Another LSP\" (LispServer Pages) but it's a bit more than
10809 that and not limited to a certain server or text format.")
10810       (license license:llgpl))))
10811
10812 (define-public cl-emb
10813   (sbcl-package->cl-source-package sbcl-cl-emb))
10814
10815 (define-public ecl-cl-emb
10816   (sbcl-package->ecl-package sbcl-cl-emb))
10817
10818 (define-public sbcl-cl-project
10819   (let ((commit "151107014e534fc4666222d57fec2cc8549c8814")
10820         (revision "1"))
10821     (package
10822       (name "sbcl-cl-project")
10823       (version (git-version "0.3.1" revision commit))
10824       (home-page "https://github.com/fukamachi/cl-project")
10825       (source
10826        (origin
10827          (method git-fetch)
10828          (uri (git-reference
10829                (url home-page)
10830                (commit commit)))
10831          (file-name (git-file-name name version))
10832          (sha256
10833           (base32 "1rmh6s1ncv8s2yrr14ja9wisgg745sq6xibqwb341ikdicxdp26y"))))
10834       (build-system asdf-build-system/sbcl)
10835       (inputs
10836        `(("cl-emb" ,sbcl-cl-emb)
10837          ("cl-ppcre" ,sbcl-cl-ppcre)
10838          ("local-time" ,sbcl-local-time)
10839          ("prove" ,sbcl-prove)))
10840       (arguments
10841        ;; Tests depend on caveman, which in turns depends on cl-project.
10842        '(#:tests? #f
10843          #:asd-files '("cl-project.asd")))
10844       (synopsis "Generate a skeleton for modern Common Lisp projects")
10845       (description "This library provides a modern project skeleton generator.
10846 In contract with other generators, CL-Project generates one package per file
10847 and encourages unit testing by generating a system for unit testing, so you
10848 can begin writing unit tests as soon as the project is generated.")
10849       (license license:llgpl))))
10850
10851 (define-public cl-project
10852   (sbcl-package->cl-source-package sbcl-cl-project))
10853
10854 (define-public ecl-cl-project
10855   (sbcl-package->ecl-package sbcl-cl-project))
10856
10857 (define-public sbcl-caveman
10858   (let ((commit "faa5f7e3b364fd7e7096af9a7bb06728b8d80441") ; No release since 2012
10859         (revision "1"))
10860     (package
10861       (name "sbcl-caveman")
10862       (version (git-version "2.4.0" revision commit))
10863       (home-page "http://8arrow.org/caveman/")
10864       (source
10865        (origin
10866          (method git-fetch)
10867          (uri (git-reference
10868                (url "https://github.com/fukamachi/caveman/")
10869                (commit commit)))
10870          (file-name (git-file-name name version))
10871          (sha256
10872           (base32 "0kh0gx05pczk8f7r9qdi4zn1p3d0a2prps27k7jpgvc1dxkl8qhq"))))
10873       (build-system asdf-build-system/sbcl)
10874       (inputs
10875        `(("ningle" ,cl-ningle)
10876          ("lack" ,sbcl-lack)
10877          ("cl-project" ,sbcl-cl-project)
10878          ("dbi" ,sbcl-dbi)
10879          ("cl-syntax" ,sbcl-cl-syntax)
10880          ("myway" ,sbcl-myway)
10881          ("quri" ,sbcl-quri)))
10882       (native-inputs
10883        `(("usocket" ,sbcl-usocket)
10884          ("dexador" ,sbcl-dexador)))
10885       (arguments
10886        `(#:asd-files '("caveman2.asd")
10887          #:asd-systems '("caveman2")
10888          #:phases
10889          (modify-phases %standard-phases
10890            (add-after 'unpack 'remove-v1
10891              (lambda _
10892                (delete-file-recursively "v1")
10893                (for-each delete-file
10894                          '("README.v1.markdown" "caveman.asd" "caveman-test.asd")))))
10895          ;; TODO: Tests fail with:
10896          ;; writing /gnu/store/...-sbcl-caveman-2.4.0-1.faa5f7e/share/common-lisp/sbcl-source/caveman2/v2/t/tmp/myapp573/tests/myapp573.lisp
10897          ;; While evaluating the form starting at line 38, column 0
10898          ;;   of #P"/tmp/guix-build-sbcl-caveman-2.4.0-1.faa5f7e.drv-0/source/v2/t/caveman.lisp":
10899          ;; Unhandled ASDF/FIND-COMPONENT:MISSING-COMPONENT in thread #<SB-THREAD:THREAD "main thread" RUNNING
10900          ;;                                                              {10009F8083}>:
10901          ;;   Component "myapp573" not found
10902          #:tests? #f))
10903       (synopsis "Lightweight web application framework in Common Lisp")
10904       (description "Caveman is intended to be a collection of common parts for
10905 web applications.  Caveman2 has three design goals:
10906
10907 @itemize
10908 @item Be extensible.
10909 @item Be practical.
10910 @item Don't force anything.
10911 @end itemize\n")
10912       (license license:llgpl))))
10913
10914 (define-public cl-caveman
10915   (package
10916     (inherit
10917      (sbcl-package->cl-source-package sbcl-caveman))
10918     (propagated-inputs
10919      `(("ningle" ,cl-ningle)))))
10920
10921 (define-public ecl-caveman
10922   (sbcl-package->ecl-package sbcl-caveman))