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, 2020 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>
24 ;;; This file is part of GNU Guix.
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.
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.
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/>.
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.
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-19))
80 (define-public sbcl-alexandria
82 (name "sbcl-alexandria")
88 (url "https://gitlab.common-lisp.net/alexandria/alexandria.git")
89 (commit (string-append "v" version))))
92 "1zanb3xa98js0i66iqcmx3gp123p1m2d1fxn8d7bfzyfad5f6xn2"))
93 (file-name (git-file-name name version))))
94 (build-system asdf-build-system/sbcl)
97 (synopsis "Collection of portable utilities for Common Lisp")
99 "Alexandria is a collection of portable utilities. It does not contain
100 conceptual extensions to Common Lisp. It is conservative in scope, and
101 portable between implementations.")
102 (home-page "https://common-lisp.net/project/alexandria/")
103 (license license:public-domain)))
105 (define-public cl-alexandria
106 (sbcl-package->cl-source-package sbcl-alexandria))
108 (define-public ecl-alexandria
109 (sbcl-package->ecl-package sbcl-alexandria))
111 (define-public sbcl-net.didierverna.asdf-flv
113 (name "sbcl-net.didierverna.asdf-flv")
119 (url "https://github.com/didierverna/asdf-flv")
120 (commit (string-append "version-" version))))
121 (file-name (git-file-name "asdf-flv" version))
123 (base32 "1fi2y4baxan103jbg4idjddzihy03kwnj2mzbwrknw4d4x7xlgwj"))))
124 (build-system asdf-build-system/sbcl)
125 (synopsis "Common Lisp ASDF extension to provide support for file-local variables")
126 (description "ASDF-FLV provides support for file-local variables through
127 ASDF. A file-local variable behaves like @code{*PACKAGE*} and
128 @code{*READTABLE*} with respect to @code{LOAD} and @code{COMPILE-FILE}: a new
129 dynamic binding is created before processing the file, so that any
130 modification to the variable becomes essentially file-local.
132 In order to make one or several variables file-local, use the macros
133 @code{SET-FILE-LOCAL-VARIABLE(S)}.")
134 (home-page "https://www.lrde.epita.fr/~didier/software/lisp/misc.php#asdf-flv")
135 (license (license:non-copyleft
136 "https://www.gnu.org/prep/maintain/html_node/License-Notices-for-Other-Files.html"
137 "GNU All-Permissive License"))))
139 (define-public cl-net.didierverna.asdf-flv
140 (sbcl-package->cl-source-package sbcl-net.didierverna.asdf-flv))
142 (define-public ecl-net.didierverna.asdf-flv
143 (sbcl-package->ecl-package sbcl-net.didierverna.asdf-flv))
145 (define-public sbcl-fiveam
153 (url "https://github.com/sionescu/fiveam")
154 (commit (string-append "v" version))))
155 (file-name (git-file-name "fiveam" version))
157 (base32 "1q3d38pwafnwnw42clq0f8g5xw7pbzr287jl9jsqmb1vb0n1vrli"))))
159 `(("alexandria" ,sbcl-alexandria)
160 ("net.didierverna.asdf-flv" ,sbcl-net.didierverna.asdf-flv)
161 ("trivial-backtrace" ,sbcl-trivial-backtrace)))
162 (build-system asdf-build-system/sbcl)
163 (synopsis "Common Lisp testing framework")
164 (description "FiveAM is a simple (as far as writing and running tests
165 goes) regression testing framework. It has been designed with Common Lisp's
166 interactive development model in mind.")
167 (home-page "https://common-lisp.net/project/fiveam/")
168 (license license:bsd-3)))
170 (define-public cl-fiveam
171 (sbcl-package->cl-source-package sbcl-fiveam))
173 (define-public ecl-fiveam
174 (sbcl-package->ecl-package sbcl-fiveam))
176 (define-public sbcl-bordeaux-threads
178 (name "sbcl-bordeaux-threads")
183 (url "https://github.com/sionescu/bordeaux-threads")
184 (commit (string-append "v" version))))
186 (base32 "19i443fz3488v1pbbr9x24y8h8vlyhny9vj6c9jk5prm702awrp6"))
188 (git-file-name "bordeaux-threads" version))))
189 (inputs `(("alexandria" ,sbcl-alexandria)))
190 (native-inputs `(("fiveam" ,sbcl-fiveam)))
191 (build-system asdf-build-system/sbcl)
192 (synopsis "Portable shared-state concurrency library for Common Lisp")
193 (description "BORDEAUX-THREADS is a proposed standard for a minimal
194 MP/Threading interface. It is similar to the CLIM-SYS threading and lock
196 (home-page "https://common-lisp.net/project/bordeaux-threads/")
197 (license license:x11)))
199 (define-public cl-bordeaux-threads
200 (sbcl-package->cl-source-package sbcl-bordeaux-threads))
202 (define-public ecl-bordeaux-threads
203 (sbcl-package->ecl-package sbcl-bordeaux-threads))
205 (define-public sbcl-trivial-gray-streams
207 (commit "ebd59b1afed03b9dc8544320f8f432fdf92ab010"))
209 (name "sbcl-trivial-gray-streams")
210 (version (string-append "0.0.0-" revision "." (string-take commit 7)))
216 (url "https://github.com/trivial-gray-streams/trivial-gray-streams")
219 (base32 "0b1pxlccmnagk9cbh4cy8s5k66g3x0gwib5shjwr24xvrji6lp94"))
221 (string-append "trivial-gray-streams-" version "-checkout"))))
222 (build-system asdf-build-system/sbcl)
223 (synopsis "Compatibility layer for Gray streams implementations")
224 (description "Gray streams is an interface proposed for inclusion with
225 ANSI CL by David N. Gray. The proposal did not make it into ANSI CL, but most
226 popular CL implementations implement it. This package provides an extremely
227 thin compatibility layer for gray streams.")
228 (home-page "https://www.cliki.net/trivial-gray-streams")
229 (license license:x11))))
231 (define-public cl-trivial-gray-streams
232 (sbcl-package->cl-source-package sbcl-trivial-gray-streams))
234 (define-public ecl-trivial-gray-streams
235 (sbcl-package->ecl-package sbcl-trivial-gray-streams))
237 (define-public sbcl-fiasco
238 (let ((commit "d62f7558b21addc89f87e306f65d7f760632655f")
242 (version (git-version "0.0.1" revision commit))
247 (url "https://github.com/joaotavora/fiasco")
249 (file-name (git-file-name "fiasco" version))
252 "1zwxs3d6iswayavcmb49z2892xhym7n556d8dnmvalc32pm9bkjh"))))
253 (build-system asdf-build-system/sbcl)
255 `(("alexandria" ,sbcl-alexandria)
256 ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
257 (synopsis "Simple and powerful test framework for Common Lisp")
258 (description "A Common Lisp test framework that treasures your failures,
259 logical continuation of Stefil. It focuses on interactive debugging.")
260 (home-page "https://github.com/joaotavora/fiasco")
261 ;; LICENCE specifies this is public-domain unless the legislation
262 ;; doesn't allow or recognize it. In that case it falls back to a
263 ;; permissive licence.
264 (license (list license:public-domain
265 (license:x11-style "file://LICENCE"))))))
267 (define-public cl-fiasco
268 (sbcl-package->cl-source-package sbcl-fiasco))
270 (define-public ecl-fiasco
271 (sbcl-package->ecl-package sbcl-fiasco))
273 (define-public sbcl-flexi-streams
275 (name "sbcl-flexi-streams")
281 (url "https://github.com/edicl/flexi-streams")
282 (commit (string-append "v" version))))
283 (file-name (git-file-name "flexi-streams" version))
285 (base32 "0bjv7fd2acknidc5dyi3h85pn10krxv5jyxs1xg8jya2rlfv7f1j"))))
286 (build-system asdf-build-system/sbcl)
289 (modify-phases %standard-phases
290 (add-after 'unpack 'make-git-checkout-writable
292 (for-each make-file-writable (find-files "."))
294 (inputs `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
295 (synopsis "Implementation of virtual bivalent streams for Common Lisp")
296 (description "Flexi-streams is an implementation of \"virtual\" bivalent
297 streams that can be layered atop real binary or bivalent streams and that can
298 be used to read and write character data in various single- or multi-octet
299 encodings which can be changed on the fly. It also supplies in-memory binary
300 streams which are similar to string streams.")
301 (home-page "http://weitz.de/flexi-streams/")
302 (license license:bsd-3)))
304 (define-public cl-flexi-streams
305 (sbcl-package->cl-source-package sbcl-flexi-streams))
307 (define-public ecl-flexi-streams
308 (sbcl-package->ecl-package sbcl-flexi-streams))
310 (define-public sbcl-cl-ppcre
312 (name "sbcl-cl-ppcre")
318 (url "https://github.com/edicl/cl-ppcre")
319 (commit (string-append "v" version))))
320 (file-name (git-file-name "cl-ppcre" version))
322 (base32 "0dwvr29diqzcg5n6jvbk2rnd90i05l7n828hhw99khmqd0kz7xsi"))))
323 (build-system asdf-build-system/sbcl)
324 (native-inputs `(("flexi-streams" ,sbcl-flexi-streams)))
325 (synopsis "Portable regular expression library for Common Lisp")
326 (description "CL-PPCRE is a portable regular expression library for Common
327 Lisp, which is compatible with perl. It is pretty fast, thread-safe, and
328 compatible with ANSI-compliant Common Lisp implementations.")
329 (home-page "http://weitz.de/cl-ppcre/")
330 (license license:bsd-2)))
332 (define-public cl-ppcre
333 (sbcl-package->cl-source-package sbcl-cl-ppcre))
335 (define-public ecl-cl-ppcre
336 (sbcl-package->ecl-package sbcl-cl-ppcre))
338 (define sbcl-cl-unicode-base
340 (name "sbcl-cl-unicode-base")
345 (url "https://github.com/edicl/cl-unicode")
346 (commit (string-append "v" version))))
347 (file-name (git-file-name name version))
350 "0ykx2s9lqfl74p1px0ik3l2izd1fc9jd1b4ra68s5x34rvjy0hza"))))
351 (build-system asdf-build-system/sbcl)
353 '(#:asd-file "cl-unicode.asd"
354 #:asd-system-name "cl-unicode/base"))
356 `(("cl-ppcre" ,sbcl-cl-ppcre)))
357 (home-page "http://weitz.de/cl-unicode/")
358 (synopsis "Portable Unicode library for Common Lisp")
359 (description "CL-UNICODE is a portable Unicode library Common Lisp, which
360 is compatible with perl. It is pretty fast, thread-safe, and compatible with
361 ANSI-compliant Common Lisp implementations.")
362 (license license:bsd-2)))
364 (define-public sbcl-cl-unicode
366 (inherit sbcl-cl-unicode-base)
367 (name "sbcl-cl-unicode")
369 `(("cl-unicode/base" ,sbcl-cl-unicode-base)
370 ,@(package-inputs sbcl-cl-unicode-base)))
372 `(("flexi-streams" ,sbcl-flexi-streams)))
375 (define-public ecl-cl-unicode
376 (sbcl-package->ecl-package sbcl-cl-unicode))
378 (define-public cl-unicode
379 (sbcl-package->cl-source-package sbcl-cl-unicode))
381 (define-public sbcl-zpb-ttf
383 (name "sbcl-zpb-ttf")
389 (url "https://github.com/xach/zpb-ttf")
390 (commit (string-append "release-" version))))
391 (file-name (git-file-name name version))
394 "1wh66vjijzqlydnrihynpwp6796917xwrh0i9li93c17kyxa74ih"))))
395 (build-system asdf-build-system/sbcl)
396 (home-page "https://github.com/xach/zpb-ttf")
397 (synopsis "TrueType font file access for Common Lisp")
399 "ZPB-TTF is a TrueType font file parser that provides an interface for
400 reading typographic metrics, glyph outlines, and other information from the
402 (license license:bsd-2)))
404 (define-public ecl-zpb-ttf
405 (sbcl-package->ecl-package sbcl-zpb-ttf))
407 (define-public cl-zpb-ttf
408 (sbcl-package->cl-source-package sbcl-zpb-ttf))
410 (define-public sbcl-cl-aa
417 (uri (string-append "http://projects.tuxee.net/cl-vectors/"
418 "files/cl-vectors-" version ".tar.gz"))
421 "04lhwi0kq8pkwhgd885pk80m1cp9sfvjjn5zj70s1dnckibhdmqh"))))
422 (build-system asdf-build-system/sbcl)
423 (arguments '(#:asd-file "cl-aa.asd"))
424 (home-page "http://projects.tuxee.net/cl-vectors/")
425 (synopsis "Polygon rasterizer")
427 "This is a Common Lisp library implementing the AA polygon rasterization
428 algorithm from the @url{http://antigrain.com, Antigrain} project.")
429 (license license:expat)))
431 (define-public ecl-cl-aa
432 (sbcl-package->ecl-package sbcl-cl-aa))
435 (sbcl-package->cl-source-package sbcl-cl-aa))
437 (define-public sbcl-cl-paths
440 (name "sbcl-cl-paths")
441 (arguments '(#:asd-file "cl-paths.asd"))
442 (synopsis "Facilities to create and manipulate vectorial paths")
444 "This package provides facilities to create and manipulate vectorial
447 (define-public ecl-cl-paths
448 (sbcl-package->ecl-package sbcl-cl-paths))
450 (define-public cl-paths
451 (sbcl-package->cl-source-package sbcl-cl-paths))
453 (define-public sbcl-cl-paths-ttf
456 (name "sbcl-cl-paths-ttf")
457 (arguments '(#:asd-file "cl-paths-ttf.asd"))
459 `(("cl-paths" ,sbcl-cl-paths)
460 ("zpb-ttf" ,sbcl-zpb-ttf)))
461 (synopsis "Facilities to create and manipulate vectorial paths")
463 "This package provides facilities to create and manipulate vectorial
466 (define-public ecl-cl-paths-ttf
467 (sbcl-package->ecl-package sbcl-cl-paths-ttf))
469 (define-public cl-paths-ttf
470 (sbcl-package->cl-source-package sbcl-cl-paths-ttf))
472 (define-public sbcl-cl-vectors
475 (name "sbcl-cl-vectors")
476 (arguments '(#:asd-file "cl-vectors.asd"))
478 `(("cl-aa" ,sbcl-cl-aa)
479 ("cl-paths" ,sbcl-cl-paths)))
480 (synopsis "Create, transform and render anti-aliased vectorial paths")
482 "This is a pure Common Lisp library to create, transform and render
483 anti-aliased vectorial paths.")))
485 (define-public ecl-cl-vectors
486 (sbcl-package->ecl-package sbcl-cl-vectors))
488 (define-public cl-vectors
489 (sbcl-package->cl-source-package sbcl-cl-vectors))
491 (define-public sbcl-spatial-trees
492 ;; There have been no releases.
493 (let ((commit "81fdad0a0bf109c80a53cc96eca2e093823400ba")
496 (name "sbcl-spatial-trees")
497 (version (git-version "0" revision commit))
502 (url "https://github.com/rpav/spatial-trees")
504 (file-name (git-file-name name version))
507 "11rhc6h501dwcik2igkszz7b9n515cr99m5pjh4r2qfwgiri6ysa"))))
508 (build-system asdf-build-system/sbcl)
510 '(#:tests? #f ; spatial-trees.test requires spatial-trees.nns
511 #:asd-file "spatial-trees.asd"
512 #:test-asd-file "spatial-trees.test.asd"))
514 `(("fiveam" ,sbcl-fiveam)))
515 (home-page "https://github.com/rpav/spatial-trees")
516 (synopsis "Dynamic index data structures for spatially-extended data")
518 "Spatial-trees is a set of dynamic index data structures for
519 spatially-extended data.")
520 (license license:bsd-3))))
522 (define-public ecl-spatial-trees
523 (sbcl-package->ecl-package sbcl-spatial-trees))
525 (define-public cl-spatial-trees
526 (sbcl-package->cl-source-package sbcl-spatial-trees))
528 (define-public sbcl-flexichain
529 ;; There are no releases.
530 (let ((commit "13d2a6c505ed0abfcd4c4ec7d7145059b06855d6")
533 (name "sbcl-flexichain")
539 (url "https://github.com/robert-strandh/Flexichain")
541 (file-name (git-file-name name version))
544 "0pfyvhsfbjd2sjb30grfs52r51a428xglv7bwydvpg2lc117qimg"))))
545 (build-system asdf-build-system/sbcl)
546 (home-page "https://github.com/robert-strandh/Flexichain.git")
547 (synopsis "Dynamically add elements to or remove them from sequences")
549 "This package provides an implementation of the flexichain protocol,
550 allowing client code to dynamically add elements to, and delete elements from
551 a sequence (or chain) of such elements.")
552 (license license:lgpl2.1+))))
554 (define-public ecl-flexichain
555 (sbcl-package->ecl-package sbcl-flexichain))
557 (define-public cl-flexichain
558 (sbcl-package->cl-source-package sbcl-flexichain))
560 (define-public sbcl-cl-pdf
561 ;; There are no releases
562 (let ((commit "752e337e6d6fc206f09d091a982e7f8e5c404e4e")
566 (version (git-version "0" revision commit))
571 (url "https://github.com/mbattyani/cl-pdf")
573 (file-name (git-file-name name version))
576 "1cg3k3m3r11ipb8j008y8ipynj97l3xjlpi2knqc9ndmx4r3kb1r"))))
577 (build-system asdf-build-system/sbcl)
579 `(("iterate" ,sbcl-iterate)
580 ("zpb-ttf" ,sbcl-zpb-ttf)))
581 (home-page "https://github.com/mbattyani/cl-pdf")
582 (synopsis "Common Lisp library for generating PDF files")
584 "CL-PDF is a cross-platform Common Lisp library for generating PDF
586 (license license:bsd-2))))
588 (define-public ecl-cl-pdf
589 (sbcl-package->ecl-package sbcl-cl-pdf))
591 (define-public cl-pdf
592 (sbcl-package->cl-source-package sbcl-cl-pdf))
594 (define-public sbcl-clx
603 (url "https://github.com/sharplispers/clx")
607 "1vi67z9hpj5rr4xcmfbfwzmlcc0ah7hzhrmfid6lqdkva238v2wf"))
608 (file-name (string-append "clx-" version))))
609 (build-system asdf-build-system/sbcl)
611 `(("fiasco" ,sbcl-fiasco)))
612 (home-page "https://www.cliki.net/portable-clx")
613 (synopsis "X11 client library for Common Lisp")
614 (description "CLX is an X11 client library for Common Lisp. The code was
615 originally taken from a CMUCL distribution, was modified somewhat in order to
616 make it compile and run under SBCL, then a selection of patches were added
617 from other CLXes around the net.")
618 (license license:x11)))
620 (define-public cl-clx
621 (sbcl-package->cl-source-package sbcl-clx))
623 (define-public ecl-clx
624 (sbcl-package->ecl-package sbcl-clx))
626 (define-public sbcl-clx-truetype
627 (let ((commit "c6e10a918d46632324d5863a8ed067a83fc26de8")
630 (name "sbcl-clx-truetype")
631 (version (git-version "0.0.1" revision commit))
636 (url "https://github.com/l04m33/clx-truetype")
638 (file-name (git-file-name name version))
641 "079hyp92cjkdfn6bhkxsrwnibiqbz4y4af6nl31lzw6nm91j5j37"))
642 (modules '((guix build utils)))
645 (substitute* "package.lisp"
646 ((":export") ":export\n :+font-cache-filename+"))
648 (build-system asdf-build-system/sbcl)
651 ("zpb-ttf" ,sbcl-zpb-ttf)
652 ("cl-vectors" ,sbcl-cl-vectors)
653 ("cl-paths-ttf" ,sbcl-cl-paths-ttf)
654 ("cl-fad" ,sbcl-cl-fad)
655 ("cl-store" ,sbcl-cl-store)
656 ("trivial-features" ,sbcl-trivial-features)))
657 (home-page "https://github.com/l04m33/clx-truetype")
658 (synopsis "Antialiased TrueType font rendering using CLX and XRender")
659 (description "CLX-TrueType is pure common lisp solution for
660 antialiased TrueType font rendering using CLX and XRender extension.")
661 (license license:expat))))
663 (define-public sbcl-cl-ppcre-unicode
664 (package (inherit sbcl-cl-ppcre)
665 (name "sbcl-cl-ppcre-unicode")
667 `(#:tests? #f ; tests fail with "Component :CL-PPCRE-TEST not found"
668 #:asd-file "cl-ppcre-unicode.asd"))
670 `(("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
671 ("sbcl-cl-unicode" ,sbcl-cl-unicode)))))
673 (define-public ecl-cl-ppcre-unicode
674 (sbcl-package->ecl-package sbcl-cl-ppcre-unicode))
676 ;; The slynk that users expect to install includes all of slynk's contrib
677 ;; modules. Therefore, we build the base module and all contribs first; then
678 ;; we expose the union of these as `sbcl-slynk'. The following variable
679 ;; describes the base module.
680 (define sbcl-slynk-boot0
682 ;; Update together with emacs-sly.
683 (commit "6a2f543cb21f14104c2253af5a1427b884a987ae"))
685 (name "sbcl-slynk-boot0")
686 (version (string-append "1.0.0-beta-" revision "." (string-take commit 7)))
692 (url "https://github.com/joaotavora/sly")
695 (base32 "0wbpg9p9yg2hd62l15pvy50fk3hndq5zzyqlyyf04g368s895144"))
696 (file-name (string-append "slynk-" version "-checkout"))
697 (modules '((guix build utils)
701 ;; Move the contribs into the main source directory for easier
703 (substitute* "slynk/slynk.asd"
706 (("\\(defsystem :slynk/util")
707 "(defsystem :slynk/util :depends-on (:slynk)"))
708 (substitute* "contrib/slynk-trace-dialog.lisp"
709 (("\\(slynk::reset-inspector\\)") ; Causes problems on load
711 (substitute* "contrib/slynk-profiler.lisp"
713 "slynk-pprint-to-line"))
714 (substitute* "contrib/slynk-fancy-inspector.lisp"
715 (("slynk/util") "slynk-util")
716 ((":compile-toplevel :load-toplevel") ""))
717 (rename-file "contrib" "slynk/contrib")
718 ;; Move slynk's contents into the base directory for easier
720 (for-each (lambda (file)
721 (unless (string-prefix? "." file)
722 (rename-file (string-append "slynk/" file)
723 (string-append "./" (basename file)))))
726 (build-system asdf-build-system/sbcl)
728 `(#:tests? #f ; No test suite
729 #:asd-system-name "slynk"))
730 (synopsis "Common Lisp IDE for Emacs")
731 (description "SLY is a fork of SLIME, an IDE backend for Common Lisp.
732 It also features a completely redesigned REPL based on Emacs's own
733 full-featured @code{comint-mode}, live code annotations, and a consistent interactive
734 button interface. Everything can be copied to the REPL. One can create
735 multiple inspectors with independent history.")
736 (home-page "https://github.com/joaotavora/sly")
737 (license license:public-domain)
738 (properties `((cl-source-variant . ,(delay cl-slynk)))))))
740 (define-public cl-slynk
742 (inherit (sbcl-package->cl-source-package sbcl-slynk-boot0))
745 (define ecl-slynk-boot0
746 (sbcl-package->ecl-package sbcl-slynk-boot0))
748 (define sbcl-slynk-arglists
750 (inherit sbcl-slynk-boot0)
751 (name "sbcl-slynk-arglists")
752 (inputs `(("slynk" ,sbcl-slynk-boot0)))
754 (substitute-keyword-arguments (package-arguments sbcl-slynk-boot0)
755 ((#:asd-file _ "") "slynk.asd")
756 ((#:asd-system-name _ #f) "slynk/arglists")))))
758 (define ecl-slynk-arglists
759 (sbcl-package->ecl-package sbcl-slynk-arglists))
761 (define sbcl-slynk-util
763 (inherit sbcl-slynk-boot0)
764 (name "sbcl-slynk-util")
765 (inputs `(("slynk" ,sbcl-slynk-boot0)))
767 (substitute-keyword-arguments (package-arguments sbcl-slynk-boot0)
768 ((#:asd-file _ "") "slynk.asd")
769 ((#:asd-system-name _ #f) "slynk/util")))))
771 (define ecl-slynk-util
772 (sbcl-package->ecl-package sbcl-slynk-util))
774 (define sbcl-slynk-fancy-inspector
776 (inherit sbcl-slynk-arglists)
777 (name "sbcl-slynk-fancy-inspector")
778 (inputs `(("slynk-util" ,sbcl-slynk-util)
779 ,@(package-inputs sbcl-slynk-arglists)))
781 (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
782 ((#:asd-system-name _ #f) "slynk/fancy-inspector")))))
784 (define ecl-slynk-fancy-inspector
785 (sbcl-package->ecl-package sbcl-slynk-fancy-inspector))
787 (define sbcl-slynk-package-fu
789 (inherit sbcl-slynk-arglists)
790 (name "sbcl-slynk-package-fu")
792 (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
793 ((#:asd-system-name _ #f) "slynk/package-fu")))))
795 (define ecl-slynk-package-fu
796 (sbcl-package->ecl-package sbcl-slynk-package-fu))
798 (define sbcl-slynk-mrepl
800 (inherit sbcl-slynk-fancy-inspector)
801 (name "sbcl-slynk-mrepl")
803 (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
804 ((#:asd-system-name _ #f) "slynk/mrepl")))))
806 (define ecl-slynk-mrepl
807 (sbcl-package->ecl-package sbcl-slynk-mrepl))
809 (define sbcl-slynk-trace-dialog
811 (inherit sbcl-slynk-arglists)
812 (name "sbcl-slynk-trace-dialog")
814 (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
815 ((#:asd-system-name _ #f) "slynk/trace-dialog")))))
817 (define ecl-slynk-trace-dialog
818 (sbcl-package->ecl-package sbcl-slynk-trace-dialog))
820 (define sbcl-slynk-profiler
822 (inherit sbcl-slynk-arglists)
823 (name "sbcl-slynk-profiler")
825 (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
826 ((#:asd-system-name _ #f) "slynk/profiler")))))
828 (define ecl-slynk-profiler
829 (sbcl-package->ecl-package sbcl-slynk-profiler))
831 (define sbcl-slynk-stickers
833 (inherit sbcl-slynk-arglists)
834 (name "sbcl-slynk-stickers")
836 (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
837 ((#:asd-system-name _ #f) "slynk/stickers")))))
839 (define ecl-slynk-stickers
840 (sbcl-package->ecl-package sbcl-slynk-stickers))
842 (define sbcl-slynk-indentation
844 (inherit sbcl-slynk-arglists)
845 (name "sbcl-slynk-indentation")
847 (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
848 ((#:asd-system-name _ #f) "slynk/indentation")))))
850 (define ecl-slynk-indentation
851 (sbcl-package->ecl-package sbcl-slynk-indentation))
853 (define sbcl-slynk-retro
855 (inherit sbcl-slynk-arglists)
856 (name "sbcl-slynk-retro")
858 (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
859 ((#:asd-system-name _ #f) "slynk/retro")))))
861 (define ecl-slynk-retro
862 (sbcl-package->ecl-package sbcl-slynk-retro))
864 (define slynk-systems
868 "slynk-fancy-inspector"
877 (define-public sbcl-slynk
879 (inherit sbcl-slynk-boot0)
882 `(("slynk" ,sbcl-slynk-boot0)
883 ("slynk-util" ,sbcl-slynk-util)
884 ("slynk-arglists" ,sbcl-slynk-arglists)
885 ("slynk-fancy-inspector" ,sbcl-slynk-fancy-inspector)
886 ("slynk-package-fu" ,sbcl-slynk-package-fu)
887 ("slynk-mrepl" ,sbcl-slynk-mrepl)
888 ("slynk-profiler" ,sbcl-slynk-profiler)
889 ("slynk-trace-dialog" ,sbcl-slynk-trace-dialog)
890 ("slynk-stickers" ,sbcl-slynk-stickers)
891 ("slynk-indentation" ,sbcl-slynk-indentation)
892 ("slynk-retro" ,sbcl-slynk-retro)))
893 (native-inputs `(("sbcl" ,sbcl)))
894 (build-system trivial-build-system)
896 (outputs '("out" "image"))
898 `(#:modules ((guix build union)
900 (guix build lisp-utils))
903 (use-modules (ice-9 match)
906 (guix build lisp-utils))
909 (assoc-ref %outputs "out")
913 (if (string-prefix? "slynk" name) path #f)))
916 (prepend-to-source-registry
917 (string-append (assoc-ref %outputs "out") "//"))
919 (parameterize ((%lisp-type "sbcl")
920 (%lisp (string-append (assoc-ref %build-inputs "sbcl")
922 (build-image (string-append
923 (assoc-ref %outputs "image")
926 #:dependencies ',slynk-systems))
929 (define-public ecl-slynk
936 (list name (sbcl-package->ecl-package pkg))))
937 (package-inputs sbcl-slynk)))
941 '(#:modules ((guix build union))
944 (use-modules (ice-9 match)
947 (((names . paths) ...)
948 (union-build (assoc-ref %outputs "out")
952 (define-public sbcl-parse-js
953 (let ((commit "fbadc6029bec7039602abfc06c73bb52970998f6")
956 (name "sbcl-parse-js")
957 (version (string-append "0.0.0-" revision "." (string-take commit 9)))
962 (url "http://marijn.haverbeke.nl/git/parse-js")
964 (file-name (string-append name "-" commit "-checkout"))
967 "1wddrnr5kiya5s3gp4cdq6crbfy9fqcz7fr44p81502sj3bvdv39"))))
968 (build-system asdf-build-system/sbcl)
969 (home-page "https://marijnhaverbeke.nl/parse-js/")
970 (synopsis "Parse JavaScript")
971 (description "Parse-js is a Common Lisp package for parsing
972 JavaScript (ECMAScript 3). It has basic support for ECMAScript 5.")
973 (license license:zlib))))
975 (define-public cl-parse-js
976 (sbcl-package->cl-source-package sbcl-parse-js))
978 (define-public sbcl-parse-number
980 (name "sbcl-parse-number")
986 (url "https://github.com/sharplispers/parse-number/")
987 (commit (string-append "v" version))))
988 (file-name (git-file-name name version))
991 "0sk06ib1bhqv9y39vwnnw44vmbc4b0kvqm37xxmkxd4dwchq82d7"))))
992 (build-system asdf-build-system/sbcl)
993 (home-page "https://www.cliki.net/PARSE-NUMBER")
994 (synopsis "Parse numbers")
995 (description "@code{parse-number} is a library of functions for parsing
996 strings into one of the standard Common Lisp number types without using the
997 reader. @code{parse-number} accepts an arbitrary string and attempts to parse
998 the string into one of the standard Common Lisp number types, if possible, or
999 else @code{parse-number} signals an error of type @code{invalid-number}.")
1000 (license license:bsd-3)))
1002 (define-public cl-parse-number
1003 (sbcl-package->cl-source-package sbcl-parse-number))
1005 (define-public sbcl-iterate
1007 (name "sbcl-iterate")
1012 (uri (string-append "https://common-lisp.net/project/iterate/releases/"
1013 "iterate-" version ".tar.gz"))
1016 "1lqsbhrkfl0yif46aymvb7l3nb9wdcmj4jyw485blj32jb4famzn"))))
1017 (build-system asdf-build-system/sbcl)
1020 (home-page "https://common-lisp.net/project/iterate/")
1021 (synopsis "Iteration construct for Common Lisp")
1022 (description "@code{iterate} is an iteration construct for Common Lisp.
1023 It is similar to the @code{CL:LOOP} macro, with these distinguishing marks:
1026 @item it is extensible,
1027 @item it helps editors like Emacs indent iterate forms by having a more
1028 lisp-like syntax, and
1029 @item it isn't part of the ANSI standard for Common Lisp.
1031 (license license:expat)))
1033 (define-public cl-iterate
1034 (sbcl-package->cl-source-package sbcl-iterate))
1036 (define-public ecl-iterate
1037 (sbcl-package->ecl-package sbcl-iterate))
1039 (define-public sbcl-cl-uglify-js
1040 ;; There have been many bug fixes since the 2010 release.
1041 (let ((commit "429c5e1d844e2f96b44db8fccc92d6e8e28afdd5")
1044 (name "sbcl-cl-uglify-js")
1045 (version (string-append "0.1-" revision "." (string-take commit 9)))
1050 (url "https://github.com/mishoo/cl-uglify-js")
1052 (file-name (git-file-name name version))
1055 "0k39y3c93jgxpr7gwz7w0d8yknn1fdnxrjhd03057lvk5w8js27a"))))
1056 (build-system asdf-build-system/sbcl)
1058 `(("sbcl-parse-js" ,sbcl-parse-js)
1059 ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
1060 ("sbcl-cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)
1061 ("sbcl-parse-number" ,sbcl-parse-number)
1062 ("sbcl-iterate" ,sbcl-iterate)))
1063 (home-page "https://github.com/mishoo/cl-uglify-js")
1064 (synopsis "JavaScript compressor library for Common Lisp")
1065 (description "This is a Common Lisp version of UglifyJS, a JavaScript
1066 compressor. It works on data produced by @code{parse-js} to generate a
1067 @dfn{minified} version of the code. Currently it can:
1070 @item reduce variable names (usually to single letters)
1071 @item join consecutive @code{var} statements
1072 @item resolve simple binary expressions
1073 @item group most consecutive statements using the @code{sequence} operator (comma)
1074 @item remove unnecessary blocks
1075 @item convert @code{IF} expressions in various ways that result in smaller code
1076 @item remove some unreachable code
1078 (license license:zlib))))
1080 (define-public cl-uglify-js
1081 (sbcl-package->cl-source-package sbcl-cl-uglify-js))
1083 (define-public uglify-js
1085 (inherit sbcl-cl-uglify-js)
1087 (build-system trivial-build-system)
1089 `(#:modules ((guix build utils))
1091 (let* ((bin (string-append (assoc-ref %outputs "out") "/bin/"))
1092 (script (string-append bin "uglify-js")))
1093 (use-modules (guix build utils))
1095 (with-output-to-file script
1097 (format #t "#!~a/bin/sbcl --script
1099 (push (truename \"~a/lib/sbcl\") asdf:*central-registry*)"
1100 (assoc-ref %build-inputs "sbcl")
1101 (assoc-ref %build-inputs "sbcl-cl-uglify-js"))
1102 ;; FIXME: cannot use progn here because otherwise it fails to
1103 ;; find cl-uglify-js.
1107 (let ((*standard-output* (make-broadcast-stream))
1108 (*error-output* (make-broadcast-stream)))
1109 (asdf:load-system :cl-uglify-js))
1110 (let ((file (cadr *posix-argv*)))
1113 (cl-uglify-js:ast-gen-code
1114 (cl-uglify-js:ast-mangle
1115 (cl-uglify-js:ast-squeeze
1116 (with-open-file (in file)
1117 (parse-js:parse-js in))))
1120 (format *error-output*
1121 "Please provide a JavaScript file.~%")
1122 (sb-ext:exit :code 1))))))))
1123 (chmod script #o755)
1127 ("sbcl-cl-uglify-js" ,sbcl-cl-uglify-js)))
1128 (synopsis "JavaScript compressor")))
1130 (define-public sbcl-cl-strings
1131 (let ((revision "1")
1132 (commit "c5c5cbafbf3e6181d03c354d66e41a4f063f00ae"))
1134 (name "sbcl-cl-strings")
1135 (version (git-version "0.0.0" revision commit))
1140 (url "https://github.com/diogoalexandrefranco/cl-strings")
1144 "00754mfaqallj480lwd346nkfb6ra8pa8xcxcylf4baqn604zlmv"))
1145 (file-name (string-append "cl-strings-" version "-checkout"))))
1146 (build-system asdf-build-system/sbcl)
1147 (synopsis "Portable, dependency-free set of utilities to manipulate strings in Common Lisp")
1149 "@command{cl-strings} is a small, portable, dependency-free set of
1150 utilities that make it even easier to manipulate text in Common Lisp. It has
1151 100% test coverage and works at least on sbcl, ecl, ccl, abcl and clisp.")
1152 (home-page "https://github.com/diogoalexandrefranco/cl-strings")
1153 (license license:expat))))
1155 (define-public cl-strings
1156 (sbcl-package->cl-source-package sbcl-cl-strings))
1158 (define-public ecl-cl-strings
1159 (sbcl-package->ecl-package sbcl-cl-strings))
1161 (define-public sbcl-trivial-features
1162 ;; No release since 2014.
1163 (let ((commit "870d03de0ed44067963350936856e17ee725153e"))
1165 (name "sbcl-trivial-features")
1166 (version (git-version "0.8" "1" commit))
1171 (url "https://github.com/trivial-features/trivial-features")
1173 (file-name (git-file-name "trivial-features" version))
1175 (base32 "14pcahr8r2j3idhyy216zyw8jnj1dnrx0qbkkbdqkvwzign1ah4j"))))
1176 (build-system asdf-build-system/sbcl)
1177 (arguments '(#:tests? #f))
1178 (home-page "https://cliki.net/trivial-features")
1179 (synopsis "Ensures consistency of @code{*FEATURES*} in Common Lisp")
1180 (description "Trivial-features ensures that @code{*FEATURES*} is
1181 consistent across multiple Common Lisp implementations.")
1182 (license license:expat))))
1184 (define-public cl-trivial-features
1185 (sbcl-package->cl-source-package sbcl-trivial-features))
1187 (define-public ecl-trivial-features
1188 (sbcl-package->ecl-package sbcl-trivial-features))
1190 (define-public sbcl-hu.dwim.asdf
1192 (name "sbcl-hu.dwim.asdf")
1193 (version "20190521")
1197 (uri (string-append "http://beta.quicklisp.org/archive/hu.dwim.asdf/"
1198 "2019-05-21/hu.dwim.asdf-" version "-darcs.tgz"))
1201 "0rsbv71vyszy8w35yjwb5h6zcmknjq223hkzir79y72qdsc6sabn"))))
1202 (build-system asdf-build-system/sbcl)
1203 (home-page "https://hub.darcs.net/hu.dwim/hu.dwim.asdf")
1204 (synopsis "Extensions to ASDF")
1205 (description "Various ASDF extensions such as attached test and
1206 documentation system, explicit development support, etc.")
1207 (license license:public-domain)))
1209 (define-public cl-hu.dwim.asdf
1210 (sbcl-package->cl-source-package sbcl-hu.dwim.asdf))
1212 (define-public ecl-hu.dwim.asdf
1213 (sbcl-package->ecl-package sbcl-hu.dwim.asdf))
1215 (define-public sbcl-hu.dwim.stefil
1216 (let ((commit "ab6d1aa8995878a1b66d745dfd0ba021090bbcf9"))
1218 (name "sbcl-hu.dwim.stefil")
1219 (version (git-version "0.0.0" "1" commit))
1225 (url "https://gitlab.common-lisp.net/xcvb/hu.dwim.stefil.git")
1228 (base32 "1d8yccw65zj3zh46cbi3x6nmn1dwdb76s9d0av035077mvyirqqp"))
1229 (file-name (git-file-name "hu.dwim.stefil" version))))
1230 (build-system asdf-build-system/sbcl)
1232 `(("asdf:cl-hu.dwim.asdf" ,sbcl-hu.dwim.asdf)))
1234 `(("sbcl-alexandria" ,sbcl-alexandria)))
1235 (home-page "https://hub.darcs.net/hu.dwim/hu.dwim.stefil")
1236 (synopsis "Simple test framework")
1237 (description "Stefil is a simple test framework for Common Lisp,
1238 with a focus on interactive development.")
1239 (license license:public-domain))))
1241 (define-public cl-hu.dwim.stefil
1242 (sbcl-package->cl-source-package sbcl-hu.dwim.stefil))
1244 (define-public ecl-hu.dwim.stefil
1245 (sbcl-package->ecl-package sbcl-hu.dwim.stefil))
1247 (define-public sbcl-babel
1248 ;; No release since 2014.
1249 (let ((commit "aeed2d1b76358db48e6b70a64399c05678a6b9ea"))
1252 (version (git-version "0.5.0" "1" commit))
1257 (url "https://github.com/cl-babel/babel")
1259 (file-name (git-file-name "babel" version))
1261 (base32 "0lkvv4xdpv4cv1y2bqillmabx8sdb2y4l6pbinq6mjh33w2brpvb"))))
1262 (build-system asdf-build-system/sbcl)
1264 `(("tests:cl-hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
1266 `(("sbcl-alexandria" ,sbcl-alexandria)
1267 ("sbcl-trivial-features" ,sbcl-trivial-features)))
1268 (home-page "https://common-lisp.net/project/babel/")
1269 (synopsis "Charset encoding and decoding library")
1270 (description "Babel is a charset encoding and decoding library, not unlike
1271 GNU libiconv, but completely written in Common Lisp.")
1272 (license license:expat))))
1274 (define-public cl-babel
1275 (sbcl-package->cl-source-package sbcl-babel))
1277 (define-public ecl-babel
1278 (sbcl-package->ecl-package sbcl-babel))
1280 (define-public sbcl-cl-yacc
1282 (name "sbcl-cl-yacc")
1288 (url "https://github.com/jech/cl-yacc")
1289 (commit (string-append "cl-yacc-" version))))
1292 "16946pzf8vvadnyfayvj8rbh4zjzw90h0azz2qk1mxrvhh5wklib"))
1293 (file-name (string-append "cl-yacc-" version "-checkout"))))
1294 (build-system asdf-build-system/sbcl)
1296 `(#:asd-file "yacc.asd"
1297 #:asd-system-name "yacc"))
1298 (synopsis "LALR(1) parser generator for Common Lisp, similar in spirit to Yacc")
1300 "CL-Yacc is a LALR(1) parser generator for Common Lisp, similar in spirit
1301 to AT&T Yacc, Berkeley Yacc, GNU Bison, Zebu, lalr.cl or lalr.scm.
1303 CL-Yacc uses the algorithm due to Aho and Ullman, which is the one also used
1304 by AT&T Yacc, Berkeley Yacc and Zebu. It does not use the faster algorithm due
1305 to DeRemer and Pennello, which is used by Bison and lalr.scm (not lalr.cl).")
1306 (home-page "https://www.irif.fr/~jch//software/cl-yacc/")
1307 (license license:expat)))
1309 (define-public cl-yacc
1310 (sbcl-package->cl-source-package sbcl-cl-yacc))
1312 (define-public ecl-cl-yacc
1313 (sbcl-package->ecl-package sbcl-cl-yacc))
1315 (define-public sbcl-eager-future2
1316 (let ((commit "54df8effd9d9eccac917509590286b5ac5f9cb30"))
1318 (name "sbcl-eager-future2")
1319 (version (git-version "0.0.0" "1" commit))
1324 (url "https://gitlab.common-lisp.net/vsedach/eager-future2.git")
1326 (file-name (git-file-name name version))
1329 "1qs1bv3m0ki8l5czhsflxcryh22r9d9g9a3a3b0cr0pl954q5rld"))))
1330 (build-system asdf-build-system/sbcl)
1332 `(("bordeaux-threads" ,sbcl-bordeaux-threads)
1333 ("trivial-garbage" ,sbcl-trivial-garbage)))
1334 (synopsis "Futures promises synchronization mechanism for Common Lisp")
1336 "Eager Future2 is a Common Lisp library that provides composable
1337 concurrency primitives that unify parallel and lazy evaluation, are integrated
1338 with the Common Lisp condition system, and have automatic resource
1340 (home-page "https://gitlab.common-lisp.net/vsedach/eager-future2")
1341 (license license:lgpl3+))))
1343 (define-public cl-eager-future2
1344 (sbcl-package->cl-source-package sbcl-eager-future2))
1346 (define-public ecl-eager-future2
1347 (sbcl-package->ecl-package sbcl-eager-future2))
1349 (define-public sbcl-jpl-util
1350 (let ((commit "0311ed374e19a49d43318064d729fe3abd9a3b62"))
1352 (name "sbcl-jpl-util")
1353 (version "20151005")
1358 ;; Quicklisp uses this fork.
1359 (url "https://github.com/hawkir/cl-jpl-util")
1362 (git-file-name "jpl-util" version))
1365 "0nc0rk9n8grkg3045xsw34whmcmddn2sfrxki4268g7kpgz0d2yz"))))
1366 (build-system asdf-build-system/sbcl)
1367 (synopsis "Collection of Common Lisp utility functions and macros")
1369 "@command{cl-jpl-util} is a collection of Common Lisp utility functions
1370 and macros, primarily for software projects written in CL by the author.")
1371 (home-page "https://www.thoughtcrime.us/software/cl-jpl-util/")
1372 (license license:isc))))
1374 (define-public cl-jpl-util
1375 (sbcl-package->cl-source-package sbcl-jpl-util))
1377 (define-public ecl-jpl-util
1378 (sbcl-package->ecl-package sbcl-jpl-util))
1380 (define-public sbcl-jpl-queues
1382 (name "sbcl-jpl-queues")
1388 "http://www.thoughtcrime.us/software/jpl-queues/jpl-queues-"
1393 "1wvvv7j117h9a42qaj1g4fh4mji28xqs7s60rn6d11gk9jl76h96"))))
1394 (build-system asdf-build-system/sbcl)
1396 `(("jpl-util" ,sbcl-jpl-util)
1397 ("bordeaux-threads" ,sbcl-bordeaux-threads)))
1399 ;; Tests seem to be broken.
1401 (synopsis "Common Lisp library implementing a few different kinds of queues")
1403 "A Common Lisp library implementing a few different kinds of queues:
1406 @item Bounded and unbounded FIFO queues.
1407 @item Lossy bounded FIFO queues that drop elements when full.
1408 @item Unbounded random-order queues that use less memory than unbounded FIFO queues.
1411 Additionally, a synchronization wrapper is provided to make any queue
1412 conforming to the @command{jpl-queues} API thread-safe for lightweight
1413 multithreading applications. (See Calispel for a more sophisticated CL
1414 multithreaded message-passing library with timeouts and alternation among
1415 several blockable channels.)")
1416 (home-page "https://www.thoughtcrime.us/software/jpl-queues/")
1417 (license license:isc)))
1419 (define-public cl-jpl-queues
1420 (sbcl-package->cl-source-package sbcl-jpl-queues))
1422 (define-public ecl-jpl-queues
1423 (sbcl-package->ecl-package sbcl-jpl-queues))
1425 (define-public sbcl-calispel
1426 (let ((commit "e9f2f9c1af97f4d7bb4c8ac25fb2a8f3e8fada7a"))
1428 (name "sbcl-calispel")
1429 (version (git-version "0.1" "1" commit))
1434 ;; This fork replaces the dependency on the obsolete
1435 ;; eager-future with eager-future2.
1436 (url "https://github.com/hawkir/calispel")
1438 (file-name (git-file-name name version))
1441 "08bmf3pi7n5hadpmqqkg65cxcj6kbvm997wcs1f53ml1nb79d9z8"))))
1442 (build-system asdf-build-system/sbcl)
1444 `(("jpl-queues" ,sbcl-jpl-queues)
1445 ("bordeaux-threads" ,sbcl-bordeaux-threads)))
1447 `(("eager-future2" ,sbcl-eager-future2)))
1448 (synopsis "Thread-safe message-passing channels in Common Lisp")
1450 "Calispel is a Common Lisp library for thread-safe message-passing
1451 channels, in the style of the occam programming language, also known as
1452 communicating sequential processes (CSP). See
1453 @url{https://en.wikipedia.org/wiki/Communicating_sequential_processes}.
1455 Calispel channels let one thread communicate with another, facilitating
1456 unidirectional communication of any Lisp object. Channels may be unbuffered,
1457 where a sender waits for a receiver (or vice versa) before either operation can
1458 continue, or channels may be buffered with flexible policy options.
1460 Because sending and receiving on a channel may block, either operation can time
1461 out after a specified amount of time.
1463 A syntax for alternation is provided (like @code{ALT} in occam, or Unix
1464 @code{select()}): given a sequence of operations, any or all of which may
1465 block, alternation selects the first operation that doesn't block and executes
1466 associated code. Alternation can also time out, executing an \"otherwise\"
1467 clause if no operation becomes available within a set amount of time.
1469 Calispel is a message-passing library, and as such leaves the role of
1470 threading abstractions and utilities left to be filled by complementary
1471 libraries such as Bordeaux-Threads and Eager Future.")
1472 (home-page "https://www.thoughtcrime.us/software/jpl-queues/")
1473 (license license:isc))))
1475 (define-public cl-calispel
1476 (sbcl-package->cl-source-package sbcl-calispel))
1478 (define-public ecl-calispel
1479 (sbcl-package->ecl-package sbcl-calispel))
1481 (define-public sbcl-eos
1482 (let ((commit "b4413bccc4d142cbe1bf49516c3a0a22c9d99243")
1486 (version (git-version "0.0.0" revision commit))
1491 (url "https://github.com/adlai/Eos")
1494 (base32 "1afllvmlnx97yzz404gycl3pa3kwx427k3hrbf37rpmjlv47knhk"))
1495 (file-name (git-file-name "eos" version))))
1496 (build-system asdf-build-system/sbcl)
1497 (synopsis "Unit Testing for Common Lisp")
1499 "Eos was a unit testing library for Common Lisp.
1500 It began as a fork of FiveAM; however, FiveAM development has continued, while
1501 that of Eos has not. Thus, Eos is now deprecated in favor of FiveAM.")
1502 (home-page "https://github.com/adlai/Eos")
1503 (license license:expat))))
1505 (define-public cl-eos
1506 (sbcl-package->cl-source-package sbcl-eos))
1508 (define-public ecl-eos
1509 (sbcl-package->ecl-package sbcl-eos))
1511 (define-public sbcl-esrap
1512 (let ((commit "133be8b05c2aae48696fe5b739eea2fa573fa48d"))
1515 (version (git-version "0.0.0" "1" commit))
1520 (url "https://github.com/nikodemus/esrap")
1524 "02d5clihsdryhf7pix8c5di2571fdsffh75d40fkzhws90r5mksl"))
1525 (file-name (git-file-name "esrap" version))))
1526 (build-system asdf-build-system/sbcl)
1528 `(("eos" ,sbcl-eos))) ;For testing only.
1530 `(("alexandria" ,sbcl-alexandria)))
1531 (synopsis "Common Lisp packrat parser")
1533 "A packrat parser for Common Lisp.
1534 In addition to regular Packrat / Parsing Grammar / TDPL features ESRAP supports:
1537 @item dynamic redefinition of nonterminals
1538 @item inline grammars
1539 @item semantic predicates
1540 @item introspective facilities (describing grammars, tracing, setting breaks)
1542 (home-page "https://nikodemus.github.io/esrap/")
1543 (license license:expat))))
1545 (define-public cl-esrap
1546 (sbcl-package->cl-source-package sbcl-esrap))
1548 (define-public ecl-esrap
1549 (sbcl-package->ecl-package sbcl-esrap))
1551 (define-public sbcl-split-sequence
1553 (name "sbcl-split-sequence")
1559 (url "https://github.com/sharplispers/split-sequence")
1560 (commit (string-append "v" version))))
1563 "0jcpnx21hkfwqj5fvp7kc6pn1qcz9hk7g2s5x8h0349x1j2irln0"))
1564 (file-name (git-file-name "split-sequence" version))))
1565 (build-system asdf-build-system/sbcl)
1567 `(("fiveam" ,sbcl-fiveam)))
1568 (synopsis "Member of the Common Lisp Utilities family of programs")
1570 "Splits sequence into a list of subsequences delimited by objects
1571 satisfying the test.")
1572 (home-page "https://cliki.net/split-sequence")
1573 (license license:expat)))
1575 (define-public cl-split-sequence
1576 (sbcl-package->cl-source-package sbcl-split-sequence))
1578 (define-public ecl-split-sequence
1579 (sbcl-package->ecl-package sbcl-split-sequence))
1581 (define-public sbcl-html-encode
1583 (name "sbcl-html-encode")
1589 "http://beta.quicklisp.org/archive/html-encode/2010-10-06/html-encode-"
1593 "06mf8wn95yf5swhmzk4vp0xr4ylfl33dgfknkabbkd8n6jns8gcf"))
1594 (file-name (string-append "colorize" version "-checkout"))))
1595 (build-system asdf-build-system/sbcl)
1596 (synopsis "Common Lisp library for encoding text in various web-savvy encodings")
1598 "A library for encoding text in various web-savvy encodings.")
1599 (home-page "http://quickdocs.org/html-encode/")
1600 (license license:expat)))
1602 (define-public cl-html-encode
1603 (sbcl-package->cl-source-package sbcl-html-encode))
1605 (define-public ecl-html-encode
1606 (sbcl-package->ecl-package sbcl-html-encode))
1608 (define-public sbcl-colorize
1609 (let ((commit "ea676b584e0899cec82f21a9e6871172fe3c0eb5"))
1611 (name "sbcl-colorize")
1612 (version (git-version "0.0.0" "1" commit))
1617 (url "https://github.com/kingcons/colorize")
1621 "1pdg4kiaczmr3ivffhirp7m3lbr1q27rn7dhaay0vwghmi31zcw9"))
1622 (file-name (git-file-name "colorize" version))))
1623 (build-system asdf-build-system/sbcl)
1625 `(("alexandria" ,sbcl-alexandria)
1626 ("split-sequence" ,sbcl-split-sequence)
1627 ("html-encode" ,sbcl-html-encode)))
1628 (synopsis "Common Lisp for syntax highlighting")
1630 "@command{colorize} is a Lisp library for syntax highlighting
1631 supporting the following languages: Common Lisp, Emacs Lisp, Scheme, Clojure,
1632 C, C++, Java, Python, Erlang, Haskell, Objective-C, Diff, Webkit.")
1633 (home-page "https://github.com/kingcons/colorize")
1634 ;; TODO: Missing license?
1635 (license license:expat))))
1637 (define-public cl-colorize
1638 (sbcl-package->cl-source-package sbcl-colorize))
1640 (define-public ecl-colorize
1641 (sbcl-package->ecl-package sbcl-colorize))
1643 (define-public sbcl-3bmd
1644 (let ((commit "192ea13435b605a96ef607df51317056914cabbd"))
1647 (version (git-version "0.0.0" "1" commit))
1652 (url "https://github.com/3b/3bmd")
1656 "1rgv3gi7wf963ikmmpk132wgn0icddf226gq3bmcnk1fr3v9gf2f"))
1657 (file-name (git-file-name "3bmd" version))))
1658 (build-system asdf-build-system/sbcl)
1660 ;; FIXME: We need to specify the name because the build-system thinks
1661 ;; "3" is a version marker.
1662 `(#:asd-system-name "3bmd"))
1664 `(("esrap" ,sbcl-esrap)
1665 ("split-sequence" ,sbcl-split-sequence)))
1666 (synopsis "Markdown processor in Command Lisp using esrap parser")
1668 "Common Lisp Markdown -> HTML converter, using @command{esrap} for
1669 parsing, and grammar based on @command{peg-markdown}.")
1670 (home-page "https://github.com/3b/3bmd")
1671 (license license:expat))))
1673 (define-public cl-3bmd
1674 (sbcl-package->cl-source-package sbcl-3bmd))
1676 (define-public ecl-3bmd
1677 (sbcl-package->ecl-package sbcl-3bmd))
1679 (define-public sbcl-3bmd-ext-code-blocks
1680 (let ((commit "192ea13435b605a96ef607df51317056914cabbd"))
1683 (name "sbcl-3bmd-ext-code-blocks")
1685 `(#:asd-system-name "3bmd-ext-code-blocks"
1686 #:asd-file "3bmd-ext-code-blocks.asd"))
1688 `(("3bmd" ,sbcl-3bmd)
1689 ("colorize" ,sbcl-colorize)))
1690 (synopsis "3bmd extension which adds support for GitHub-style fenced
1693 "3bmd extension which adds support for GitHub-style fenced code blocks,
1694 with @command{colorize} support."))))
1696 (define-public cl-3bmd-ext-code-blocks
1697 (sbcl-package->cl-source-package sbcl-3bmd-ext-code-blocks))
1699 (define-public ecl-3bmd-ext-code-blocks
1700 (sbcl-package->ecl-package sbcl-3bmd-ext-code-blocks))
1702 (define-public sbcl-cl-fad
1704 (name "sbcl-cl-fad")
1710 (url "https://github.com/edicl/cl-fad/")
1711 (commit (string-append "v" version))))
1714 "1gc8i82v6gks7g0lnm54r4prk2mklidv2flm5fvbr0a7rsys0vpa"))
1715 (file-name (string-append "cl-fad" version "-checkout"))))
1716 (build-system asdf-build-system/sbcl)
1718 `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
1719 (synopsis "Portable pathname library for Common Lisp")
1721 "CL-FAD (for \"Files and Directories\") is a thin layer atop Common
1722 Lisp's standard pathname functions. It is intended to provide some
1723 unification between current CL implementations on Windows, OS X, Linux, and
1724 Unix. Most of the code was written by Peter Seibel for his book Practical
1726 (home-page "https://edicl.github.io/cl-fad/")
1727 (license license:bsd-2)))
1729 (define-public cl-fad
1730 (sbcl-package->cl-source-package sbcl-cl-fad))
1732 (define-public ecl-cl-fad
1733 (sbcl-package->ecl-package sbcl-cl-fad))
1735 (define-public sbcl-rt
1736 (let ((commit "a6a7503a0b47953bc7579c90f02a6dba1f6e4c5a")
1740 (version (git-version "1990.12.19" revision commit))
1745 (url "http://git.kpe.io/rt.git")
1747 (file-name (git-file-name name version))
1749 (base32 "13si2rrxaagbr0bkvg6sqicxxpyshabx6ad6byc9n2ik5ysna69b"))))
1750 (build-system asdf-build-system/sbcl)
1751 (synopsis "MIT Regression Tester")
1753 "RT provides a framework for writing regression test suites.")
1754 (home-page "https://www.cliki.net/rt")
1755 (license license:expat))))
1757 (define-public cl-rt
1758 (sbcl-package->cl-source-package sbcl-rt))
1760 (define-public ecl-rt
1761 (sbcl-package->ecl-package sbcl-rt))
1763 (define-public sbcl-nibbles
1765 (name "sbcl-nibbles")
1771 (url "https://github.com/sharplispers/nibbles/")
1772 (commit (string-append "v" version))))
1775 "1v7qfgpvdr6nz7v63dj69d26dis0kff3rd8xamr1llfdvza2pm8f"))
1776 (file-name (git-file-name "nibbles" version))))
1777 (build-system asdf-build-system/sbcl)
1781 (synopsis "Common Lisp library for accessing octet-addressed blocks of data")
1783 "When dealing with network protocols and file formats, it's common to
1784 have to read or write 16-, 32-, or 64-bit datatypes in signed or unsigned
1785 flavors. Common Lisp sort of supports this by specifying :element-type for
1786 streams, but that facility is underspecified and there's nothing similar for
1787 read/write from octet vectors. What most people wind up doing is rolling their
1788 own small facility for their particular needs and calling it a day.
1790 This library attempts to be comprehensive and centralize such
1791 facilities. Functions to read 16-, 32-, and 64-bit quantities from octet
1792 vectors in signed or unsigned flavors are provided; these functions are also
1793 SETFable. Since it's sometimes desirable to read/write directly from streams,
1794 functions for doing so are also provided. On some implementations,
1795 reading/writing IEEE singles/doubles (i.e. single-float and double-float) will
1796 also be supported.")
1797 (home-page "https://github.com/sharplispers/nibbles")
1798 (license license:bsd-3)))
1800 (define-public cl-nibbles
1801 (sbcl-package->cl-source-package sbcl-nibbles))
1803 (define-public ecl-nibbles
1804 (sbcl-package->ecl-package sbcl-nibbles))
1806 (define-public sbcl-ironclad
1808 (name "sbcl-ironclad")
1814 (url "https://github.com/sharplispers/ironclad/")
1815 (commit (string-append "v" version))))
1817 (base32 "1zxkzbxsfb83bb87rhp4h75cc1h5f6ziyfa5lvaa30zgix9l2d7v"))
1818 (file-name (git-file-name name version))))
1819 (build-system asdf-build-system/sbcl)
1824 `(("bordeaux-threads" ,sbcl-bordeaux-threads)
1825 ("flexi-streams" ,sbcl-flexi-streams)))
1826 (synopsis "Cryptographic toolkit written in Common Lisp")
1828 "Ironclad is a cryptography library written entirely in Common Lisp.
1829 It includes support for several popular ciphers, digests, MACs and public key
1830 cryptography algorithms. For several implementations that support Gray
1831 streams, support is included for convenient stream wrappers.")
1832 (home-page "https://github.com/sharplispers/ironclad")
1833 (license license:bsd-3)))
1835 (define-public cl-ironclad
1836 (sbcl-package->cl-source-package sbcl-ironclad))
1838 (define-public ecl-ironclad
1839 (sbcl-package->ecl-package sbcl-ironclad))
1841 (define-public sbcl-named-readtables
1842 (let ((commit "64bd53f37a1694cfde48fc38b8f03901f6f0c05b")
1845 (name "sbcl-named-readtables")
1846 (version (git-version "0.9" revision commit))
1851 (url "https://github.com/melisgl/named-readtables")
1854 (base32 "01l4831m7k84qvhzyx0qgdl50isr4zmp40qf6dfq2iqcaj8y4h3n"))
1855 (file-name (git-file-name "named-readtables" version))))
1856 (build-system asdf-build-system/sbcl)
1858 ;; Tests seem to be broken.
1860 (home-page "https://github.com/melisgl/named-readtables/")
1861 (synopsis "Library that creates a namespace for named readtables")
1862 (description "Named readtables is a library that creates a namespace for
1863 named readtables, which is akin to package namespacing in Common Lisp.")
1864 (license license:bsd-3))))
1866 (define-public cl-named-readtables
1867 (sbcl-package->cl-source-package sbcl-named-readtables))
1869 (define-public ecl-named-readtables
1870 (sbcl-package->ecl-package sbcl-named-readtables))
1872 (define-public sbcl-pythonic-string-reader
1873 (let ((commit "47a70ba1e32362e03dad6ef8e6f36180b560f86a"))
1875 (name "sbcl-pythonic-string-reader")
1876 (version (git-version "0.0.0" "1" commit))
1881 (url "https://github.com/smithzvk/pythonic-string-reader/")
1884 (base32 "1b5iryqw8xsh36swckmz8rrngmc39k92si33fgy5pml3n9l5rq3j"))
1885 (file-name (git-file-name "pythonic-string-reader" version))))
1886 (build-system asdf-build-system/sbcl)
1888 `(("named-readtables" ,sbcl-named-readtables)))
1889 (home-page "https://github.com/smithzvk/pythonic-string-reader")
1890 (synopsis "Read table modification inspired by Python's three quote strings")
1891 (description "This piece of code sets up some reader macros that make it
1892 simpler to input string literals which contain backslashes and double quotes
1893 This is very useful for writing complicated docstrings and, as it turns out,
1894 writing code that contains string literals that contain code themselves.")
1895 (license license:bsd-3))))
1897 (define-public cl-pythonic-string-reader
1898 (sbcl-package->cl-source-package sbcl-pythonic-string-reader))
1900 (define-public ecl-pythonic-string-reader
1901 (sbcl-package->ecl-package sbcl-pythonic-string-reader))
1903 ;; SLIME does not have a ASDF system definition to build all of Swank. As a
1904 ;; result, the asdf-build-system/sbcl will produce an almost empty package.
1905 ;; Some work was done to fix this at
1906 ;; https://github.com/sionescu/slime/tree/swank-asdf but it was never merged
1907 ;; and is now lagging behind. Building SBCL fasls might not be worth the
1908 ;; hassle, so let's just ship the source then.
1909 (define-public cl-slime-swank
1911 (name "cl-slime-swank")
1915 (file-name (string-append name "-" version ".tar.gz"))
1918 (url "https://github.com/slime/slime/")
1919 (commit (string-append "v" version))))
1922 "0mxb1wnw19v0s72w2wkz5afdlzvpy5nn7pr4vav403qybac0sw5c"))))
1923 (build-system asdf-build-system/source)
1924 (home-page "https://github.com/slime/slime")
1925 (synopsis "Common Lisp Swank server")
1927 "This is only useful if you want to start a Swank server in a Lisp
1928 processes that doesn't run under Emacs. Lisp processes created by
1929 @command{M-x slime} automatically start the server.")
1930 (license (list license:gpl2+ license:public-domain))))
1932 (define-public sbcl-slime-swank
1933 (deprecated-package "sbcl-slime-swank" cl-slime-swank))
1935 (define-public sbcl-mgl-pax
1936 (let ((commit "818448418d6b9de74620f606f5b23033c6082769"))
1938 (name "sbcl-mgl-pax")
1939 (version (git-version "0.0.0" "1" commit))
1944 (url "https://github.com/melisgl/mgl-pax")
1948 "1p97zfkh130bdxqqxwaw2j9psv58751wakx7czbfpq410lg7dd7i"))
1949 (file-name (git-file-name "mgl-pax" version))))
1950 (build-system asdf-build-system/sbcl)
1952 `(("3bmd" ,sbcl-3bmd)
1953 ("3bmd-ext-code-blocks" ,sbcl-3bmd-ext-code-blocks)
1954 ("babel" ,sbcl-babel)
1955 ("cl-fad" ,sbcl-cl-fad)
1956 ("ironclad" ,sbcl-ironclad)
1957 ("named-readtables" ,sbcl-named-readtables)
1958 ("pythonic-string-reader" ,sbcl-pythonic-string-reader)))
1960 ;; Packages having mgl-pax as input complain that it can't find
1961 ;; swank if we put it in inputs, so let's put it in propageted-inputs.
1962 `(("swank" ,cl-slime-swank)))
1963 (synopsis "Exploratory programming environment and documentation generator")
1965 "PAX provides an extremely poor man's Explorable Programming
1966 environment. Narrative primarily lives in so called sections that mix markdown
1967 docstrings with references to functions, variables, etc, all of which should
1968 probably have their own docstrings.
1970 The primary focus is on making code easily explorable by using SLIME's
1971 @command{M-.} (@command{slime-edit-definition}). See how to enable some
1972 fanciness in Emacs Integration. Generating documentation from sections and all
1973 the referenced items in Markdown or HTML format is also implemented.
1975 With the simplistic tools provided, one may accomplish similar effects as with
1976 Literate Programming, but documentation is generated from code, not vice versa
1977 and there is no support for chunking yet. Code is first, code must look
1978 pretty, documentation is code.")
1979 (home-page "http://quotenil.com/")
1980 (license license:expat))))
1982 (define-public cl-mgl-pax
1983 (sbcl-package->cl-source-package sbcl-mgl-pax))
1985 (define-public ecl-mgl-pax
1986 (sbcl-package->ecl-package sbcl-mgl-pax))
1988 (define-public sbcl-lisp-unit
1989 (let ((commit "89653a232626b67400bf9a941f9b367da38d3815"))
1991 (name "sbcl-lisp-unit")
1992 (version (git-version "0.0.0" "1" commit))
1997 (url "https://github.com/OdonataResearchLLC/lisp-unit")
2001 "0p6gdmgr7p383nvd66c9y9fp2bjk4jx1lpa5p09g43hr9y9pp9ry"))
2002 (file-name (git-file-name "lisp-unit" version))))
2003 (build-system asdf-build-system/sbcl)
2004 (synopsis "Common Lisp Test framework inspired by JUnit to be simple of use")
2006 "@command{lisp-unit} is a Common Lisp library that supports unit
2007 testing. It is an extension of the library written by Chris Riesbeck.")
2008 (home-page "https://github.com/OdonataResearchLLC/lisp-unit")
2009 (license license:expat))))
2011 (define-public cl-lisp-unit
2012 (sbcl-package->cl-source-package sbcl-lisp-unit))
2014 (define-public ecl-lisp-unit
2015 (sbcl-package->ecl-package sbcl-lisp-unit))
2017 (define-public sbcl-anaphora
2019 (name "sbcl-anaphora")
2025 (url "https://github.com/tokenrove/anaphora")
2029 "19wfrk3asimznkli0x2rfy637hwpdgqyvwj3vhq9x7vjvyf5vv6x"))
2030 (file-name (git-file-name "anaphora" version))))
2031 (build-system asdf-build-system/sbcl)
2034 (synopsis "The anaphoric macro collection from Hell")
2036 "Anaphora is the anaphoric macro collection from Hell: it includes many
2037 new fiends in addition to old friends like @command{aif} and
2039 (home-page "https://github.com/tokenrove/anaphora")
2040 (license license:public-domain)))
2042 (define-public cl-anaphora
2043 (sbcl-package->cl-source-package sbcl-anaphora))
2045 (define-public ecl-anaphora
2046 (sbcl-package->ecl-package sbcl-anaphora))
2048 (define-public sbcl-lift
2049 (let ((commit "7d49a66c62759535624037826891152223d4206c"))
2052 (version (git-version "1.7.1" "1" commit))
2057 (url "https://github.com/gwkkwg/lift")
2061 "127v5avpz1i4m0lkaxqrq8hrl69rdazqaxf6s8awf0nd7wj2g4dp"))
2062 (file-name (git-file-name "lift" version))
2063 (modules '((guix build utils)))
2065 ;; Don't keep the bundled website
2067 (delete-file-recursively "website")
2069 (build-system asdf-build-system/sbcl)
2071 ;; The tests require a debugger, but we run with the debugger disabled.
2073 (synopsis "LIsp Framework for Testing")
2075 "The LIsp Framework for Testing (LIFT) is a unit and system test tool for LISP.
2076 Though inspired by SUnit and JUnit, it's built with Lisp in mind. In LIFT,
2077 testcases are organized into hierarchical testsuites each of which can have
2078 its own fixture. When run, a testcase can succeed, fail, or error. LIFT
2079 supports randomized testing, benchmarking, profiling, and reporting.")
2080 (home-page "https://github.com/gwkkwg/lift")
2081 (license license:expat))))
2083 (define-public cl-lift
2084 (sbcl-package->cl-source-package sbcl-lift))
2086 (define-public ecl-lift
2087 (sbcl-package->ecl-package sbcl-lift))
2089 (define-public sbcl-let-plus
2090 (let ((commit "5f14af61d501ecead02ec6b5a5c810efc0c9fdbb"))
2092 (name "sbcl-let-plus")
2093 (version (git-version "0.0.0" "1" commit))
2098 (url "https://github.com/sharplispers/let-plus")
2102 "0i050ca2iys9f5mb7dgqgqdxfnc3b0rnjdwv95sqd490vkiwrsaj"))
2103 (file-name (git-file-name "let-plus" version))))
2104 (build-system asdf-build-system/sbcl)
2106 `(("alexandria" ,sbcl-alexandria)
2107 ("anaphora" ,sbcl-anaphora)))
2109 `(("lift" ,sbcl-lift)))
2110 (synopsis "Destructuring extension of let*")
2112 "This library implements the let+ macro, which is a dectructuring
2113 extension of let*. It features:
2116 @item Clean, consistent syntax and small implementation (less than 300 LOC,
2118 @item Placeholder macros allow editor hints and syntax highlighting
2119 @item @command{&ign} for ignored values (in forms where that makes sense)
2120 @item Very easy to extend
2122 (home-page "https://github.com/sharplispers/let-plus")
2123 (license license:boost1.0))))
2125 (define-public cl-let-plus
2126 (sbcl-package->cl-source-package sbcl-let-plus))
2128 (define-public ecl-let-plus
2129 (sbcl-package->ecl-package sbcl-let-plus))
2131 (define-public sbcl-cl-colors
2132 (let ((commit "827410584553f5c717eec6182343b7605f707f75"))
2134 (name "sbcl-cl-colors")
2135 (version (git-version "0.0.0" "1" commit))
2140 (url "https://github.com/tpapp/cl-colors")
2144 "0l446lday4hybsm9bq3jli97fvv8jb1d33abg79vbylpwjmf3y9a"))
2145 (file-name (git-file-name "cl-colors" version))))
2146 (build-system asdf-build-system/sbcl)
2148 `(("alexandria" ,sbcl-alexandria)
2149 ("let-plus" ,sbcl-let-plus)))
2150 (synopsis "Simple color library for Common Lisp")
2152 "This is a very simple color library for Common Lisp, providing
2155 @item Types for representing colors in HSV and RGB spaces.
2156 @item Simple conversion functions between the above types (and also
2157 hexadecimal representation for RGB).
2158 @item Some predefined colors (currently X11 color names – of course the
2159 library does not depend on X11).Because color in your terminal is nice.
2162 This library is no longer supported by its author.")
2163 (home-page "https://github.com/tpapp/cl-colors")
2164 (license license:boost1.0))))
2166 (define-public cl-colors
2167 (sbcl-package->cl-source-package sbcl-cl-colors))
2169 (define-public ecl-cl-colors
2170 (sbcl-package->ecl-package sbcl-cl-colors))
2172 (define-public sbcl-cl-ansi-text
2173 (let ((commit "53badf7878f27f22f2d4a2a43e6df458e43acbe9"))
2175 (name "sbcl-cl-ansi-text")
2176 (version (git-version "1.0.0" "1" commit))
2181 (url "https://github.com/pnathan/cl-ansi-text")
2185 "11i27n0dbz5lmygiw65zzr8lx0rac6b6yysqranphn31wls6ja3v"))
2186 (file-name (git-file-name "cl-ansi-text" version))))
2187 (build-system asdf-build-system/sbcl)
2189 `(("alexandria" ,sbcl-alexandria)
2190 ("cl-colors" ,sbcl-cl-colors)))
2192 `(("fiveam" ,sbcl-fiveam)))
2193 (synopsis "ANSI terminal color implementation for Common Lisp")
2195 "@command{cl-ansi-text} provides utilities which enable printing to an
2196 ANSI terminal with colored text. It provides the macro @command{with-color}
2197 which causes everything printed in the body to be displayed with the provided
2198 color. It further provides functions which will print the argument with the
2200 (home-page "https://github.com/pnathan/cl-ansi-text")
2201 (license license:llgpl))))
2203 (define-public cl-ansi-text
2204 (sbcl-package->cl-source-package sbcl-cl-ansi-text))
2206 (define-public ecl-cl-ansi-text
2207 (sbcl-package->ecl-package sbcl-cl-ansi-text))
2209 (define-public sbcl-prove-asdf
2210 (let ((commit "4f9122bd393e63c5c70c1fba23070622317cfaa0"))
2212 (name "sbcl-prove-asdf")
2213 (version (git-version "1.0.0" "1" commit))
2218 (url "https://github.com/fukamachi/prove")
2222 "07sbfw459z8bbjvx1qlmfa8qk2mvbjnnzi2mi0x72blaj8bkl4vc"))
2223 (file-name (git-file-name "prove" version))))
2224 (build-system asdf-build-system/sbcl)
2226 `(#:asd-file "prove-asdf.asd"))
2227 (synopsis "Test requirement for the Common Lisp 'prove' library")
2229 "Test requirement for the Common Lisp @command{prove} library.")
2230 (home-page "https://github.com/fukamachi/prove")
2231 (license license:expat))))
2233 (define-public cl-prove-asdf
2234 (sbcl-package->cl-source-package sbcl-prove-asdf))
2236 (define-public ecl-prove-asdf
2237 (sbcl-package->ecl-package sbcl-prove-asdf))
2239 (define-public sbcl-prove
2241 (inherit sbcl-prove-asdf)
2244 `(("alexandria" ,sbcl-alexandria)
2245 ("cl-ppcre" ,sbcl-cl-ppcre)
2246 ("cl-ansi-text" ,sbcl-cl-ansi-text)))
2248 `(("prove-asdf" ,sbcl-prove-asdf)))
2250 `(#:asd-file "prove.asd"))
2251 (synopsis "Yet another unit testing framework for Common Lisp")
2253 "This project was originally called @command{cl-test-more}.
2254 @command{prove} is yet another unit testing framework for Common Lisp. The
2255 advantages of @command{prove} are:
2258 @item Various simple functions for testing and informative error messages
2259 @item ASDF integration
2260 @item Extensible test reporters
2261 @item Colorizes the report if it's available (note for SLIME)
2262 @item Reports test durations
2265 (define-public cl-prove
2266 (sbcl-package->cl-source-package sbcl-prove))
2268 (define-public ecl-prove
2269 (sbcl-package->ecl-package sbcl-prove))
2271 (define-public sbcl-proc-parse
2272 (let ((commit "ac3636834d561bdc2686c956dbd82494537285fd"))
2274 (name "sbcl-proc-parse")
2275 (version (git-version "0.0.0" "1" commit))
2280 (url "https://github.com/fukamachi/proc-parse")
2284 "06rnl0h4cx6xv2wj3jczmmcxqn2703inmmvg1s4npbghmijsybfh"))
2285 (file-name (git-file-name "proc-parse" version))))
2286 (build-system asdf-build-system/sbcl)
2288 `(("alexandria" ,sbcl-alexandria)
2289 ("babel" ,sbcl-babel)))
2291 `(("prove" ,sbcl-prove)
2292 ("prove-asdf" ,sbcl-prove-asdf)))
2294 ;; TODO: Tests don't find "proc-parse-test", why?
2296 (synopsis "Procedural vector parser")
2298 "This is a string/octets parser library for Common Lisp with speed and
2299 readability in mind. Unlike other libraries, the code is not a
2300 pattern-matching-like, but a char-by-char procedural parser.")
2301 (home-page "https://github.com/fukamachi/proc-parse")
2302 (license license:bsd-2))))
2304 (define-public cl-proc-parse
2305 (sbcl-package->cl-source-package sbcl-proc-parse))
2307 (define-public ecl-proc-parse
2308 (sbcl-package->ecl-package sbcl-proc-parse))
2310 (define-public sbcl-parse-float
2311 (let ((commit "2aae569f2a4b2eb3bfb5401a959425dcf151b09c"))
2313 (name "sbcl-parse-float")
2314 (version (git-version "0.0.0" "1" commit))
2319 (url "https://github.com/soemraws/parse-float")
2323 "08xw8cchhmqcc0byng69m3f5a2izc9y2290jzz2k0qrbibp1fdk7"))
2324 (file-name (git-file-name "proc-parse" version))))
2325 (build-system asdf-build-system/sbcl)
2327 `(("alexandria" ,sbcl-alexandria)
2328 ("babel" ,sbcl-babel)))
2330 `(("prove" ,sbcl-prove)
2331 ("prove-asdf" ,sbcl-prove-asdf)))
2333 ;; TODO: Tests don't find "proc-parse-test", why?
2335 (synopsis "Parse a floating point value from a string in Common Lisp")
2337 "This package exports the following function to parse floating-point
2338 values from a string in Common Lisp.")
2339 (home-page "https://github.com/soemraws/parse-float")
2340 (license license:public-domain))))
2342 (define-public cl-parse-float
2343 (sbcl-package->cl-source-package sbcl-parse-float))
2345 (define-public ecl-parse-float
2346 (sbcl-package->ecl-package sbcl-parse-float))
2348 (define-public sbcl-ascii-strings
2349 (let ((revision "1")
2350 (changeset "5048480a61243e6f1b02884012c8f25cdbee6d97"))
2352 (name "sbcl-ascii-strings")
2353 (version (string-append "0-" revision "." (string-take changeset 7)))
2358 (url "https://bitbucket.org/vityok/cl-string-match/")
2359 (changeset changeset)))
2362 "01wn5qx562w43ssy92xlfgv79w7p0nv0wbl76mpmba131n9ziq2y"))
2363 (file-name (git-file-name "cl-string-match" version))))
2364 (build-system asdf-build-system/sbcl)
2366 `(("alexandria" ,sbcl-alexandria)
2367 ("babel" ,sbcl-babel)))
2369 `(#:asd-file "ascii-strings.asd"))
2370 (synopsis "Operations on ASCII strings")
2372 "Operations on ASCII strings. Essentially this can be any kind of
2373 single-byte encoded strings.")
2374 (home-page "https://bitbucket.org/vityok/cl-string-match/")
2375 (license license:bsd-3))))
2377 (define-public cl-ascii-strings
2378 (sbcl-package->cl-source-package sbcl-ascii-strings))
2380 (define-public ecl-ascii-strings
2381 (sbcl-package->ecl-package sbcl-ascii-strings))
2383 (define-public sbcl-simple-scanf
2385 (inherit sbcl-ascii-strings)
2386 (name "sbcl-simple-scanf")
2388 `(("alexandria" ,sbcl-alexandria)
2389 ("iterate" ,sbcl-iterate)
2390 ("proc-parse" ,sbcl-proc-parse)
2391 ("parse-float" ,sbcl-parse-float)))
2393 `(#:asd-file "simple-scanf.asd"))
2394 (synopsis "Simple scanf-like functionality implementation")
2396 "A simple scanf-like functionality implementation.")))
2398 (define-public cl-simple-scanf
2399 (sbcl-package->cl-source-package sbcl-simple-scanf))
2401 (define-public ecl-simple-scanf
2402 (sbcl-package->ecl-package sbcl-simple-scanf))
2404 (define-public sbcl-cl-string-match
2406 (inherit sbcl-ascii-strings)
2407 (name "sbcl-cl-string-match")
2409 `(("alexandria" ,sbcl-alexandria)
2410 ("ascii-strings" ,sbcl-ascii-strings)
2411 ("yacc" ,sbcl-cl-yacc)
2412 ("jpl-util" ,sbcl-jpl-util)
2413 ("jpl-queues" ,sbcl-jpl-queues)
2414 ("mgl-pax" ,sbcl-mgl-pax)
2415 ("iterate" ,sbcl-iterate)))
2416 ;; TODO: Tests are not evaluated properly.
2419 `(("lisp-unit" ,sbcl-lisp-unit)
2420 ("simple-scanf" ,sbcl-simple-scanf)))
2423 #:asd-file "cl-string-match.asd"))
2424 (synopsis "Portable, dependency-free set of utilities to manipulate strings in Common Lisp")
2426 "@command{cl-strings} is a small, portable, dependency-free set of
2427 utilities that make it even easier to manipulate text in Common Lisp. It has
2428 100% test coverage and works at least on sbcl, ecl, ccl, abcl and clisp.")))
2430 (define-public cl-string-match
2431 (sbcl-package->cl-source-package sbcl-cl-string-match))
2433 (define-public ecl-cl-string-match
2434 (sbcl-package->ecl-package sbcl-cl-string-match))
2436 (define-public sbcl-ptester
2437 (let ((commit "fe69fde54f4bce00ce577feb918796c293fc7253")
2440 (name "sbcl-ptester")
2441 (version (git-version "2.1.3" revision commit))
2446 (url "http://git.kpe.io/ptester.git")
2448 (file-name (git-file-name name version))
2450 (base32 "1l0lfl7cdnr2qf4zh38hi4llxg22c49zkm639bdkmvlkzwj3ndwf"))))
2451 (build-system asdf-build-system/sbcl)
2452 (home-page "http://quickdocs.org/ptester/")
2453 (synopsis "Portable test harness package")
2455 "@command{ptester} is a portable testing framework based on Franz's
2457 (license license:llgpl))))
2459 (define-public cl-ptester
2460 (sbcl-package->cl-source-package sbcl-ptester))
2462 (define-public ecl-ptester
2463 (sbcl-package->ecl-package sbcl-ptester))
2465 (define-public sbcl-puri
2466 (let ((commit "ef5afb9e5286c8e952d4344f019c1a636a717b97")
2470 (version (git-version "1.5.7" revision commit))
2475 (url "http://git.kpe.io/puri.git")
2477 (file-name (git-file-name name version))
2479 (base32 "1vm25pdl92laj72p5vyd538kf3cjy2655z6bdc99h20ana2p231s"))))
2480 (build-system asdf-build-system/sbcl)
2482 `(("ptester" ,sbcl-ptester)))
2483 (home-page "http://quickdocs.org/puri/")
2484 (synopsis "Portable URI Library")
2486 "This is a portable Universal Resource Identifier library for Common
2487 Lisp programs. It parses URI according to the RFC 2396 specification.")
2488 (license license:llgpl))))
2490 (define-public cl-puri
2491 (sbcl-package->cl-source-package sbcl-puri))
2493 (define-public ecl-puri
2494 (sbcl-package->ecl-package sbcl-puri))
2496 (define-public sbcl-queues
2497 (let ((commit "47d4da65e9ea20953b74aeeab7e89a831b66bc94"))
2499 (name "sbcl-queues")
2500 (version (git-version "0.0.0" "1" commit))
2505 (url "https://github.com/oconnore/queues")
2507 (file-name (git-file-name "queues" version))
2510 "0wdhfnzi4v6d97pggzj2aw55si94w4327br94jrmyvwf351wqjvv"))))
2511 (build-system asdf-build-system/sbcl)
2512 (home-page "https://github.com/oconnore/queues")
2513 (synopsis "Common Lisp queue library")
2515 "This is a simple queue library for Common Lisp with features such as
2516 non-consing thread safe queues and fibonacci priority queues.")
2517 (license license:expat))))
2519 (define-public cl-queues
2520 (sbcl-package->cl-source-package sbcl-queues))
2522 (define-public ecl-queues
2523 (sbcl-package->ecl-package sbcl-queues))
2525 (define-public sbcl-queues.simple-queue
2527 (inherit sbcl-queues)
2528 (name "sbcl-queues.simple-queue")
2530 `(("sbcl-queues" ,sbcl-queues)))
2532 `(#:asd-file "queues.simple-queue.asd"))
2533 (synopsis "Simple queue implementation")
2535 "This is a simple queue library for Common Lisp with features such as
2536 non-consing thread safe queues and fibonacci priority queues.")
2537 (license license:expat)))
2539 (define-public cl-queues.simple-queue
2540 (sbcl-package->cl-source-package sbcl-queues.simple-queue))
2542 (define-public ecl-queues.simple-queue
2543 (sbcl-package->ecl-package sbcl-queues.simple-queue))
2545 (define-public sbcl-queues.simple-cqueue
2547 (inherit sbcl-queues)
2548 (name "sbcl-queues.simple-cqueue")
2550 `(("sbcl-queues" ,sbcl-queues)
2551 ("sbcl-queues.simple-queue" ,sbcl-queues.simple-queue)
2552 ("bordeaux-threads" ,sbcl-bordeaux-threads)))
2554 `(#:asd-file "queues.simple-cqueue.asd"))
2555 (synopsis "Thread safe queue implementation")
2557 "This is a simple queue library for Common Lisp with features such as
2558 non-consing thread safe queues and fibonacci priority queues.")
2559 (license license:expat)))
2561 (define-public cl-queues.simple-cqueue
2562 (sbcl-package->cl-source-package sbcl-queues.simple-cqueue))
2564 (define-public ecl-queues.simple-cqueue
2565 (sbcl-package->ecl-package sbcl-queues.simple-cqueue))
2567 (define-public sbcl-queues.priority-queue
2569 (inherit sbcl-queues)
2570 (name "sbcl-queues.priority-queue")
2572 `(("sbcl-queues" ,sbcl-queues)))
2574 `(#:asd-file "queues.priority-queue.asd"))
2575 (synopsis "Priority queue (Fibonacci) implementation")
2577 "This is a simple queue library for Common Lisp with features such as
2578 non-consing thread safe queues and fibonacci priority queues.")
2579 (license license:expat)))
2581 (define-public cl-queues.priority-queue
2582 (sbcl-package->cl-source-package sbcl-queues.priority-queue))
2584 (define-public ecl-queues.priority-queue
2585 (sbcl-package->ecl-package sbcl-queues.priority-queue))
2587 (define-public sbcl-queues.priority-cqueue
2589 (inherit sbcl-queues)
2590 (name "sbcl-queues.priority-cqueue")
2592 `(("sbcl-queues" ,sbcl-queues)
2593 ("sbcl-queues.priority-queue" ,sbcl-queues.priority-queue)
2594 ("bordeaux-threads" ,sbcl-bordeaux-threads)))
2596 `(#:asd-file "queues.priority-cqueue.asd"))
2597 (synopsis "Thread safe fibonacci priority queue implementation")
2599 "This is a simple queue library for Common Lisp with features such as
2600 non-consing thread safe queues and fibonacci priority queues.")
2601 (license license:expat)))
2603 (define-public cl-queues.priority-cqueue
2604 (sbcl-package->cl-source-package sbcl-queues.priority-cqueue))
2606 (define-public ecl-queues.priority-cqueue
2607 (sbcl-package->ecl-package sbcl-queues.priority-cqueue))
2609 (define sbcl-cffi-bootstrap
2611 (name "sbcl-cffi-bootstrap")
2617 (url "https://github.com/cffi/cffi")
2618 (commit (string-append "v" version))))
2619 (file-name (git-file-name "cffi-bootstrap" version))
2621 (base32 "1qalargz9bhp850qv60ffwpdqi4xirzar4l3g6qcg8yc6xqf2cjk"))))
2622 (build-system asdf-build-system/sbcl)
2624 `(("libffi" ,libffi)
2625 ("alexandria" ,sbcl-alexandria)
2626 ("babel" ,sbcl-babel)
2627 ("trivial-features" ,sbcl-trivial-features)))
2629 `(("pkg-config" ,pkg-config)))
2632 (modify-phases %standard-phases
2633 (add-after 'unpack 'fix-arm-support
2635 ;; This is apparently deprecated since libffi-3.3.
2636 (substitute* "libffi/libffi-types.lisp"
2637 (("\\\(\\\(:unix64.*") ")\n"))
2639 (add-after 'unpack 'fix-paths
2640 (lambda* (#:key inputs #:allow-other-keys)
2641 (substitute* "libffi/libffi.lisp"
2642 (("libffi.so.7" all) (string-append
2643 (assoc-ref inputs "libffi")
2645 (substitute* "toolchain/c-toolchain.lisp"
2646 (("\"cc\"") (format #f "~S" (which "gcc")))))))
2647 #:asd-system-name "cffi"
2649 (home-page "https://common-lisp.net/project/cffi/")
2650 (synopsis "Common Foreign Function Interface for Common Lisp")
2651 (description "The Common Foreign Function Interface (CFFI)
2652 purports to be a portable foreign function interface for Common Lisp.
2653 The CFFI library is composed of a Lisp-implementation-specific backend
2654 in the CFFI-SYS package, and a portable frontend in the CFFI
2656 (license license:expat)))
2658 (define-public sbcl-cffi-toolchain
2660 (inherit sbcl-cffi-bootstrap)
2661 (name "sbcl-cffi-toolchain")
2663 `(("libffi" ,libffi)
2664 ("sbcl-cffi" ,sbcl-cffi-bootstrap)))
2666 (substitute-keyword-arguments (package-arguments sbcl-cffi-bootstrap)
2667 ((#:asd-system-name _) #f)
2668 ((#:tests? _) #t)))))
2670 (define-public sbcl-cffi-libffi
2672 (inherit sbcl-cffi-toolchain)
2673 (name "sbcl-cffi-libffi")
2675 `(("cffi" ,sbcl-cffi-bootstrap)
2676 ("cffi-grovel" ,sbcl-cffi-grovel)
2677 ("trivial-features" ,sbcl-trivial-features)
2678 ("libffi" ,libffi)))))
2680 (define-public sbcl-cffi-grovel
2682 (inherit sbcl-cffi-toolchain)
2683 (name "sbcl-cffi-grovel")
2685 `(("libffi" ,libffi)
2686 ("cffi" ,sbcl-cffi-bootstrap)
2687 ("cffi-toolchain" ,sbcl-cffi-toolchain)
2688 ("alexandria" ,sbcl-alexandria)))
2690 (substitute-keyword-arguments (package-arguments sbcl-cffi-toolchain)
2692 `(modify-phases ,phases
2693 (add-after 'build 'install-headers
2694 (lambda* (#:key outputs #:allow-other-keys)
2695 (install-file "grovel/common.h"
2697 (assoc-ref outputs "out")
2701 (define-public sbcl-cffi
2703 (inherit sbcl-cffi-toolchain)
2705 (inputs (package-inputs sbcl-cffi-bootstrap))
2707 `(("cffi-grovel" ,sbcl-cffi-grovel)
2708 ("cffi-libffi" ,sbcl-cffi-libffi)
2710 ("bordeaux-threads" ,sbcl-bordeaux-threads)
2711 ,@(package-native-inputs sbcl-cffi-bootstrap)))))
2713 (define-public cl-cffi
2714 (sbcl-package->cl-source-package sbcl-cffi))
2716 (define-public sbcl-cffi-uffi-compat
2718 (inherit sbcl-cffi-toolchain)
2719 (name "sbcl-cffi-uffi-compat")
2721 `(,@(package-inputs sbcl-cffi-bootstrap))) ; For fix-paths phase
2723 `(("cffi" ,sbcl-cffi)))
2724 (synopsis "UFFI Compatibility Layer for CFFI")))
2726 (define-public cl-cffi-uffi-compat
2727 (sbcl-package->cl-source-package sbcl-cffi-uffi-compat))
2729 (define-public sbcl-cl-sqlite
2731 (name "sbcl-cl-sqlite")
2737 (url "https://github.com/dmitryvk/cl-sqlite")
2739 (file-name (git-file-name "cl-sqlite" version))
2742 "08iv7b4m0hh7qx2cvq4f510nrgdld0vicnvmqsh9w0fgrcgmyg4k"))))
2743 (build-system asdf-build-system/sbcl)
2745 `(("iterate" ,sbcl-iterate)
2747 ("sqlite" ,sqlite)))
2749 `(("fiveam" ,sbcl-fiveam)
2750 ("bordeaux-threads" ,sbcl-bordeaux-threads)))
2752 `(#:asd-file "sqlite.asd"
2753 #:asd-system-name "sqlite"
2755 (modify-phases %standard-phases
2756 (add-after 'unpack 'fix-paths
2757 (lambda* (#:key inputs #:allow-other-keys)
2758 (substitute* "sqlite-ffi.lisp"
2759 (("libsqlite3" all) (string-append
2760 (assoc-ref inputs "sqlite")"/lib/" all))))))))
2761 (home-page "https://common-lisp.net/project/cl-sqlite/")
2762 (synopsis "Common Lisp binding for SQLite")
2764 "The @command{cl-sqlite} package is an interface to the SQLite embedded
2765 relational database engine.")
2766 (license license:public-domain)))
2768 (define-public cl-sqlite
2769 (sbcl-package->cl-source-package sbcl-cl-sqlite))
2771 (define-public sbcl-parenscript
2772 ;; Source archives are overwritten on every release, we use the Git repo instead.
2773 (let ((commit "7a1ac46353cecd144fc91915ba9f122aafcf4766"))
2775 (name "sbcl-parenscript")
2776 (version (git-version "2.7.1" "1" commit))
2781 (url "https://gitlab.common-lisp.net/parenscript/parenscript")
2783 (file-name (git-file-name "parenscript" version))
2786 "0c22lqarrpbq82dg1sb3y6mp6w2faczp34ymzhnmff88yfq1xzsf"))))
2787 (build-system asdf-build-system/sbcl)
2789 `(("cl-ppcre" ,sbcl-cl-ppcre)
2790 ("anaphora" ,sbcl-anaphora)
2791 ("named-readtables" ,sbcl-named-readtables)))
2792 (home-page "https://common-lisp.net/project/parenscript/")
2793 (synopsis "Translator from a subset of Common Lisp to JavaScript")
2795 "Parenscript is a translator from an extended subset of Common Lisp to
2796 JavaScript. Parenscript code can run almost identically on both the
2797 browser (as JavaScript) and server (as Common Lisp).
2799 Parenscript code is treated the same way as Common Lisp code, making the full
2800 power of Lisp macros available for JavaScript. This provides a web
2801 development environment that is unmatched in its ability to reduce code
2802 duplication and provide advanced meta-programming facilities to web
2805 At the same time, Parenscript is different from almost all other \"language
2806 X\" to JavaScript translators in that it imposes almost no overhead:
2809 @item No run-time dependencies: Any piece of Parenscript code is runnable
2810 as-is. There are no JavaScript files to include.
2811 @item Native types: Parenscript works entirely with native JavaScript data
2812 types. There are no new types introduced, and object prototypes are not
2814 @item Native calling convention: Any JavaScript code can be called without the
2815 need for bindings. Likewise, Parenscript can be used to make efficient,
2816 self-contained JavaScript libraries.
2817 @item Readable code: Parenscript generates concise, formatted, idiomatic
2818 JavaScript code. Identifier names are preserved. This enables seamless
2819 debugging in tools like Firebug.
2820 @item Efficiency: Parenscript introduces minimal overhead for advanced Common
2821 Lisp features. The generated code is almost as fast as hand-written
2824 (license license:bsd-3))))
2826 (define-public cl-parenscript
2827 (sbcl-package->cl-source-package sbcl-parenscript))
2829 (define-public ecl-parenscript
2830 (sbcl-package->ecl-package sbcl-parenscript))
2832 (define-public sbcl-cl-json
2833 (let ((commit "6dfebb9540bfc3cc33582d0c03c9ec27cb913e79"))
2835 (name "sbcl-cl-json")
2836 (version (git-version "0.5" "1" commit))
2841 (url "https://github.com/hankhero/cl-json")
2843 (file-name (git-file-name "cl-json" version))
2846 "0fx3m3x3s5ji950yzpazz4s0img3l6b3d6l3jrfjv0lr702496lh"))))
2847 (build-system asdf-build-system/sbcl)
2849 `(("fiveam" ,sbcl-fiveam)))
2850 (home-page "https://github.com/hankhero/cl-json")
2851 (synopsis "JSON encoder and decoder for Common-Lisp")
2853 "@command{cl-json} provides an encoder of Lisp objects to JSON format
2854 and a corresponding decoder of JSON data to Lisp objects. Both the encoder
2855 and the decoder are highly customizable; at the same time, the default
2856 settings ensure a very simple mode of operation, similar to that provided by
2857 @command{yason} or @command{st-json}.")
2858 (license license:expat))))
2860 (define-public cl-json
2861 (sbcl-package->cl-source-package sbcl-cl-json))
2863 (define-public ecl-cl-json
2864 (sbcl-package->ecl-package sbcl-cl-json))
2866 (define-public sbcl-unix-opts
2868 (name "sbcl-unix-opts")
2874 (url "https://github.com/libre-man/unix-opts")
2876 (file-name (git-file-name "unix-opts" version))
2879 "08djdi1ard09fijb7w9bdmhmwd98b1hzmcnjw9fqjiqa0g3b44rr"))))
2880 (build-system asdf-build-system/sbcl)
2881 (home-page "https://github.com/hankhero/cl-json")
2882 (synopsis "Unix-style command line options parser")
2884 "This is a minimalistic parser of command line options. The main
2885 advantage of the library is the ability to concisely define command line
2886 options once and then use this definition for parsing and extraction of
2887 command line arguments, as well as printing description of command line
2888 options (you get --help for free). This way you don't need to repeat
2889 yourself. Also, @command{unix-opts} doesn't depend on anything and
2890 precisely controls the behavior of the parser via Common Lisp restarts.")
2891 (license license:expat)))
2893 (define-public cl-unix-opts
2894 (sbcl-package->cl-source-package sbcl-unix-opts))
2896 (define-public ecl-unix-opts
2897 (sbcl-package->ecl-package sbcl-unix-opts))
2899 (define-public sbcl-trivial-garbage
2901 (name "sbcl-trivial-garbage")
2907 (url "https://github.com/trivial-garbage/trivial-garbage")
2908 (commit (string-append "v" version))))
2909 (file-name (git-file-name "trivial-garbage" version))
2911 (base32 "0122jicfg7pca1wxw8zak1n92h5friqy60988ns0ysksj3fphw9n"))))
2912 (build-system asdf-build-system/sbcl)
2915 (home-page "https://common-lisp.net/project/trivial-garbage/")
2916 (synopsis "Portable GC-related APIs for Common Lisp")
2917 (description "@command{trivial-garbage} provides a portable API to
2918 finalizers, weak hash-tables and weak pointers on all major implementations of
2919 the Common Lisp programming language.")
2920 (license license:public-domain)))
2922 (define-public cl-trivial-garbage
2923 (sbcl-package->cl-source-package sbcl-trivial-garbage))
2925 (define-public ecl-trivial-garbage
2926 (sbcl-package->ecl-package sbcl-trivial-garbage))
2928 (define-public sbcl-closer-mop
2929 (let ((commit "19c9d33f576e10715fd79cc1d4f688dab0f241d6"))
2931 (name "sbcl-closer-mop")
2932 (version (git-version "1.0.0" "2" commit))
2937 (url "https://github.com/pcostanza/closer-mop")
2940 (base32 "1w3x087wvlwkd6swfdgbvjfs6kazf0la8ax4pjfzikwjch4snn2c"))
2941 (file-name (git-file-name "closer-mop" version ))))
2942 (build-system asdf-build-system/sbcl)
2943 (home-page "https://github.com/pcostanza/closer-mop")
2944 (synopsis "Rectifies absent or incorrect CLOS MOP features")
2945 (description "Closer to MOP is a compatibility layer that rectifies many
2946 of the absent or incorrect CLOS MOP features across a broad range of Common
2947 Lisp implementations.")
2948 (license license:expat))))
2950 (define-public cl-closer-mop
2951 (sbcl-package->cl-source-package sbcl-closer-mop))
2953 (define-public ecl-closer-mop
2954 (sbcl-package->ecl-package sbcl-closer-mop))
2956 (define sbcl-cl-cffi-gtk-boot0
2957 (let ((commit "e9a46df65995d9a16e6c8dbdc1e09b775eb4a966"))
2959 (name "sbcl-cl-cffi-gtk-boot0")
2960 (version (git-version "0.11.2" "2" commit))
2965 (url "https://github.com/Ferada/cl-cffi-gtk/")
2967 (file-name (git-file-name "cl-cffi-gtk" version))
2970 "04vix0gmqsj91lm975sx7jhlnz5gq1xf9jp873mp7c8frc5dk1jj"))))
2971 (build-system asdf-build-system/sbcl)
2973 `(("iterate" ,sbcl-iterate)
2975 ("trivial-features" ,sbcl-trivial-features)
2979 ("gdk-pixbuf" ,gdk-pixbuf)
2983 (modify-phases %standard-phases
2984 (add-after 'unpack 'fix-paths
2985 (lambda* (#:key inputs #:allow-other-keys)
2986 (substitute* "glib/glib.init.lisp"
2987 (("libglib|libgthread" all)
2988 (string-append (assoc-ref inputs "glib") "/lib/" all)))
2989 (substitute* "gobject/gobject.init.lisp"
2991 (string-append (assoc-ref inputs "glib") "/lib/" all)))
2992 (substitute* "gio/gio.init.lisp"
2994 (string-append (assoc-ref inputs "glib") "/lib/" all)))
2995 (substitute* "cairo/cairo.init.lisp"
2997 (string-append (assoc-ref inputs "cairo") "/lib/" all)))
2998 (substitute* "pango/pango.init.lisp"
3000 (string-append (assoc-ref inputs "pango") "/lib/" all)))
3001 (substitute* "gdk-pixbuf/gdk-pixbuf.init.lisp"
3002 (("libgdk_pixbuf" all)
3003 (string-append (assoc-ref inputs "gdk-pixbuf") "/lib/" all)))
3004 (substitute* "gdk/gdk.init.lisp"
3006 (string-append (assoc-ref inputs "gtk") "/lib/" all)))
3007 (substitute* "gdk/gdk.package.lisp"
3009 (string-append (assoc-ref inputs "gtk") "/lib/" all))))))))
3010 (home-page "https://github.com/Ferada/cl-cffi-gtk/")
3011 (synopsis "Common Lisp binding for GTK+3")
3013 "@command{cl-cffi-gtk} is a Lisp binding to GTK+ 3 (GIMP Toolkit) which
3014 is a library for creating graphical user interfaces.")
3015 (license license:lgpl3))))
3017 (define-public sbcl-cl-cffi-gtk-glib
3019 (inherit sbcl-cl-cffi-gtk-boot0)
3020 (name "sbcl-cl-cffi-gtk-glib")
3022 `(("bordeaux-threads" ,sbcl-bordeaux-threads)
3023 ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
3025 (substitute-keyword-arguments (package-arguments sbcl-cl-cffi-gtk-boot0)
3026 ((#:asd-file _ "") "glib/cl-cffi-gtk-glib.asd")))))
3028 (define-public sbcl-cl-cffi-gtk-gobject
3030 (inherit sbcl-cl-cffi-gtk-boot0)
3031 (name "sbcl-cl-cffi-gtk-gobject")
3033 `(("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
3034 ("trivial-garbage" ,sbcl-trivial-garbage)
3035 ("bordeaux-threads" ,sbcl-bordeaux-threads)
3036 ("closer-mop" ,sbcl-closer-mop)
3037 ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
3039 (substitute-keyword-arguments (package-arguments sbcl-cl-cffi-gtk-boot0)
3040 ((#:asd-file _ "") "gobject/cl-cffi-gtk-gobject.asd")
3042 `(modify-phases ,phases
3043 (add-after 'install 'link-source
3044 ;; Since source is particularly heavy (16MiB+), let's reuse it
3045 ;; across the different components of cl-ffi-gtk.
3046 (lambda* (#:key inputs outputs #:allow-other-keys)
3047 (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
3048 "/share/common-lisp/sbcl-source/"
3049 "cl-cffi-gtk-glib"))
3050 (out-source (string-append (assoc-ref outputs "out")
3051 "/share/common-lisp/sbcl-source/"
3052 "cl-cffi-gtk-gobject")))
3053 (delete-file-recursively out-source)
3054 (symlink glib-source out-source)
3057 (define-public sbcl-cl-cffi-gtk-gio
3059 (inherit sbcl-cl-cffi-gtk-boot0)
3060 (name "sbcl-cl-cffi-gtk-gio")
3062 `(("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
3063 ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
3064 ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
3066 (substitute-keyword-arguments (package-arguments sbcl-cl-cffi-gtk-boot0)
3067 ((#:asd-file _ "") "gio/cl-cffi-gtk-gio.asd")
3069 `(modify-phases ,phases
3070 (add-after 'install 'link-source
3071 ;; Since source is particularly heavy (16MiB+), let's reuse it
3072 ;; across the different components of cl-ffi-gtk.
3073 (lambda* (#:key inputs outputs #:allow-other-keys)
3074 (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
3075 "/share/common-lisp/sbcl-source/"
3076 "cl-cffi-gtk-glib"))
3077 (out-source (string-append (assoc-ref outputs "out")
3078 "/share/common-lisp/sbcl-source/"
3079 "cl-cffi-gtk-gio")))
3080 (delete-file-recursively out-source)
3081 (symlink glib-source out-source)
3084 (define-public sbcl-cl-cffi-gtk-cairo
3086 (inherit sbcl-cl-cffi-gtk-boot0)
3087 (name "sbcl-cl-cffi-gtk-cairo")
3089 `(("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
3090 ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
3092 (substitute-keyword-arguments (package-arguments sbcl-cl-cffi-gtk-boot0)
3093 ((#:asd-file _ "") "cairo/cl-cffi-gtk-cairo.asd")
3095 `(modify-phases ,phases
3096 (add-after 'install 'link-source
3097 ;; Since source is particularly heavy (16MiB+), let's reuse it
3098 ;; across the different components of cl-ffi-gtk.
3099 (lambda* (#:key inputs outputs #:allow-other-keys)
3100 (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
3101 "/share/common-lisp/sbcl-source/"
3102 "cl-cffi-gtk-glib"))
3103 (out-source (string-append (assoc-ref outputs "out")
3104 "/share/common-lisp/sbcl-source/"
3105 "cl-cffi-gtk-cairo")))
3106 (delete-file-recursively out-source)
3107 (symlink glib-source out-source)
3110 (define-public sbcl-cl-cffi-gtk-pango
3112 (inherit sbcl-cl-cffi-gtk-boot0)
3113 (name "sbcl-cl-cffi-gtk-pango")
3115 `(("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
3116 ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
3117 ("cl-cffi-gtk-cairo" ,sbcl-cl-cffi-gtk-cairo)
3118 ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
3120 (substitute-keyword-arguments (package-arguments sbcl-cl-cffi-gtk-boot0)
3121 ((#:asd-file _ "") "pango/cl-cffi-gtk-pango.asd")
3123 `(modify-phases ,phases
3124 (add-after 'install 'link-source
3125 ;; Since source is particularly heavy (16MiB+), let's reuse it
3126 ;; across the different components of cl-ffi-gtk.
3127 (lambda* (#:key inputs outputs #:allow-other-keys)
3128 (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
3129 "/share/common-lisp/sbcl-source/"
3130 "cl-cffi-gtk-glib"))
3131 (out-source (string-append (assoc-ref outputs "out")
3132 "/share/common-lisp/sbcl-source/"
3133 "cl-cffi-gtk-pango")))
3134 (delete-file-recursively out-source)
3135 (symlink glib-source out-source)
3138 (define-public sbcl-cl-cffi-gtk-gdk-pixbuf
3140 (inherit sbcl-cl-cffi-gtk-boot0)
3141 (name "sbcl-cl-cffi-gtk-gdk-pixbuf")
3143 `(("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
3144 ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
3145 ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
3147 (substitute-keyword-arguments (package-arguments sbcl-cl-cffi-gtk-boot0)
3148 ((#:asd-file _ "") "gdk-pixbuf/cl-cffi-gtk-gdk-pixbuf.asd")
3150 `(modify-phases ,phases
3151 (add-after 'install 'link-source
3152 ;; Since source is particularly heavy (16MiB+), let's reuse it
3153 ;; across the different components of cl-ffi-gtk.
3154 (lambda* (#:key inputs outputs #:allow-other-keys)
3155 (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
3156 "/share/common-lisp/sbcl-source/"
3157 "cl-cffi-gtk-glib"))
3158 (out-source (string-append (assoc-ref outputs "out")
3159 "/share/common-lisp/sbcl-source/"
3160 "cl-cffi-gtk-gdk-pixbuf")))
3161 (delete-file-recursively out-source)
3162 (symlink glib-source out-source)
3165 (define-public sbcl-cl-cffi-gtk-gdk
3167 (inherit sbcl-cl-cffi-gtk-boot0)
3168 (name "sbcl-cl-cffi-gtk-gdk")
3170 `(("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
3171 ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
3172 ("cl-cffi-gtk-gio" ,sbcl-cl-cffi-gtk-gio)
3173 ("cl-cffi-gtk-gdk-pixbuf" ,sbcl-cl-cffi-gtk-gdk-pixbuf)
3174 ("cl-cffi-gtk-cairo" ,sbcl-cl-cffi-gtk-cairo)
3175 ("cl-cffi-gtk-pango" ,sbcl-cl-cffi-gtk-pango)
3176 ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
3178 (substitute-keyword-arguments (package-arguments sbcl-cl-cffi-gtk-boot0)
3179 ((#:asd-file _ "") "gdk/cl-cffi-gtk-gdk.asd")
3181 `(modify-phases ,phases
3182 (add-after 'install 'link-source
3183 ;; Since source is particularly heavy (16MiB+), let's reuse it
3184 ;; across the different components of cl-ffi-gtk.
3185 (lambda* (#:key inputs outputs #:allow-other-keys)
3186 (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
3187 "/share/common-lisp/sbcl-source/"
3188 "cl-cffi-gtk-glib"))
3189 (out-source (string-append (assoc-ref outputs "out")
3190 "/share/common-lisp/sbcl-source/"
3191 "cl-cffi-gtk-gdk")))
3192 (delete-file-recursively out-source)
3193 (symlink glib-source out-source)
3196 (define-public sbcl-cl-cffi-gtk
3198 (inherit sbcl-cl-cffi-gtk-boot0)
3199 (name "sbcl-cl-cffi-gtk")
3201 `(("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
3202 ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
3203 ("cl-cffi-gtk-gio" ,sbcl-cl-cffi-gtk-gio)
3204 ("cl-cffi-gtk-gdk" ,sbcl-cl-cffi-gtk-gdk)
3205 ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
3207 `(("fiveam" ,sbcl-fiveam)))
3209 (substitute-keyword-arguments (package-arguments sbcl-cl-cffi-gtk-boot0)
3210 ((#:asd-file _ "") "gtk/cl-cffi-gtk.asd")
3211 ((#:test-asd-file _ "") "test/cl-cffi-gtk-test.asd")
3212 ;; TODO: Tests fail with memory fault.
3213 ;; See https://github.com/Ferada/cl-cffi-gtk/issues/24.
3214 ((#:tests? _ #f) #f)
3216 `(modify-phases ,phases
3217 (add-after 'install 'link-source
3218 ;; Since source is particularly heavy (16MiB+), let's reuse it
3219 ;; across the different components of cl-ffi-gtk.
3220 (lambda* (#:key inputs outputs #:allow-other-keys)
3221 (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
3222 "/share/common-lisp/sbcl-source/"
3223 "cl-cffi-gtk-glib"))
3224 (out-source (string-append (assoc-ref outputs "out")
3225 "/share/common-lisp/sbcl-source/"
3227 (delete-file-recursively out-source)
3228 (symlink glib-source out-source)
3231 (define-public cl-cffi-gtk
3232 (sbcl-package->cl-source-package sbcl-cl-cffi-gtk))
3234 (define-public sbcl-cl-webkit
3235 (let ((commit "aecd76a2bcc7bfee049c91d94cc75f893800bf37"))
3237 (name "sbcl-cl-webkit")
3238 (version (git-version "2.4" "9" commit))
3243 (url "https://github.com/joachifm/cl-webkit")
3245 (file-name (git-file-name "cl-webkit" version))
3248 "1j2wvn19kz0bcg17qr9pc4xp6fgjy8zngdnnp5rpfxd25sli62yc"))))
3249 (build-system asdf-build-system/sbcl)
3251 `(("cffi" ,sbcl-cffi)
3252 ("cl-cffi-gtk" ,sbcl-cl-cffi-gtk)
3253 ("webkitgtk" ,webkitgtk)))
3255 `(#:asd-file "webkit2/cl-webkit2.asd"
3256 #:asd-system-name "cl-webkit2"
3258 (modify-phases %standard-phases
3259 (add-after 'unpack 'fix-paths
3260 (lambda* (#:key inputs #:allow-other-keys)
3261 (substitute* "webkit2/webkit2.init.lisp"
3262 (("libwebkit2gtk" all)
3264 (assoc-ref inputs "webkitgtk") "/lib/" all))))))))
3265 (home-page "https://github.com/joachifm/cl-webkit")
3266 (synopsis "Binding to WebKitGTK+ for Common Lisp")
3268 "@command{cl-webkit} is a binding to WebKitGTK+ for Common Lisp,
3269 currently targeting WebKit version 2. The WebKitGTK+ library adds web
3270 browsing capabilities to an application, leveraging the full power of the
3271 WebKit browsing engine.")
3272 (license license:expat))))
3274 (define-public cl-webkit
3275 (sbcl-package->cl-source-package sbcl-cl-webkit))
3277 (define-public sbcl-lparallel
3279 (name "sbcl-lparallel")
3285 (url "https://github.com/lmj/lparallel/")
3286 (commit (string-append "lparallel-" version))))
3287 (file-name (git-file-name "lparallel" version))
3290 "0g0aylrbbrqsz0ahmwhvnk4cmc2931fllbpcfgzsprwnqqd7vwq9"))))
3291 (build-system asdf-build-system/sbcl)
3293 `(("alexandria" ,sbcl-alexandria)
3294 ("bordeaux-threads" ,sbcl-bordeaux-threads)
3295 ("trivial-garbage" ,sbcl-trivial-garbage)))
3298 (modify-phases %standard-phases
3299 (add-after 'unpack 'fix-dependency
3300 ;; lparallel loads a SBCL specific system in its asd file. This is
3301 ;; not carried over into the fasl which is generated. In order for
3302 ;; it to be carried over, it needs to be listed as a dependency.
3304 (substitute* "lparallel.asd"
3305 ((":depends-on \\(:alexandria" all)
3306 (string-append all " #+sbcl :sb-cltl2"))))))))
3307 (home-page "https://lparallel.org/")
3308 (synopsis "Parallelism for Common Lisp")
3310 "@command{lparallel} is a library for parallel programming in Common
3314 @item a simple model of task submission with receiving queue,
3315 @item constructs for expressing fine-grained parallelism,
3316 @item asynchronous condition handling across thread boundaries,
3317 @item parallel versions of map, reduce, sort, remove, and many others,
3318 @item promises, futures, and delayed evaluation constructs,
3319 @item computation trees for parallelizing interconnected tasks,
3320 @item bounded and unbounded FIFO queues,
3321 @item high and low priority tasks,
3322 @item task killing by category,
3323 @item integrated timeouts.
3325 (license license:expat)))
3327 (define-public cl-lparallel
3328 (sbcl-package->cl-source-package sbcl-lparallel))
3330 (define-public ecl-lparallel
3331 (sbcl-package->ecl-package sbcl-lparallel))
3333 (define-public sbcl-cl-markup
3334 (let ((commit "e0eb7debf4bdff98d1f49d0f811321a6a637b390"))
3336 (name "sbcl-cl-markup")
3337 (version (git-version "0.1" "1" commit))
3342 (url "https://github.com/arielnetworks/cl-markup/")
3344 (file-name (git-file-name "cl-markup" version))
3347 "10l6k45971dl13fkdmva7zc6i453lmq9j4xax2ci6pjzlc6xjhp7"))))
3348 (build-system asdf-build-system/sbcl)
3349 (home-page "https://github.com/arielnetworks/cl-markup/")
3350 (synopsis "Markup generation library for Common Lisp")
3352 "A modern markup generation library for Common Lisp that features:
3355 @item Fast (even faster through compiling the code)
3357 @item Support for multiple document types (markup, xml, html, html5, xhtml)
3358 @item Output with doctype
3359 @item Direct output to stream
3361 (license license:lgpl3+))))
3363 (define-public cl-markup
3364 (sbcl-package->cl-source-package sbcl-cl-markup))
3366 (define-public ecl-cl-markup
3367 (sbcl-package->ecl-package sbcl-cl-markup))
3369 (define-public sbcl-cl-css
3370 (let ((commit "8fe654c8f0cf95b300718101cce4feb517f78e2f"))
3372 (name "sbcl-cl-css")
3373 (version (git-version "0.1" "1" commit))
3378 (url "https://github.com/inaimathi/cl-css/")
3380 (file-name (git-file-name "cl-css" version))
3383 "1lc42zi2sw11fl2589sc19nr5sd2p0wy7wgvgwaggxa5f3ajhsmd"))))
3384 (build-system asdf-build-system/sbcl)
3385 (home-page "https://github.com/inaimathi/cl-css/")
3386 (synopsis "Non-validating, inline CSS generator for Common Lisp")
3388 "This is a dead-simple, non validating, inline CSS generator for Common
3389 Lisp. Its goals are axiomatic syntax, simple implementation to support
3390 portability, and boilerplate reduction in CSS.")
3391 (license license:expat))))
3393 (define-public cl-css
3394 (sbcl-package->cl-source-package sbcl-cl-css))
3396 (define-public ecl-cl-css
3397 (sbcl-package->ecl-package sbcl-cl-css))
3399 (define-public sbcl-portable-threads
3400 (let ((commit "c0e61a1faeb0583c80fd3f20b16cc4c555226920"))
3402 (name "sbcl-portable-threads")
3403 (version (git-version "2.3" "1" commit))
3408 (url "https://github.com/binghe/portable-threads/")
3410 (file-name (git-file-name "portable-threads" version))
3413 "03fmxyarc0xf4kavwkfa0a2spkyfrz6hbgbi9y4q7ny5aykdyfaq"))))
3414 (build-system asdf-build-system/sbcl)
3416 `(;; Tests seem broken.
3418 (home-page "https://github.com/binghe/portable-threads")
3419 (synopsis "Portable threads (and scheduled and periodic functions) API for Common Lisp")
3421 "Portable Threads (and Scheduled and Periodic Functions) API for Common
3422 Lisp (from GBBopen project).")
3423 (license license:asl2.0))))
3425 (define-public cl-portable-threads
3426 (sbcl-package->cl-source-package sbcl-portable-threads))
3428 (define-public ecl-portable-threada
3429 (sbcl-package->ecl-package sbcl-portable-threads))
3431 (define sbcl-usocket-boot0
3432 ;; usocket's test rely on usocket-server which depends on usocket itself.
3433 ;; We break this cyclic dependency with -boot0 that packages usocket.
3435 (name "sbcl-usocket-boot0")
3441 (url "https://github.com/usocket/usocket/")
3442 (commit (string-append "v" version))))
3443 (file-name (git-file-name "usocket" version))
3446 "0x746wr2324l6bn7skqzgkzcbj5kd0zp2ck0c8rldrw0rzabg826"))))
3447 (build-system asdf-build-system/sbcl)
3449 `(("split-sequence" ,sbcl-split-sequence)))
3452 #:asd-system-name "usocket"))
3453 (home-page "https://common-lisp.net/project/usocket/")
3454 (synopsis "Universal socket library for Common Lisp (server side)")
3456 "This library strives to provide a portable TCP/IP and UDP/IP socket
3457 interface for as many Common Lisp implementations as possible, while keeping
3458 the abstraction and portability layer as thin as possible.")
3459 (license license:expat)))
3461 (define-public sbcl-usocket-server
3463 (inherit sbcl-usocket-boot0)
3464 (name "sbcl-usocket-server")
3466 `(("bordeaux-threads" ,sbcl-bordeaux-threads)
3467 ("usocket" ,sbcl-usocket-boot0)))
3469 '(#:asd-system-name "usocket-server"))
3470 (synopsis "Universal socket library for Common Lisp (server side)")))
3472 (define-public cl-usocket-server
3473 (sbcl-package->cl-source-package sbcl-usocket-server))
3475 (define-public ecl-socket-server
3476 (sbcl-package->ecl-package sbcl-usocket-server))
3478 (define-public sbcl-usocket
3480 (inherit sbcl-usocket-boot0)
3481 (name "sbcl-usocket")
3483 ;; FIXME: Tests need network access?
3487 `(("usocket-server" ,sbcl-usocket-server)
3490 (define-public cl-usocket
3491 (sbcl-package->cl-source-package sbcl-usocket))
3493 (define-public ecl-usocket
3494 (sbcl-package->ecl-package sbcl-usocket))
3496 (define-public sbcl-s-xml
3503 (uri "https://common-lisp.net/project/s-xml/s-xml.tgz")
3506 "061qcr0dzshsa38s5ma4ay924cwak2nq9gy59dw6v9p0qb58nzjf"))))
3507 (build-system asdf-build-system/sbcl)
3508 (home-page "https://common-lisp.net/project/s-xml/")
3509 (synopsis "Simple XML parser implemented in Common Lisp")
3511 "S-XML is a simple XML parser implemented in Common Lisp. This XML
3512 parser implementation has the following features:
3515 @item It works (handling many common XML usages).
3516 @item It is very small (the core is about 700 lines of code, including
3517 comments and whitespace).
3518 @item It has a core API that is simple, efficient and pure functional, much
3519 like that from SSAX (see also http://ssax.sourceforge.net).
3520 @item It supports different DOM models: an XSML-based one, an LXML-based one
3521 and a classic xml-element struct based one.
3522 @item It is reasonably time and space efficient (internally avoiding garbage
3523 generatation as much as possible).
3524 @item It does support CDATA.
3525 @item It should support the same character sets as your Common Lisp
3527 @item It does support XML name spaces.
3530 This XML parser implementation has the following limitations:
3533 @item It does not support any special tags (like processing instructions).
3534 @item It is not validating, even skips DTD's all together.
3536 (license license:lgpl3+)))
3538 (define-public cl-s-xml
3539 (sbcl-package->cl-source-package sbcl-s-xml))
3541 (define-public ecl-s-xml
3542 (sbcl-package->ecl-package sbcl-s-xml))
3544 (define-public sbcl-s-xml-rpc
3546 (name "sbcl-s-xml-rpc")
3551 (uri "https://common-lisp.net/project/s-xml-rpc/s-xml-rpc.tgz")
3554 "02z7k163d51v0pzk8mn1xb6h5s6x64gjqkslhwm3a5x26k2gfs11"))))
3555 (build-system asdf-build-system/sbcl)
3557 `(("s-xml" ,sbcl-s-xml)))
3558 (home-page "https://common-lisp.net/project/s-xml-rpc/")
3559 (synopsis "Implementation of XML-RPC in Common Lisp for both client and server")
3561 "S-XML-RPC is an implementation of XML-RPC in Common Lisp for both
3562 client and server.")
3563 (license license:lgpl3+)))
3565 (define-public cl-s-xml-rpc
3566 (sbcl-package->cl-source-package sbcl-s-xml-rpc))
3568 (define-public ecl-s-xml-rpc
3569 (sbcl-package->ecl-package sbcl-s-xml-rpc))
3571 (define-public sbcl-trivial-clipboard
3572 (let ((commit "afcd3743b842f5a81fc86dba60f9db59970f49c5"))
3574 (name "sbcl-trivial-clipboard")
3575 (version (git-version "0.0.0.0" "3" commit))
3580 (url "https://github.com/snmsts/trivial-clipboard")
3582 (file-name (git-file-name "trivial-clipboard" version))
3585 "1qfbvkzmvkbqpc5s3sx31c5653sy6qlcixafgzd10qpykb843prr"))))
3586 (build-system asdf-build-system/sbcl)
3588 `(("xclip" ,xclip)))
3590 `(("fiveam" ,sbcl-fiveam)))
3593 (modify-phases %standard-phases
3594 (add-after 'unpack 'fix-paths
3595 (lambda* (#:key inputs #:allow-other-keys)
3596 (substitute* "src/text.lisp"
3597 (("\\(executable-find \"xclip\"\\)")
3598 (string-append "(executable-find \""
3599 (assoc-ref inputs "xclip")
3600 "/bin/xclip\")"))))))))
3601 (home-page "https://github.com/snmsts/trivial-clipboard")
3602 (synopsis "Access system clipboard in Common Lisp")
3604 "@command{trivial-clipboard} gives access to the system clipboard.")
3605 (license license:expat))))
3607 (define-public cl-trivial-clipboard
3608 (sbcl-package->cl-source-package sbcl-trivial-clipboard))
3610 (define-public ecl-trivial-clipboard
3611 (sbcl-package->ecl-package sbcl-trivial-clipboard))
3613 (define-public sbcl-trivial-backtrace
3614 (let ((commit "ca81c011b86424a381a7563cea3b924f24e6fbeb")
3617 (name "sbcl-trivial-backtrace")
3618 (version (git-version "0.0.0" revision commit))
3623 (url "https://github.com/gwkkwg/trivial-backtrace")
3625 (file-name (git-file-name "trivial-backtrace" version))
3627 (base32 "10p41p43skj6cimdg8skjy7372s8v2xpkg8djjy0l8rm45i654k1"))))
3628 (build-system asdf-build-system/sbcl)
3630 `(("sbcl-lift" ,sbcl-lift)))
3633 (modify-phases %standard-phases
3634 (add-after 'check 'delete-test-results
3635 (lambda* (#:key outputs #:allow-other-keys)
3636 (let ((test-results (string-append (assoc-ref outputs "out")
3637 "/share/common-lisp/"
3638 (%lisp-type) "-source"
3639 "/trivial-backtrace"
3641 (when (file-exists? test-results)
3642 (delete-file-recursively test-results)))
3644 (home-page "https://common-lisp.net/project/trivial-backtrace/")
3645 (synopsis "Portable simple API to work with backtraces in Common Lisp")
3647 "One of the many things that didn't quite get into the Common Lisp
3648 standard was how to get a Lisp to output its call stack when something has
3649 gone wrong. As such, each Lisp has developed its own notion of what to
3650 display, how to display it, and what sort of arguments can be used to
3651 customize it. @code{trivial-backtrace} is a simple solution to generating a
3652 backtrace portably.")
3653 (license license:expat))))
3655 (define-public cl-trivial-backtrace
3656 (sbcl-package->cl-source-package sbcl-trivial-backtrace))
3658 (define-public sbcl-rfc2388
3659 (let ((commit "591bcf7e77f2c222c43953a80f8c297751dc0c4e")
3662 (name "sbcl-rfc2388")
3663 (version (git-version "0.0.0" revision commit))
3668 (url "https://github.com/jdz/rfc2388")
3670 (file-name (git-file-name "rfc2388" version))
3672 (base32 "0phh5n3clhl9ji8jaxrajidn22d3f0aq87mlbfkkxlnx2pnw694k"))))
3673 (build-system asdf-build-system/sbcl)
3674 (home-page "https://github.com/jdz/rfc2388/")
3675 (synopsis "An implementation of RFC 2388 in Common Lisp")
3677 "This package contains an implementation of RFC 2388, which is used to
3678 process form data posted with HTTP POST method using enctype
3679 \"multipart/form-data\".")
3680 (license license:bsd-2))))
3682 (define-public cl-rfc2388
3683 (sbcl-package->cl-source-package sbcl-rfc2388))
3685 (define-public sbcl-md5
3693 (url "https://github.com/pmai/md5")
3694 (commit (string-append "release-" version))))
3695 (file-name (git-file-name "md5" version))
3697 (base32 "1waqxzm7vlc22n92hv8r27anlvvjkkh9slhrky1ww7mdx4mmxwb8"))))
3698 (build-system asdf-build-system/sbcl)
3699 (home-page "https://github.com/pmai/md5")
3701 "Common Lisp implementation of the MD5 Message-Digest Algorithm (RFC 1321)")
3703 "This package implements The MD5 Message-Digest Algorithm, as defined in
3704 RFC 1321 by R. Rivest, published April 1992.")
3705 (license license:public-domain)))
3707 (define-public cl-md5
3708 (sbcl-package->cl-source-package sbcl-md5))
3710 (define-public ecl-md5
3712 (inherit (sbcl-package->ecl-package sbcl-md5))
3714 `(("flexi-streams" ,ecl-flexi-streams)))))
3716 (define-public sbcl-cl+ssl
3717 (let ((commit "701e645081e6533a3f0f0b3ac86389d6f506c4b5")
3720 (name "sbcl-cl+ssl")
3721 (version (git-version "0.0.0" revision commit))
3726 (url "https://github.com/cl-plus-ssl/cl-plus-ssl")
3728 (file-name (git-file-name "cl+ssl" version))
3730 (base32 "0nfl275nwhff3m25872y388cydz14kqb6zbwywa6nj85r9k8bgs0"))))
3731 (build-system asdf-build-system/sbcl)
3734 (modify-phases %standard-phases
3735 (add-after 'unpack 'fix-paths
3736 (lambda* (#:key inputs #:allow-other-keys)
3737 (substitute* "src/reload.lisp"
3740 (assoc-ref inputs "openssl") "/lib/" all))))))))
3742 `(("openssl" ,openssl)
3743 ("sbcl-cffi" ,sbcl-cffi)
3744 ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)
3745 ("sbcl-flexi-streams" ,sbcl-flexi-streams)
3746 ("sbcl-bordeaux-threads" ,sbcl-bordeaux-threads)
3747 ("sbcl-trivial-garbage" ,sbcl-trivial-garbage)
3748 ("sbcl-alexandria" ,sbcl-alexandria)
3749 ("sbcl-trivial-features" ,sbcl-trivial-features)))
3750 (home-page "https://common-lisp.net/project/cl-plus-ssl/")
3751 (synopsis "Common Lisp bindings to OpenSSL")
3753 "This library is a fork of SSL-CMUCL. The original SSL-CMUCL source
3754 code was written by Eric Marsden and includes contributions by Jochen Schmidt.
3755 Development into CL+SSL was done by David Lichteblau.")
3756 (license license:expat))))
3758 (define-public cl-cl+ssl
3759 (sbcl-package->cl-source-package sbcl-cl+ssl))
3761 (define-public sbcl-kmrcl
3762 (let ((version "1.111")
3763 (commit "4a27407aad9deb607ffb8847630cde3d041ea25a")
3767 (version (git-version version revision commit))
3772 (url "http://git.kpe.io/kmrcl.git/")
3774 (file-name (git-file-name name version))
3776 (base32 "06gx04mah5nc8w78s0j8628divbf1s5w7af8w7pvzb2d5mgvrbd2"))))
3777 (build-system asdf-build-system/sbcl)
3779 `(("sbcl-rt" ,sbcl-rt)))
3780 (home-page "http://files.kpe.io/kmrcl/")
3781 (synopsis "General utilities for Common Lisp programs")
3783 "KMRCL is a collection of utilities used by a number of Kevin
3784 Rosenberg's Common Lisp packages.")
3785 (license license:llgpl))))
3787 (define-public cl-kmrcl
3788 (sbcl-package->cl-source-package sbcl-kmrcl))
3790 (define-public sbcl-cl-base64
3791 ;; 3.3.4 tests are broken, upstream fixes them.
3792 (let ((commit "577683b18fd880b82274d99fc96a18a710e3987a"))
3794 (name "sbcl-cl-base64")
3795 (version (git-version "3.3.4" "1" commit))
3800 (url "http://git.kpe.io/cl-base64.git/")
3802 (file-name (git-file-name name version))
3804 (base32 "12jj54h0fs6n237cvnp8v6hn0imfksammq22ys6pi0gwz2w47rbj"))))
3805 (build-system asdf-build-system/sbcl)
3806 (native-inputs ; For tests.
3807 `(("sbcl-ptester" ,sbcl-ptester)
3808 ("sbcl-kmrcl" ,sbcl-kmrcl)))
3809 (home-page "http://files.kpe.io/cl-base64/")
3811 "Common Lisp package to encode and decode base64 with URI support")
3813 "This package provides highly optimized base64 encoding and decoding.
3814 Besides conversion to and from strings, integer conversions are supported.
3815 Encoding with Uniform Resource Identifiers is supported by using a modified
3816 encoding table that uses only URI-compatible characters.")
3817 (license license:bsd-3))))
3819 (define-public cl-base64
3820 (sbcl-package->cl-source-package sbcl-cl-base64))
3822 (define-public sbcl-chunga
3824 (name "sbcl-chunga")
3830 (url "https://github.com/edicl/chunga")
3831 (commit (string-append "v" version))))
3832 (file-name (git-file-name name version))
3834 (base32 "0jzn3nyb3f22gm983rfk99smqs3mhb9ivjmasvhq9qla5cl9pyhd"))))
3835 (build-system asdf-build-system/sbcl)
3837 `(("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)))
3838 (home-page "https://edicl.github.io/chunga/")
3839 (synopsis "Portable chunked streams for Common Lisp")
3841 "Chunga implements streams capable of chunked encoding on demand as
3842 defined in RFC 2616.")
3843 (license license:bsd-2)))
3845 (define-public cl-chunga
3846 (sbcl-package->cl-source-package sbcl-chunga))
3848 (define-public sbcl-cl-who
3849 (let ((version "1.1.4")
3850 (commit "2c08caa4bafba720409af9171feeba3f32e86d32")
3853 (name "sbcl-cl-who")
3854 (version (git-version version revision commit))
3859 (url "https://github.com/edicl/cl-who")
3861 (file-name (git-file-name name version))
3864 "0yjb6sr3yazm288m318kqvj9xk8rm9n1lpimgf65ymqv0i5agxsb"))))
3865 (build-system asdf-build-system/sbcl)
3867 `(("sbcl-flexi-streams" ,sbcl-flexi-streams)))
3868 (home-page "https://edicl.github.io/cl-who/")
3869 (synopsis "Yet another Lisp markup language")
3871 "There are plenty of Lisp Markup Languages out there - every Lisp
3872 programmer seems to write at least one during his career - and CL-WHO (where
3873 WHO means \"with-html-output\" for want of a better acronym) is probably just
3874 as good or bad as the next one.")
3875 (license license:bsd-2))))
3877 (define-public cl-cl-who
3878 (sbcl-package->cl-source-package sbcl-cl-who))
3880 (define-public sbcl-chipz
3881 (let ((version "0.8")
3882 (commit "75dfbc660a5a28161c57f115adf74c8a926bfc4d")
3886 (version (git-version version revision commit))
3891 (url "https://github.com/froydnj/chipz")
3893 (file-name (git-file-name name version))
3896 "0plx4rs39zbs4gjk77h4a2q11zpy75fh9v8hnxrvsf8fnakajhwg"))))
3897 (build-system asdf-build-system/sbcl)
3899 `(("sbcl-flexi-streams" ,sbcl-flexi-streams)))
3900 (home-page "http://method-combination.net/lisp/chipz/")
3902 "Common Lisp library for decompressing deflate, zlib, gzip, and bzip2
3905 "DEFLATE data, defined in RFC1951, forms the core of popular
3906 compression formats such as zlib (RFC 1950) and gzip (RFC 1952). As such,
3907 Chipz also provides for decompressing data in those formats as well. BZIP2 is
3908 the format used by the popular compression tool bzip2.")
3909 ;; The author describes it as "MIT-like"
3910 (license license:expat))))
3912 (define-public cl-chipz
3913 (sbcl-package->cl-source-package sbcl-chipz))
3915 (define-public sbcl-drakma
3917 (name "sbcl-drakma")
3923 (url "https://github.com/edicl/drakma")
3924 (commit (string-append "v" version))))
3925 (file-name (git-file-name name version))
3928 "1441idnyif9xzx3ln1p3fg36k2v9h4wasjqrzc8y52j61420qpci"))))
3929 (build-system asdf-build-system/sbcl)
3931 `(("sbcl-puri" ,sbcl-puri)
3932 ("sbcl-cl-base64" ,sbcl-cl-base64)
3933 ("sbcl-chunga" ,sbcl-chunga)
3934 ("sbcl-flexi-streams" ,sbcl-flexi-streams)
3935 ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
3936 ("sbcl-chipz" ,sbcl-chipz)
3937 ("sbcl-usocket" ,sbcl-usocket)
3938 ("sbcl-cl+ssl" ,sbcl-cl+ssl)))
3940 `(("sbcl-fiveam" ,sbcl-fiveam)))
3941 (home-page "https://edicl.github.io/drakma/")
3942 (synopsis "HTTP client written in Common Lisp")
3944 "Drakma is a full-featured HTTP client implemented in Common Lisp. It
3945 knows how to handle HTTP/1.1 chunking, persistent connections, re-usable
3946 sockets, SSL, continuable uploads, file uploads, cookies, and more.")
3947 (license license:bsd-2)))
3949 (define-public cl-drakma
3950 (sbcl-package->cl-source-package sbcl-drakma))
3952 (define-public ecl-drakma
3953 (sbcl-package->ecl-package sbcl-drakma))
3955 (define-public sbcl-hunchentoot
3957 (name "sbcl-hunchentoot")
3963 (url "https://github.com/edicl/hunchentoot")
3964 (commit (string-append "v" version))))
3965 (file-name (git-file-name "hunchentoot" version))
3967 (base32 "1anpcad7w045m4rsjs1f3xdhjwx5cppq1h0vlb3q7dz81fi3i6yq"))))
3968 (build-system asdf-build-system/sbcl)
3970 `(("sbcl-cl-who" ,sbcl-cl-who)
3971 ("sbcl-drakma" ,sbcl-drakma)))
3973 `(("sbcl-chunga" ,sbcl-chunga)
3974 ("sbcl-cl-base64" ,sbcl-cl-base64)
3975 ("sbcl-cl-fad" ,sbcl-cl-fad)
3976 ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
3977 ("sbcl-flexi-streams" ,sbcl-flexi-streams)
3978 ("sbcl-cl+ssl" ,sbcl-cl+ssl)
3979 ("sbcl-md5" ,sbcl-md5)
3980 ("sbcl-rfc2388" ,sbcl-rfc2388)
3981 ("sbcl-trivial-backtrace" ,sbcl-trivial-backtrace)
3982 ("sbcl-usocket" ,sbcl-usocket)))
3983 (home-page "https://edicl.github.io/hunchentoot/")
3984 (synopsis "Web server written in Common Lisp")
3986 "Hunchentoot is a web server written in Common Lisp and at the same
3987 time a toolkit for building dynamic websites. As a stand-alone web server,
3988 Hunchentoot is capable of HTTP/1.1 chunking (both directions), persistent
3989 connections (keep-alive), and SSL.")
3990 (license license:bsd-2)))
3992 (define-public cl-hunchentoot
3993 (sbcl-package->cl-source-package sbcl-hunchentoot))
3995 (define-public sbcl-trivial-types
3997 (name "sbcl-trivial-types")
4003 (url "https://github.com/m2ym/trivial-types")
4004 (commit "ee869f2b7504d8aa9a74403641a5b42b16f47d88")))
4005 (file-name (git-file-name name version))
4007 (base32 "1s4cp9bdlbn8447q7w7f1wkgwrbvfzp20mgs307l5pxvdslin341"))))
4008 (build-system asdf-build-system/sbcl)
4009 (home-page "https://github.com/m2ym/trivial-types")
4010 (synopsis "Trivial type definitions for Common Lisp")
4012 "TRIVIAL-TYPES provides missing but important type definitions such as
4013 PROPER-LIST, ASSOCIATION-LIST, PROPERTY-LIST and TUPLE.")
4014 (license license:llgpl)))
4016 (define-public cl-trivial-types
4017 (sbcl-package->cl-source-package sbcl-trivial-types))
4019 (define-public sbcl-cl-syntax
4021 (name "sbcl-cl-syntax")
4027 (url "https://github.com/m2ym/cl-syntax")
4028 (commit "03f0c329bbd55b8622c37161e6278366525e2ccc")))
4029 (file-name (git-file-name "cl-syntax" version))
4031 (base32 "17ran8xp77asagl31xv8w819wafh6whwfc9p6dgx22ca537gyl4y"))))
4032 (build-system asdf-build-system/sbcl)
4034 '(#:asd-file "cl-syntax.asd"
4035 #:asd-system-name "cl-syntax"))
4036 (inputs `(("sbcl-trivial-types" ,sbcl-trivial-types)
4037 ("sbcl-named-readtables" ,sbcl-named-readtables)))
4038 (home-page "https://github.com/m2ym/cl-syntax")
4039 (synopsis "Reader Syntax Coventions for Common Lisp and SLIME")
4041 "CL-SYNTAX provides Reader Syntax Coventions for Common Lisp and SLIME.")
4042 (license license:llgpl)))
4044 (define-public cl-syntax
4045 (sbcl-package->cl-source-package sbcl-cl-syntax))
4047 (define-public sbcl-cl-annot
4048 (let ((commit "c99e69c15d935eabc671b483349a406e0da9518d")
4051 (name "sbcl-cl-annot")
4052 (version (git-version "0.0.0" revision commit))
4057 (url "https://github.com/m2ym/cl-annot")
4059 (file-name (git-file-name name version))
4061 (base32 "1wq1gs9jjd5m6iwrv06c2d7i5dvqsfjcljgbspfbc93cg5xahk4n"))))
4062 (build-system asdf-build-system/sbcl)
4064 '(#:asd-file "cl-annot.asd"
4065 #:asd-system-name "cl-annot"))
4067 `(("sbcl-alexandria" ,sbcl-alexandria)))
4068 (home-page "https://github.com/m2ym/cl-annot")
4069 (synopsis "Python-like Annotation Syntax for Common Lisp.")
4071 "@code{cl-annot} is an general annotation library for Common Lisp.")
4072 (license license:llgpl))))
4074 (define-public cl-annot
4075 (sbcl-package->cl-source-package sbcl-cl-annot))
4077 (define-public sbcl-cl-syntax-annot
4079 (inherit sbcl-cl-syntax)
4080 (name "sbcl-cl-syntax-annot")
4082 '(#:asd-file "cl-syntax-annot.asd"
4083 #:asd-system-name "cl-syntax-annot"))
4085 `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
4086 ("sbcl-cl-annot" ,sbcl-cl-annot)))
4087 (synopsis "Common Lisp reader Syntax for cl-annot")
4089 "CL-SYNTAX provides reader syntax coventions for Common Lisp and
4090 @code{cl-annot}.")))
4092 (define-public cl-syntax-annot
4093 (sbcl-package->cl-source-package sbcl-cl-syntax-annot))
4095 (define-public sbcl-cl-syntax-interpol
4097 (inherit sbcl-cl-syntax)
4098 (name "sbcl-cl-syntax-interpol")
4100 '(#:asd-file "cl-syntax-interpol.asd"
4101 #:asd-system-name "cl-syntax-interpol"))
4103 `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
4104 ("sbcl-cl-interpol" ,sbcl-cl-interpol)))
4105 (synopsis "Common Lisp reader Syntax for cl-interpol")
4107 "CL-SYNTAX provides reader syntax coventions for Common Lisp and
4108 @code{cl-interpol}.")))
4110 (define-public cl-syntax-interpol
4111 (sbcl-package->cl-source-package sbcl-cl-syntax-interpol))
4113 (define-public sbcl-cl-utilities
4114 (let ((commit "dce2d2f6387091ea90357a130fa6d13a6776884b")
4117 (name "sbcl-cl-utilities")
4118 (version (git-version "0.0.0" revision commit))
4124 "https://gitlab.common-lisp.net/cl-utilities/cl-utilities/-/"
4125 "archive/" commit "/cl-utilities-" commit ".tar.gz"))
4127 (base32 "1r46v730yf96nk2vb24qmagv9x96xvd08abqwhf02ghgydv1a7z2"))))
4128 (build-system asdf-build-system/sbcl)
4130 '(#:asd-file "cl-utilities.asd"
4131 #:asd-system-name "cl-utilities"
4133 (modify-phases %standard-phases
4134 (add-after 'unpack 'fix-paths
4135 (lambda* (#:key inputs #:allow-other-keys)
4136 (substitute* "rotate-byte.lisp"
4137 (("in-package :cl-utilities)" all)
4138 "in-package :cl-utilities)\n\n#+sbcl\n(require :sb-rotate-byte)")))))))
4139 (home-page "http://common-lisp.net/project/cl-utilities")
4140 (synopsis "A collection of semi-standard utilities")
4142 "On Cliki.net <http://www.cliki.net/Common%20Lisp%20Utilities>, there
4143 is a collection of Common Lisp Utilities, things that everybody writes since
4144 they're not part of the official standard. There are some very useful things
4145 there; the only problems are that they aren't implemented as well as you'd
4146 like (some aren't implemented at all) and they aren't conveniently packaged
4147 and maintained. It takes quite a bit of work to carefully implement utilities
4148 for common use, commented and documented, with error checking placed
4149 everywhere some dumb user might make a mistake.")
4150 (license license:public-domain))))
4152 (define-public cl-utilities
4153 (sbcl-package->cl-source-package sbcl-cl-utilities))
4155 (define-public sbcl-map-set
4156 (let ((commit "7b4b545b68b8")
4159 (name "sbcl-map-set")
4160 (version (git-version "0.0.0" revision commit))
4165 "https://bitbucket.org/tarballs_are_good/map-set/get/"
4168 (base32 "1sx5j5qdsy5fklspfammwb16kjrhkggdavm922a9q86jm5l0b239"))))
4169 (build-system asdf-build-system/sbcl)
4170 (home-page "https://bitbucket.org/tarballs_are_good/map-set")
4171 (synopsis "Set-like data structure")
4173 "Implementation of a set-like data structure with constant time
4174 addition, removal, and random selection.")
4175 (license license:bsd-3))))
4177 (define-public cl-map-set
4178 (sbcl-package->cl-source-package sbcl-map-set))
4180 (define-public sbcl-quri
4181 (let ((commit "b53231c5f19446dd7c24b15a249fefa45ae94f9a")
4185 (version (git-version "0.1.0" revision commit))
4190 (url "https://github.com/fukamachi/quri")
4192 (file-name (git-file-name name version))
4194 (base32 "0cansr63m690ymvhway419178mq2sqnmxm4rdxclbsrnjwwbi36m"))))
4195 (build-system asdf-build-system/sbcl)
4197 ;; Tests fail with: Component QURI-ASD::QURI-TEST not found,
4198 ;; required by #<SYSTEM "quri">. Why?
4200 (native-inputs `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4201 ("sbcl-prove" ,sbcl-prove)))
4202 (inputs `(("sbcl-babel" ,sbcl-babel)
4203 ("sbcl-split-sequence" ,sbcl-split-sequence)
4204 ("sbcl-cl-utilities" ,sbcl-cl-utilities)
4205 ("sbcl-alexandria" ,sbcl-alexandria)))
4206 (home-page "https://github.com/fukamachi/quri")
4207 (synopsis "Yet another URI library for Common Lisp")
4209 "QURI (pronounced \"Q-ree\") is yet another URI library for Common
4210 Lisp. It is intended to be a replacement of PURI.")
4211 (license license:bsd-3))))
4213 (define-public cl-quri
4214 (sbcl-package->cl-source-package sbcl-quri))
4216 (define-public sbcl-myway
4217 (let ((commit "286230082a11f879c18b93f17ca571c5f676bfb7")
4221 (version (git-version "0.1.0" revision commit))
4226 (url "https://github.com/fukamachi/myway")
4228 (file-name (git-file-name "myway" version))
4230 (base32 "0briia9bk3lbr0frnx39d1qg6i38dm4j6z9w3yga3d40k6df4a90"))))
4231 (build-system asdf-build-system/sbcl)
4233 ;; Tests fail with: Component MYWAY-ASD::MYWAY-TEST not found, required
4234 ;; by #<SYSTEM "myway">. Why?
4237 `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4238 ("sbcl-prove" ,sbcl-prove)))
4240 `(("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
4241 ("sbcl-quri" ,sbcl-quri)
4242 ("sbcl-map-set" ,sbcl-map-set)))
4243 (home-page "https://github.com/fukamachi/myway")
4244 (synopsis "Sinatra-compatible URL routing library for Common Lisp")
4245 (description "My Way is a Sinatra-compatible URL routing library.")
4246 (license license:llgpl))))
4248 (define-public cl-myway
4249 (sbcl-package->cl-source-package sbcl-myway))
4251 (define-public sbcl-xsubseq
4252 (let ((commit "5ce430b3da5cda3a73b9cf5cee4df2843034422b")
4255 (name "sbcl-xsubseq")
4256 (version (git-version "0.0.1" revision commit))
4261 (url "https://github.com/fukamachi/xsubseq")
4263 (file-name (git-file-name name version))
4265 (base32 "1xz79q0p2mclf3sqjiwf6izdpb6xrsr350bv4mlmdlm6rg5r99px"))))
4266 (build-system asdf-build-system/sbcl)
4268 ;; Tests fail with: Component XSUBSEQ-ASD::XSUBSEQ-TEST not found,
4269 ;; required by #<SYSTEM "xsubseq">. Why?
4272 `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4273 ("sbcl-prove" ,sbcl-prove)))
4274 (home-page "https://github.com/fukamachi/xsubseq")
4275 (synopsis "Efficient way to use \"subseq\"s in Common Lisp")
4277 "XSubseq provides functions to be able to handle \"subseq\"s more
4279 (license license:bsd-2))))
4281 (define-public cl-xsubseq
4282 (sbcl-package->cl-source-package sbcl-xsubseq))
4284 (define-public sbcl-smart-buffer
4285 (let ((commit "09b9a9a0b3abaa37abe9a730f5aac2643dca4e62")
4288 (name "sbcl-smart-buffer")
4289 (version (git-version "0.0.1" revision commit))
4294 (url "https://github.com/fukamachi/smart-buffer")
4296 (file-name (git-file-name name version))
4298 (base32 "0qz1zzxx0wm5ff7gpgsq550a59p0qj594zfmm2rglj97dahj54l7"))))
4299 (build-system asdf-build-system/sbcl)
4301 ;; Tests fail with: Component SMART-BUFFER-ASD::SMART-BUFFER-TEST not
4302 ;; found, required by #<SYSTEM "smart-buffer">. Why?
4305 `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4306 ("sbcl-prove" ,sbcl-prove)))
4308 `(("sbcl-xsubseq" ,sbcl-xsubseq)
4309 ("sbcl-flexi-streams" ,sbcl-flexi-streams)))
4310 (home-page "https://github.com/fukamachi/smart-buffer")
4311 (synopsis "Smart octets buffer")
4313 "Smart-buffer provides an output buffer which changes the destination
4314 depending on content size.")
4315 (license license:bsd-3))))
4317 (define-public cl-smart-buffer
4318 (sbcl-package->cl-source-package sbcl-smart-buffer))
4320 (define-public sbcl-fast-http
4321 (let ((commit "502a37715dcb8544cc8528b78143a942de662c5a")
4324 (name "sbcl-fast-http")
4325 (version (git-version "0.2.0" revision commit))
4330 (url "https://github.com/fukamachi/fast-http")
4332 (file-name (git-file-name name version))
4334 (base32 "0al2g7g219jjljsf7b23pbilpgacxy5as5gs2nqf76b5qni396mi"))))
4335 (build-system asdf-build-system/sbcl)
4337 ;; Tests fail with: Component FAST-HTTP-ASD::FAST-HTTP-TEST not found,
4338 ;; required by #<SYSTEM "fast-http">. Why?
4341 `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4342 ("sbcl-prove" ,sbcl-prove)
4343 ("cl-syntax-interpol" ,sbcl-cl-syntax-interpol)))
4345 `(("sbcl-alexandria" ,sbcl-alexandria)
4346 ("sbcl-proc-parse" ,sbcl-proc-parse)
4347 ("sbcl-xsubseq" ,sbcl-xsubseq)
4348 ("sbcl-smart-buffer" ,sbcl-smart-buffer)
4349 ("sbcl-cl-utilities" ,sbcl-cl-utilities)))
4350 (home-page "https://github.com/fukamachi/fast-http")
4351 (synopsis "HTTP request/response parser for Common Lisp")
4353 "@code{fast-http} is a HTTP request/response protocol parser for Common
4355 ;; Author specified the MIT license
4356 (license license:expat))))
4358 (define-public cl-fast-http
4359 (sbcl-package->cl-source-package sbcl-fast-http))
4361 (define-public sbcl-static-vectors
4363 (name "sbcl-static-vectors")
4369 (url "https://github.com/sionescu/static-vectors")
4370 (commit (string-append "v" version))))
4371 (file-name (git-file-name name version))
4373 (base32 "0qvf9z6bhwhm8n45fjwkm7j8dcb58szfvndky65cyn4lpdval7m1"))))
4375 `(("sbcl-fiveam" ,sbcl-fiveam)))
4377 `(("sbcl-cffi-grovel" ,sbcl-cffi-grovel)
4378 ("sbcl-cffi" ,sbcl-cffi)))
4379 (build-system asdf-build-system/sbcl)
4380 (home-page "https://github.com/sionescu/static-vectors")
4381 (synopsis "Allocate SIMPLE-ARRAYs in static memory")
4383 "With @code{static-vectors}, you can create vectors allocated in static
4385 (license license:expat)))
4387 (define-public cl-static-vectors
4388 (sbcl-package->cl-source-package sbcl-static-vectors))
4390 (define-public ecl-static-vectors
4391 (sbcl-package->ecl-package sbcl-static-vectors))
4393 (define-public sbcl-marshal
4394 (let ((commit "eff1b15f2b0af2f26f71ad6a4dd5c4beab9299ec")
4397 (name "sbcl-marshal")
4398 (version (git-version "1.3.0" revision commit))
4403 (url "https://github.com/wlbr/cl-marshal")
4405 (file-name (git-file-name name version))
4407 (base32 "08qs6fhk38xpkkjkpcj92mxx0lgy4ygrbbzrmnivdx281syr0gwh"))))
4408 (build-system asdf-build-system/sbcl)
4409 (home-page "https://github.com/wlbr/cl-marshal")
4410 (synopsis "Simple (de)serialization of Lisp datastructures")
4412 "Simple and fast marshalling of Lisp datastructures. Convert any object
4413 into a string representation, put it on a stream an revive it from there.
4414 Only minimal changes required to make your CLOS objects serializable.")
4415 (license license:expat))))
4417 (define-public cl-marshal
4418 (sbcl-package->cl-source-package sbcl-marshal))
4420 (define-public sbcl-checkl
4421 (let ((commit "80328800d047fef9b6e32dfe6bdc98396aee3cc9")
4424 (name "sbcl-checkl")
4425 (version (git-version "0.0.0" revision commit))
4430 (url "https://github.com/rpav/CheckL")
4432 (file-name (git-file-name name version))
4434 (base32 "0bpisihx1gay44xmyr1dmhlwh00j0zzi04rp9fy35i95l2r4xdlx"))))
4435 (build-system asdf-build-system/sbcl)
4437 ;; Error while trying to load definition for system checkl-test from
4438 ;; pathname [...]/checkl-test.asd: The function CHECKL:DEFINE-TEST-OP
4442 `(("sbcl-fiveam" ,sbcl-fiveam)))
4444 `(("sbcl-marshal" ,sbcl-marshal)))
4445 (home-page "https://github.com/rpav/CheckL/")
4446 (synopsis "Dynamic testing for Common Lisp")
4448 "CheckL lets you write tests dynamically, it checks resulting values
4449 against the last run.")
4450 ;; The author specifies both LLGPL and "BSD", but the "BSD" license
4451 ;; isn't specified anywhere, so I don't know which kind. LLGPL is the
4452 ;; stronger of the two and so I think only listing this should suffice.
4453 (license license:llgpl))))
4455 (define-public cl-checkl
4456 (sbcl-package->cl-source-package sbcl-checkl))
4458 (define-public sbcl-fast-io
4459 (let ((commit "603f4903dd74fb221859da7058ae6ca3853fe64b")
4462 (name "sbcl-fast-io")
4463 (version (git-version "1.0.0" revision commit))
4468 (url "https://github.com/rpav/fast-io")
4470 (file-name (git-file-name name version))
4472 (base32 "00agvc0xx4w715i6ach05p995zpcpghn04xc06zyci06q677vw3n"))))
4473 (build-system asdf-build-system/sbcl)
4475 ;; Error while trying to load definition for system fast-io-test from
4476 ;; pathname [...]/fast-io-test.asd: The function CHECKL:DEFINE-TEST-OP
4480 `(("sbcl-fiveam" ,sbcl-fiveam)
4481 ("sbcl-checkl" ,sbcl-checkl)))
4483 `(("sbcl-alexandria" ,sbcl-alexandria)
4484 ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)
4485 ("sbcl-static-vectors" ,sbcl-static-vectors)))
4486 (home-page "https://github.com/rpav/fast-io")
4487 (synopsis "Fast octet-vector/stream I/O for Common Lisp")
4489 "Fast-io is about improving performance to octet-vectors and octet
4490 streams (though primarily the former, while wrapping the latter).")
4491 ;; Author specifies this as NewBSD which is an alias
4492 (license license:bsd-3))))
4494 (define-public cl-fast-io
4495 (sbcl-package->cl-source-package sbcl-fast-io))
4497 (define-public sbcl-jonathan
4498 (let ((commit "1f448b4f7ac8265e56e1c02b32ce383e65316300")
4501 (name "sbcl-jonathan")
4502 (version (git-version "0.1.0" revision commit))
4507 (url "https://github.com/Rudolph-Miller/jonathan")
4509 (file-name (git-file-name name version))
4511 (base32 "14x4iwz3mbag5jzzzr4sb6ai0m9r4q4kyypbq32jmsk2dx1hi807"))))
4512 (build-system asdf-build-system/sbcl)
4514 ;; Tests fail with: Component JONATHAN-ASD::JONATHAN-TEST not found,
4515 ;; required by #<SYSTEM "jonathan">. Why?
4518 `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4519 ("sbcl-prove" ,sbcl-prove)))
4521 `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
4522 ("sbcl-cl-syntax-annot" ,sbcl-cl-syntax-annot)
4523 ("sbcl-fast-io" ,sbcl-fast-io)
4524 ("sbcl-proc-parse" ,sbcl-proc-parse)
4525 ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)))
4526 (home-page "https://rudolph-miller.github.io/jonathan/overview.html")
4527 (synopsis "JSON encoder and decoder")
4529 "High performance JSON encoder and decoder. Currently support: SBCL,
4531 ;; Author specifies the MIT license
4532 (license license:expat))))
4534 (define-public cl-jonathan
4535 (sbcl-package->cl-source-package sbcl-jonathan))
4537 (define-public sbcl-http-body
4538 (let ((commit "dd01dc4f5842e3d29728552e5163acce8386eb73")
4541 (name "sbcl-http-body")
4542 (version (git-version "0.1.0" revision commit))
4547 (url "https://github.com/fukamachi/http-body")
4549 (file-name (git-file-name name version))
4551 (base32 "1jd06snjvxcprhapgfq8sx0y5lrldkvhf206ix6d5a23dd6zcmr0"))))
4552 (build-system asdf-build-system/sbcl)
4554 ;; Tests fail with: Component HTTP-BODY-ASD::HTTP-BODY-TEST not
4555 ;; found, required by #<SYSTEM "http-body">. Why?
4558 `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4559 ("sbcl-prove" ,sbcl-prove)))
4561 `(("sbcl-fast-http" ,sbcl-fast-http)
4562 ("sbcl-jonathan" ,sbcl-jonathan)
4563 ("sbcl-quri" ,sbcl-quri)))
4564 (home-page "https://github.com/fukamachi/http-body")
4565 (synopsis "HTTP POST data parser")
4567 "HTTP-Body parses HTTP POST data and returns POST parameters. It
4568 supports application/x-www-form-urlencoded, application/json, and
4569 multipart/form-data.")
4570 (license license:bsd-2))))
4572 (define-public cl-http-body
4573 (sbcl-package->cl-source-package sbcl-http-body))
4575 (define-public sbcl-circular-streams
4576 (let ((commit "e770bade1919c5e8533dd2078c93c3d3bbeb38df")
4579 (name "sbcl-circular-streams")
4580 (version (git-version "0.1.0" revision commit))
4585 (url "https://github.com/fukamachi/circular-streams")
4587 (file-name (git-file-name name version))
4589 (base32 "1wpw6d5cciyqcf92f7mvihak52pd5s47kk4qq6f0r2z2as68p5rs"))))
4590 (build-system asdf-build-system/sbcl)
4592 ;; The tests depend on cl-test-more which is now prove. Prove
4593 ;; tests aren't working for some reason.
4596 `(("sbcl-fast-io" ,sbcl-fast-io)
4597 ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)))
4598 (home-page "https://github.com/fukamachi/circular-streams")
4599 (synopsis "Circularly readable streams for Common Lisp")
4601 "Circular-Streams allows you to read streams circularly by wrapping real
4602 streams. Once you reach end-of-file of a stream, it's file position will be
4603 reset to 0 and you're able to read it again.")
4604 (license license:llgpl))))
4606 (define-public cl-circular-streams
4607 (sbcl-package->cl-source-package sbcl-circular-streams))
4609 (define-public sbcl-lack-request
4610 (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4613 (name "sbcl-lack-request")
4614 (version (git-version "0.1.0" revision commit))
4619 (url "https://github.com/fukamachi/lack")
4621 (file-name (git-file-name "lack-request" version))
4623 (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4624 (build-system asdf-build-system/sbcl)
4626 '(#:asd-file "lack-request.asd"
4627 #:asd-system-name "lack-request"
4628 #:test-asd-file "t-lack-request.asd"
4629 ;; XXX: Component :CLACK-TEST not found
4632 `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4633 ("sbcl-prove" ,sbcl-prove)))
4635 `(("sbcl-quri" ,sbcl-quri)
4636 ("sbcl-http-body" ,sbcl-http-body)
4637 ("sbcl-circular-streams" ,sbcl-circular-streams)))
4638 (home-page "https://github.com/fukamachi/lack")
4639 (synopsis "Lack, the core of Clack")
4641 "Lack is a Common Lisp library which allows web applications to be
4642 constructed of modular components. It was originally a part of Clack, however
4643 it's going to be rewritten as an individual project since Clack v2 with
4644 performance and simplicity in mind.")
4645 (license license:llgpl))))
4647 (define-public cl-lack-request
4648 (sbcl-package->cl-source-package sbcl-lack-request))
4650 (define-public sbcl-local-time
4651 (let ((commit "62792705245168d3fc2e04164b9a143477284142")
4654 (name "sbcl-local-time")
4655 (version (git-version "1.0.6" revision commit))
4660 (url "https://github.com/dlowe-net/local-time")
4662 (file-name (git-file-name name version))
4664 (base32 "1r5zq4l1lrgprdr2pw7wwry194yknnllyjf6lx7snypb3k4r3yir"))))
4665 (build-system asdf-build-system/sbcl)
4667 ;; TODO: Component :STEFIL not found, required by #<SYSTEM
4668 ;; "local-time/test">
4671 `(("stefil" ,sbcl-hu.dwim.stefil)))
4673 `(("sbcl-cl-fad" ,sbcl-cl-fad)))
4674 (home-page "https://common-lisp.net/project/local-time/")
4675 (synopsis "Time manipulation library for Common Lisp")
4677 "The LOCAL-TIME library is a Common Lisp library for the manipulation of
4678 dates and times. It is based almost entirely upon Erik Naggum's paper \"The
4679 Long Painful History of Time\".")
4680 (license license:expat))))
4682 (define-public cl-local-time
4683 (sbcl-package->cl-source-package sbcl-local-time))
4685 (define-public sbcl-lack-response
4686 (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4689 (name "sbcl-lack-response")
4690 (version (git-version "0.1.0" revision commit))
4695 (url "https://github.com/fukamachi/lack")
4697 (file-name (git-file-name name version))
4699 (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4700 (build-system asdf-build-system/sbcl)
4702 '(#:asd-file "lack-response.asd"
4703 #:asd-system-name "lack-response"
4704 ;; XXX: no tests for lack-response.
4707 `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
4708 ("sbcl-prove" ,sbcl-prove)))
4710 `(("sbcl-quri" ,sbcl-quri)
4711 ("sbcl-http-body" ,sbcl-http-body)
4712 ("sbcl-circular-streams" ,sbcl-circular-streams)
4713 ("sbcl-local-time" ,sbcl-local-time)))
4714 (home-page "https://github.com/fukamachi/lack")
4715 (synopsis "Lack, the core of Clack")
4717 "Lack is a Common Lisp library which allows web applications to be
4718 constructed of modular components. It was originally a part of Clack, however
4719 it's going to be rewritten as an individual project since Clack v2 with
4720 performance and simplicity in mind.")
4721 (license license:llgpl))))
4723 (define-public cl-lack-response
4724 (sbcl-package->cl-source-package sbcl-lack-response))
4726 (define-public sbcl-lack-component
4727 (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4730 (name "sbcl-lack-component")
4731 (version (git-version "0.0.0" revision commit))
4736 (url "https://github.com/fukamachi/lack")
4738 (file-name (git-file-name "lack-component" version))
4740 (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4741 (build-system asdf-build-system/sbcl)
4743 '(#:asd-file "lack-component.asd"
4744 #:asd-system-name "lack-component"
4745 #:test-asd-file "t-lack-component.asd"
4746 ;; XXX: Component :LACK-TEST not found
4749 `(("prove-asdf" ,sbcl-prove-asdf)))
4750 (home-page "https://github.com/fukamachi/lack")
4751 (synopsis "Lack, the core of Clack")
4753 "Lack is a Common Lisp library which allows web applications to be
4754 constructed of modular components. It was originally a part of Clack, however
4755 it's going to be rewritten as an individual project since Clack v2 with
4756 performance and simplicity in mind.")
4757 (license license:llgpl))))
4759 (define-public cl-lack-component
4760 (sbcl-package->cl-source-package sbcl-lack-component))
4762 (define-public sbcl-lack-util
4763 (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4766 (name "sbcl-lack-util")
4767 (version (git-version "0.1.0" revision commit))
4772 (url "https://github.com/fukamachi/lack")
4774 (file-name (git-file-name "lack-util" version))
4776 (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4777 (build-system asdf-build-system/sbcl)
4779 '(#:asd-file "lack-util.asd"
4780 #:asd-system-name "lack-util"
4781 #:test-asd-file "t-lack-util.asd"
4782 ;; XXX: Component :LACK-TEST not found
4785 `(("prove-asdf" ,sbcl-prove-asdf)))
4787 `(("sbcl-ironclad" ,sbcl-ironclad)))
4788 (home-page "https://github.com/fukamachi/lack")
4789 (synopsis "Lack, the core of Clack")
4791 "Lack is a Common Lisp library which allows web applications to be
4792 constructed of modular components. It was originally a part of Clack, however
4793 it's going to be rewritten as an individual project since Clack v2 with
4794 performance and simplicity in mind.")
4795 (license license:llgpl))))
4797 (define-public cl-lack-util
4798 (sbcl-package->cl-source-package sbcl-lack-util))
4800 (define-public sbcl-lack-middleware-backtrace
4801 (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4804 (name "sbcl-lack-middleware-backtrace")
4805 (version (git-version "0.1.0" revision commit))
4810 (url "https://github.com/fukamachi/lack")
4812 (file-name (git-file-name "lack-middleware-backtrace" version))
4814 (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4815 (build-system asdf-build-system/sbcl)
4817 '(#:asd-file "lack-middleware-backtrace.asd"
4818 #:asd-system-name "lack-middleware-backtrace"
4819 #:test-asd-file "t-lack-middleware-backtrace.asd"
4820 ;; XXX: Component :LACK not found
4823 `(("prove-asdf" ,sbcl-prove-asdf)))
4824 (home-page "https://github.com/fukamachi/lack")
4825 (synopsis "Lack, the core of Clack")
4827 "Lack is a Common Lisp library which allows web applications to be
4828 constructed of modular components. It was originally a part of Clack, however
4829 it's going to be rewritten as an individual project since Clack v2 with
4830 performance and simplicity in mind.")
4831 (license license:llgpl))))
4833 (define-public cl-lack-middleware-backtrace
4834 (sbcl-package->cl-source-package sbcl-lack-middleware-backtrace))
4836 (define-public sbcl-trivial-mimes
4837 (let ((commit "303f8ac0aa6ca0bc139aa3c34822e623c3723fab")
4840 (name "sbcl-trivial-mimes")
4841 (version (git-version "1.1.0" revision commit))
4846 (url "https://github.com/Shinmera/trivial-mimes")
4848 (file-name (git-file-name name version))
4850 (base32 "17jxgl47r695bvsb7wi3n2ws5rp1zzgvw0zii8cy5ggw4b4ayv6m"))))
4851 (build-system asdf-build-system/sbcl)
4854 (modify-phases %standard-phases
4857 (lambda* (#:key inputs #:allow-other-keys)
4858 (let ((anchor "#p\"/etc/mime.types\""))
4859 (substitute* "mime-types.lisp"
4863 "(asdf:system-relative-pathname :trivial-mimes "
4864 "\"../../share/common-lisp/" (%lisp-type)
4865 "-source/trivial-mimes/mime.types\")")))))))))
4867 `(("stefil" ,sbcl-hu.dwim.stefil)))
4869 `(("sbcl-cl-fad" ,sbcl-cl-fad)))
4870 (home-page "https://shinmera.github.io/trivial-mimes/")
4871 (synopsis "Tiny Common Lisp library to detect mime types in files")
4873 "This is a teensy library that provides some functions to determine the
4874 mime-type of a file.")
4875 (license license:artistic2.0))))
4877 (define-public cl-trivial-mimes
4878 (sbcl-package->cl-source-package sbcl-trivial-mimes))
4880 (define-public ecl-trivial-mimes
4881 (sbcl-package->ecl-package sbcl-trivial-mimes))
4883 (define-public sbcl-lack-middleware-static
4884 (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4887 (name "sbcl-lack-middleware-static")
4888 (version (git-version "0.1.0" revision commit))
4893 (url "https://github.com/fukamachi/lack")
4895 (file-name (git-file-name "lack-middleware-static" version))
4897 (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4898 (build-system asdf-build-system/sbcl)
4900 '(#:asd-file "lack-middleware-static.asd"
4901 #:asd-system-name "lack-middleware-static"
4902 #:test-asd-file "t-lack-middleware-static.asd"
4903 ;; XXX: Component :LACK not found
4906 `(("prove-asdf" ,sbcl-prove-asdf)))
4908 `(("sbcl-ironclad" ,sbcl-ironclad)
4909 ("sbcl-trivial-mimes" ,sbcl-trivial-mimes)
4910 ("sbcl-local-time" ,sbcl-local-time)))
4911 (home-page "https://github.com/fukamachi/lack")
4912 (synopsis "Lack, the core of Clack")
4914 "Lack is a Common Lisp library which allows web applications to be
4915 constructed of modular components. It was originally a part of Clack, however
4916 it's going to be rewritten as an individual project since Clack v2 with
4917 performance and simplicity in mind.")
4918 (license license:llgpl))))
4920 (define-public cl-lack-middleware-static
4921 (sbcl-package->cl-source-package sbcl-lack-middleware-static))
4923 (define-public sbcl-lack
4924 (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4928 (version (git-version "0.1.0" revision commit))
4933 (url "https://github.com/fukamachi/lack")
4935 (file-name (git-file-name "lack" version))
4937 (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4938 (build-system asdf-build-system/sbcl)
4940 '(#:test-asd-file "t-lack.asd"
4941 ;; XXX: Component :CLACK not found
4944 `(("prove-asdf" ,sbcl-prove-asdf)))
4946 `(("sbcl-lack-component" ,sbcl-lack-component)
4947 ("sbcl-lack-util" ,sbcl-lack-util)))
4948 (home-page "https://github.com/fukamachi/lack")
4949 (synopsis "Lack, the core of Clack")
4951 "Lack is a Common Lisp library which allows web applications to be
4952 constructed of modular components. It was originally a part of Clack, however
4953 it's going to be rewritten as an individual project since Clack v2 with
4954 performance and simplicity in mind.")
4955 (license license:llgpl))))
4957 (define-public cl-lack
4958 (sbcl-package->cl-source-package sbcl-lack))
4960 (define-public sbcl-ningle
4961 (let ((commit "50bd4f09b5a03a7249bd4d78265d6451563b25ad")
4964 (name "sbcl-ningle")
4965 (version (git-version "0.3.0" revision commit))
4970 (url "https://github.com/fukamachi/ningle")
4972 (file-name (git-file-name name version))
4974 (base32 "1bsl8cnxhacb8p92z9n89vhk1ikmij5zavk0m2zvmj7iqm79jzgw"))))
4975 (build-system asdf-build-system/sbcl)
4977 ;; TODO: pull in clack-test
4980 (modify-phases %standard-phases
4981 (delete 'cleanup-files)
4983 (add-before 'cleanup 'combine-fasls
4984 (lambda* (#:key outputs #:allow-other-keys)
4985 (let* ((out (assoc-ref outputs "out"))
4986 (lib (string-append out "/lib/sbcl"))
4987 (ningle-path (string-append lib "/ningle"))
4988 (fasl-files (find-files out "\\.fasl$")))
4989 (mkdir-p ningle-path)
4990 (let ((fasl-path (lambda (name)
4991 (string-append ningle-path
4995 (for-each (lambda (file)
4998 (basename file ".fasl"))))
5003 `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
5004 ("sbcl-prove" ,sbcl-prove)))
5006 `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
5007 ("sbcl-cl-syntax-annot" ,sbcl-cl-syntax-annot)
5008 ("sbcl-myway" ,sbcl-myway)
5009 ("sbcl-lack-request" ,sbcl-lack-request)
5010 ("sbcl-lack-response" ,sbcl-lack-response)
5011 ("sbcl-lack-component" ,sbcl-lack-component)
5012 ("sbcl-alexandria" ,sbcl-alexandria)
5013 ("sbcl-babel" ,sbcl-babel)))
5014 (home-page "https://8arrow.org/ningle/")
5015 (synopsis "Super micro framework for Common Lisp")
5017 "Ningle is a lightweight web application framework for Common Lisp.")
5018 (license license:llgpl))))
5020 (define-public cl-ningle
5021 (sbcl-package->cl-source-package sbcl-ningle))
5023 (define-public sbcl-cl-fastcgi
5024 (let ((commit "d576d20eeb12f225201074b28934ba395b15781a")
5027 (name "sbcl-cl-fastcgi")
5028 (version (git-version "0.2" revision commit))
5033 (url "https://github.com/KDr2/cl-fastcgi/")
5035 (file-name (git-file-name name version))
5037 (base32 "02mvzzyn0k960s38rbxaqqmdkwcfmyhf8dx6ynz8xyxflmp0s5zv"))))
5038 (build-system asdf-build-system/sbcl)
5040 `(("usocket" ,sbcl-usocket)
5045 (modify-phases %standard-phases
5046 (add-after 'unpack 'fix-paths
5047 (lambda* (#:key inputs #:allow-other-keys)
5048 (substitute* "cl-fastcgi.lisp"
5052 (assoc-ref inputs "fcgi") "/lib/libfcgi.so\""))))))))
5053 (home-page "https://kdr2.com/project/cl-fastcgi.html")
5054 (synopsis "FastCGI wrapper for Common Lisp")
5056 "CL-FastCGI is a generic version of SB-FastCGI, targeting to run on
5057 mostly Common Lisp implementation.")
5058 ;; TODO: Upstream on specifies "BSD license":
5059 ;; https://github.com/KDr2/cl-fastcgi/issues/4
5060 (license license:bsd-2))))
5062 (define-public cl-fastcgi
5063 (sbcl-package->cl-source-package sbcl-cl-fastcgi))
5065 (define-public ecl-cl-fastcgi
5066 (sbcl-package->ecl-package sbcl-cl-fastcgi))
5068 (define clack-commit "e3e032843bb1220ab96263c411aa7f2feb4746e0")
5069 (define clack-revision "1")
5071 (define-public sbcl-clack
5074 (version (git-version "2.0.0" clack-revision clack-commit))
5079 (url "https://github.com/fukamachi/clack")
5080 (commit clack-commit)))
5081 (file-name (git-file-name name version))
5083 (base32 "1ymzs6qyrwhlj6cgqsnpyn6g5cbp7a3s1vgxwna20y2q7y4iacy0"))))
5084 (build-system asdf-build-system/sbcl)
5086 `(("sbcl-lack" ,sbcl-lack)
5087 ("sbcl-lack-middleware-backtrace" ,sbcl-lack-middleware-backtrace)
5088 ("sbcl-bordeaux-threads" ,sbcl-bordeaux-threads)))
5089 (home-page "https://github.com/fukamachi/clack")
5090 (synopsis "Web Application Environment for Common Lisp")
5092 "Clack is a web application environment for Common Lisp inspired by
5093 Python's WSGI and Ruby's Rack.")
5094 (license license:llgpl)))
5096 (define-public cl-clack
5097 (sbcl-package->cl-source-package sbcl-clack))
5099 (define-public sbcl-clack-handler-fcgi
5101 (inherit sbcl-clack)
5102 (name "sbcl-clack-handler-fcgi")
5103 (version (git-version "0.3.1" clack-revision clack-commit))
5105 `(("cl-fastcgi" ,sbcl-cl-fastcgi)
5106 ("alexandria" ,sbcl-alexandria)
5107 ("flexi-streams" ,sbcl-flexi-streams)
5108 ("usocket" ,sbcl-usocket)
5109 ("quri" ,sbcl-quri)))
5110 (synopsis "Web Application Environment for Common Lisp (FastCGI handler)")))
5112 (define-public cl-clack-handler-fcgi
5113 (sbcl-package->cl-source-package sbcl-clack-handler-fcgi))
5115 (define sbcl-clack-socket
5117 (inherit sbcl-clack)
5118 (name "sbcl-clack-socket")
5119 (version (git-version "0.1" clack-revision clack-commit))))
5121 (define-public sbcl-clack-handler-hunchentoot
5123 (inherit sbcl-clack)
5124 (name "sbcl-clack-handler-hunchentoot")
5125 (version (git-version "0.4.0" clack-revision clack-commit))
5127 `(("hunchentoot" ,sbcl-hunchentoot)
5128 ("clack-socket" ,sbcl-clack-socket)
5129 ("flexi-streams" ,sbcl-flexi-streams)
5130 ("bordeaux-threads" ,sbcl-bordeaux-threads)
5131 ("split-sequence" ,sbcl-split-sequence)
5132 ("alexandria" ,sbcl-alexandria)))
5133 (synopsis "Web Application Environment for Common Lisp (Hunchentoot handler)")))
5135 (define-public sbcl-log4cl
5136 (let ((commit "611e094458504b938d49de904eab141285328c7c")
5139 (name "sbcl-log4cl")
5140 (build-system asdf-build-system/sbcl)
5146 (url "https://github.com/sharplispers/log4cl")
5148 (file-name (git-file-name name version))
5151 "08jly0s0g26b56hhpfizxsb4j0yvbh946sd205gr42dkzv8l7dsc"))))
5152 ;; FIXME: tests require stefil, sbcl-hu.dwim.stefil wont work
5155 (inputs `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
5156 (synopsis "Common Lisp logging framework, modeled after Log4J")
5157 (home-page "https://github.com/7max/log4cl")
5158 (description "This is a Common Lisp logging framework that can log at
5159 various levels and mix text with expressions.")
5160 (license license:asl2.0))))
5162 (define-public cl-log4cl
5163 (sbcl-package->cl-source-package sbcl-log4cl))
5165 (define-public ecl-log4cl
5166 (sbcl-package->ecl-package sbcl-log4cl))
5168 (define-public sbcl-find-port
5169 (let ((commit "00c96a25af93a0f8681d34ec548861f2d7485478")
5172 (name "sbcl-find-port")
5173 (build-system asdf-build-system/sbcl)
5175 (home-page "https://github.com/eudoxia0/find-port")
5182 (file-name (git-file-name name version))
5185 "0d6dzbb45jh0rx90wgs6v020k2xa87mvzas3mvfzvivjvqqlpryq"))))
5187 `(("fiveam" ,sbcl-fiveam)))
5189 `(("sbcl-usocket" ,sbcl-usocket)))
5190 (synopsis "Find open ports programmatically in Common Lisp")
5191 (description "This is a small Common Lisp library that finds an open
5192 port within a range.")
5193 (license license:expat))))
5195 (define-public cl-find-port
5196 (sbcl-package->cl-source-package sbcl-find-port))
5198 (define-public ecl-find-port
5199 (sbcl-package->ecl-package sbcl-find-port))
5201 (define-public sbcl-clunit
5202 (let ((commit "6f6d72873f0e1207f037470105969384f8380628")
5205 (name "sbcl-clunit")
5206 (version (git-version "0.2.3" revision commit))
5211 (url "https://github.com/tgutu/clunit")
5213 (file-name (git-file-name name version))
5216 "1idf2xnqzlhi8rbrqmzpmb3i1l6pbdzhhajkmhwbp6qjkmxa4h85"))))
5217 (build-system asdf-build-system/sbcl)
5218 (synopsis "CLUnit is a Common Lisp unit testing framework")
5220 "CLUnit is a Common Lisp unit testing framework. It is designed
5221 to be easy to use so that you can quickly start testing. CLUnit
5222 provides a rich set of features aimed at improving your unit testing
5224 (home-page "https://tgutu.github.io/clunit/")
5226 (license license:expat))))
5228 (define-public cl-clunit
5229 (sbcl-package->cl-source-package sbcl-clunit))
5231 (define-public ecl-clunit
5232 (sbcl-package->ecl-package sbcl-clunit))
5234 (define-public sbcl-py4cl
5235 (let ((commit "4c8a2b0814fd311f978964f825ce012290f60136")
5239 (version (git-version "0.0.0" revision commit))
5244 (url "https://github.com/bendudson/py4cl")
5246 (file-name (git-file-name name version))
5249 "15mk7qdqjkj56gdnbyrdyz6r7m1h26ldvn6ch96pmvg5vmr1m45r"))
5250 (modules '((guix build utils)))))
5251 (build-system asdf-build-system/sbcl)
5253 `(("sbcl-clunit" ,sbcl-clunit)))
5255 `(("sbcl-trivial-garbage" ,sbcl-trivial-garbage)))
5257 ;; This package doesn't do anything without python available
5258 `(("python" ,python)
5259 ;; For multi-dimensional array support
5260 ("python-numpy" ,python-numpy)))
5263 (modify-phases %standard-phases
5264 (add-after 'unpack 'replace-*base-directory*-var
5265 (lambda* (#:key outputs #:allow-other-keys)
5266 ;; In the ASD, the author makes an attempt to
5267 ;; programatically determine the location of the
5268 ;; source-code so lisp can call into "py4cl.py". We can
5269 ;; hard-code this since we know where this file will
5271 (substitute* "src/callpython.lisp"
5272 (("py4cl/config:\\*base-directory\\*")
5275 (assoc-ref outputs "out")
5276 "/share/common-lisp/sbcl-source/py4cl/"
5278 (synopsis "Call python from Common Lisp")
5280 "Py4CL is a bridge between Common Lisp and Python, which enables Common
5281 Lisp to interact with Python code. It uses streams to communicate with a
5282 separate python process, the approach taken by cl4py. This is different to
5283 the CFFI approach used by burgled-batteries, but has the same goal.")
5284 (home-page "https://github.com/bendudson/py4cl")
5286 (license license:expat))))
5288 (define-public cl-py4cl
5289 (sbcl-package->cl-source-package sbcl-py4cl))
5291 (define-public ecl-py4cl
5292 (sbcl-package->ecl-package sbcl-py4cl))
5294 (define-public sbcl-parse-declarations
5295 (let ((commit "549aebbfb9403a7fe948654126b9c814f443f4f2")
5298 (name "sbcl-parse-declarations")
5299 (version (git-version "1.0.0" revision commit))
5305 "https://gitlab.common-lisp.net/parse-declarations/"
5306 "parse-declarations.git"))
5308 (file-name (git-file-name name version))
5310 (base32 "03g5qks4c59nmxa48pbslxkfh77h8hn8566jddp6m9pl15dzzpxd"))))
5311 (build-system asdf-build-system/sbcl)
5313 `(#:asd-file "parse-declarations-1.0.asd"
5314 #:asd-system-name "parse-declarations-1.0"))
5315 (home-page "https://common-lisp.net/project/parse-declarations/")
5316 (synopsis "Parse, filter, and build declarations")
5318 "Parse-Declarations is a Common Lisp library to help writing
5319 macros which establish bindings. To be semantically correct, such
5320 macros must take user declarations into account, as these may affect
5321 the bindings they establish. Yet the ANSI standard of Common Lisp does
5322 not provide any operators to work with declarations in a convenient,
5323 high-level way. This library provides such operators.")
5325 (license license:expat))))
5327 (define-public cl-parse-declarations
5328 (sbcl-package->cl-source-package sbcl-parse-declarations))
5330 (define-public ecl-parse-declarations
5331 (sbcl-package->ecl-package sbcl-parse-declarations))
5333 (define-public sbcl-cl-quickcheck
5334 (let ((commit "807b2792a30c883a2fbecea8e7db355b50ba662f")
5337 (name "sbcl-cl-quickcheck")
5338 (version (git-version "0.0.4" revision commit))
5343 (url "https://github.com/mcandre/cl-quickcheck")
5345 (file-name (git-file-name name version))
5348 "165lhypq5xkcys6hvzb3jq7ywnmqvzaflda29qk2cbs3ggas4767"))))
5349 (build-system asdf-build-system/sbcl)
5351 "Common Lisp port of the QuickCheck unit test framework")
5353 "Common Lisp port of the QuickCheck unit test framework")
5354 (home-page "https://github.com/mcandre/cl-quickcheck")
5356 (license license:expat))))
5358 (define-public cl-cl-quickcheck
5359 (sbcl-package->cl-source-package sbcl-cl-quickcheck))
5361 (define-public ecl-cl-quickcheck
5362 (sbcl-package->ecl-package sbcl-cl-quickcheck))
5364 (define-public sbcl-burgled-batteries3
5365 (let ((commit "f65f454d13bb6c40e17e9ec62e41eb5069e09760")
5368 (name "sbcl-burgled-batteries3")
5369 (version (git-version "0.0.0" revision commit))
5374 (url "https://github.com/snmsts/burgled-batteries3")
5376 (file-name (git-file-name name version))
5379 "1nzn7jawrfajyzwfnzrg2cmn9xxadcqh4szbpg0jggkhdkdzz4wa"))))
5380 (build-system asdf-build-system/sbcl)
5383 #:modules (((guix build python-build-system) #:select (python-version))
5384 ,@%asdf-build-system-modules)
5385 #:imported-modules ((guix build python-build-system)
5386 ,@%asdf-build-system-modules)
5388 (modify-phases (@ (guix build asdf-build-system) %standard-phases)
5389 (add-after 'unpack 'set-*cpython-include-dir*-var
5390 (lambda* (#:key inputs #:allow-other-keys)
5391 (let ((python (assoc-ref inputs "python")))
5392 (setenv "BB_PYTHON3_INCLUDE_DIR"
5393 (string-append python "/include/python"
5394 (python-version python)))
5395 (setenv "BB_PYTHON3_DYLIB"
5396 (string-append python "/lib/libpython3.so"))
5398 (add-after 'unpack 'adjust-for-python-3.8
5400 ;; This method is no longer part of the public API.
5401 (substitute* "ffi-interface.lisp"
5402 ((".*PyEval_ReInitThreads.*")
5406 `(("sbcl-cl-fad" ,sbcl-cl-fad)
5407 ("sbcl-lift" ,sbcl-lift)
5408 ("sbcl-cl-quickcheck" ,sbcl-cl-quickcheck)))
5410 `(("python" ,python)
5411 ("sbcl-cffi" ,sbcl-cffi)
5412 ("sbcl-cffi-grovel" ,sbcl-cffi-grovel)
5413 ("sbcl-alexandria" , sbcl-alexandria)
5414 ("sbcl-parse-declarations-1.0" ,sbcl-parse-declarations)
5415 ("sbcl-trivial-garbage" ,sbcl-trivial-garbage)))
5416 (synopsis "Bridge between Python and Lisp (FFI bindings, etc.)")
5418 "This package provides a shim between Python3 (specifically, the
5419 CPython implementation of Python) and Common Lisp.")
5420 (home-page "https://github.com/snmsts/burgled-batteries3")
5421 (license license:expat))))
5423 (define-public cl-burgled-batteries3
5424 (sbcl-package->cl-source-package sbcl-burgled-batteries3))
5426 (define-public ecl-burgled-batteries3
5427 (sbcl-package->ecl-package sbcl-burgled-batteries3))
5429 (define-public sbcl-metabang-bind
5430 (let ((commit "c93b7f7e1c18c954c2283efd6a7fdab36746ab5e")
5433 (name "sbcl-metabang-bind")
5434 (version (git-version "0.8.0" revision commit))
5439 (url "https://github.com/gwkkwg/metabang-bind")
5441 (file-name (git-file-name name version))
5444 "0hd0kr91795v77akpbcyqiss9p0p7ypa9dznrllincnmgvsxlmf0"))))
5445 (build-system asdf-build-system/sbcl)
5447 `(("sbcl-lift" ,sbcl-lift)))
5448 (synopsis "Macro that generalizes @code{multiple-value-bind} etc.")
5450 "Bind extends the idea of of let and destructing to provide a uniform
5451 syntax for all your accessor needs. It combines @code{let},
5452 @code{destructuring-bind}, @code{with-slots}, @code{with-accessors}, structure
5453 editing, property or association-lists, and @code{multiple-value-bind} and a
5454 whole lot more into a single form.")
5455 (home-page "https://common-lisp.net/project/metabang-bind/")
5457 (license license:expat))))
5459 (define-public cl-metabang-bind
5460 (sbcl-package->cl-source-package sbcl-metabang-bind))
5462 (define-public ecl-metabang-bind
5463 (sbcl-package->ecl-package sbcl-metabang-bind))
5465 (define-public sbcl-fare-utils
5466 (let ((commit "66e9c6f1499140bc00ccc22febf2aa528cbb5724")
5469 (name "sbcl-fare-utils")
5470 (version (git-version "1.0.0.5" revision commit))
5477 "https://gitlab.common-lisp.net/frideau/fare-utils.git")
5479 (file-name (git-file-name name version))
5482 "01wsr1aap3jdzhn4hrqjbhsjx6qci9dbd3gh4gayv1p49rbg8aqr"))))
5483 (build-system asdf-build-system/sbcl)
5485 `(#:test-asd-file "test/fare-utils-test.asd"))
5487 `(("sbcl-hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
5488 (synopsis "Collection of utilities and data structures")
5490 "fare-utils is a small collection of utilities. It contains a lot of
5491 basic everyday functions and macros.")
5492 (home-page "https://gitlab.common-lisp.net/frideau/fare-utils")
5494 (license license:expat))))
5496 (define-public cl-fare-utils
5497 (sbcl-package->cl-source-package sbcl-fare-utils))
5499 (define-public ecl-fare-utils
5500 (sbcl-package->ecl-package sbcl-fare-utils))
5502 (define-public sbcl-trivial-utf-8
5503 (let ((commit "4d427cfbb1c452436a0efb71c3205c9da67f718f")
5506 (name "sbcl-trivial-utf-8")
5507 (version (git-version "0.0.0" revision commit))
5513 (url (string-append "https://gitlab.common-lisp.net/"
5514 "trivial-utf-8/trivial-utf-8.git"))
5516 (file-name (git-file-name name version))
5519 "1jz27gz8gvqdmvp3k9bxschs6d5b3qgk94qp2bj6nv1d0jc3m1l1"))))
5521 ;; Guix incorrectly assumes the "8" is part of the version
5522 ;; number and lobs it off.
5523 `(#:asd-file "trivial-utf-8.asd"
5524 #:asd-system-name "trivial-utf-8"))
5525 (build-system asdf-build-system/sbcl)
5526 (synopsis "UTF-8 input/output library")
5528 "The Babel library solves a similar problem while understanding more
5529 encodings. Trivial UTF-8 was written before Babel existed, but for new
5530 projects you might be better off going with Babel. The one plus that Trivial
5531 UTF-8 has is that it doesn't depend on any other libraries.")
5532 (home-page "https://common-lisp.net/project/trivial-utf-8/")
5533 (license license:bsd-3))))
5535 (define-public cl-trivial-utf-8
5536 (sbcl-package->cl-source-package sbcl-trivial-utf-8))
5538 (define-public ecl-trivial-utf-8
5539 (sbcl-package->ecl-package sbcl-trivial-utf-8))
5541 (define-public sbcl-idna
5544 (build-system asdf-build-system/sbcl)
5546 (home-page "https://github.com/antifuchs/idna")
5553 (file-name (git-file-name name version))
5556 "00nbr3mffxhlq14gg9d16pa6691s4qh35inyw76v906s77khm5a2"))))
5558 `(("split-sequence" ,sbcl-split-sequence)))
5559 (synopsis "IDNA string encoding and decoding routines for Common Lisp")
5560 (description "This Common Lisp library provides string encoding and
5561 decoding routines for IDNA, the International Domain Names in Applications.")
5562 (license license:expat)))
5564 (define-public cl-idna
5565 (sbcl-package->cl-source-package sbcl-idna))
5567 (define-public ecl-idna
5568 (sbcl-package->ecl-package sbcl-idna))
5570 (define-public sbcl-swap-bytes
5572 (name "sbcl-swap-bytes")
5573 (build-system asdf-build-system/sbcl)
5575 (home-page "https://github.com/sionescu/swap-bytes")
5581 (commit (string-append "v" version))))
5582 (file-name (git-file-name name version))
5585 "1hw1v1lw26rifyznpnj1csphha9jgzwpiic16ni3pvs6hcsni9rz"))))
5587 `(("trivial-features" ,sbcl-trivial-features)))
5589 `(("fiveam" ,sbcl-fiveam)))
5590 (synopsis "Efficient endianness conversion for Common Lisp")
5591 (description "This Common Lisp library provides optimized byte-swapping
5592 primitives. The library can change endianness of unsigned integers of length
5593 1/2/4/8. Very useful in implementing various network protocols and file
5595 (license license:expat)))
5597 (define-public cl-swap-bytes
5598 (sbcl-package->cl-source-package sbcl-swap-bytes))
5600 (define-public ecl-swap-bytes
5601 (sbcl-package->ecl-package sbcl-swap-bytes))
5603 (define-public sbcl-iolib.asdf
5604 ;; Latest release is from June 2017.
5605 (let ((commit "7f5ea3a8457a29d224b24653c2b3657fb1898021")
5608 (name "sbcl-iolib.asdf")
5609 (build-system asdf-build-system/sbcl)
5610 (version (git-version "0.8.3" revision commit))
5611 (home-page "https://github.com/sionescu/iolib")
5618 (file-name (git-file-name name version))
5621 "1bg5w7lm61hqk4b0svmri8a590q36z76jfa0sdgzb39r98c04w12"))))
5623 `(("alexandria" ,sbcl-alexandria)))
5625 '(#:asd-file "iolib.asdf.asd"))
5626 (synopsis "ASDF component classes for IOLib, a Common Lisp I/O library")
5627 (description "IOlib is to be a better and more modern I/O library than
5628 the standard Common Lisp library. It contains a socket library, a DNS
5629 resolver, an I/O multiplexer(which supports @code{select(2)}, @code{epoll(4)}
5630 and @code{kqueue(2)}), a pathname library and file-system utilities.")
5631 (license license:expat))))
5633 (define-public sbcl-iolib.conf
5635 (inherit sbcl-iolib.asdf)
5636 (name "sbcl-iolib.conf")
5638 `(("iolib.asdf" ,sbcl-iolib.asdf)))
5640 '(#:asd-file "iolib.conf.asd"))
5641 (synopsis "Compile-time configuration for IOLib, a Common Lisp I/O library")))
5643 (define-public sbcl-iolib.common-lisp
5645 (inherit sbcl-iolib.asdf)
5646 (name "sbcl-iolib.common-lisp")
5648 `(("iolib.asdf" ,sbcl-iolib.asdf)
5649 ("iolib.conf" ,sbcl-iolib.conf)))
5651 '(#:asd-file "iolib.common-lisp.asd"))
5652 (synopsis "Slightly modified Common Lisp for IOLib, a Common Lisp I/O library")))
5654 (define-public sbcl-iolib.base
5656 (inherit sbcl-iolib.asdf)
5657 (name "sbcl-iolib.base")
5659 `(("iolib.asdf" ,sbcl-iolib.asdf)
5660 ("iolib.conf" ,sbcl-iolib.conf)
5661 ("iolib.common-lisp" ,sbcl-iolib.common-lisp)
5662 ("split-sequence" ,sbcl-split-sequence)))
5664 '(#:asd-file "iolib.base.asd"))
5665 (synopsis "Base package for IOLib, a Common Lisp I/O library")))
5667 (define-public sbcl-iolib.grovel
5668 (deprecated-package "sbcl-iolib.grovel" sbcl-cffi-grovel))
5670 (define sbcl-iolib+syscalls
5672 (inherit sbcl-iolib.asdf)
5673 (name "sbcl-iolib+syscalls")
5675 `(("iolib.asdf" ,sbcl-iolib.asdf)
5676 ("iolib.conf" ,sbcl-iolib.conf)
5677 ("cffi-grovel" ,sbcl-cffi-grovel)
5678 ("iolib.base" ,sbcl-iolib.base)
5679 ("bordeaux-threads" ,sbcl-bordeaux-threads)
5681 ("swap-bytes" ,sbcl-swap-bytes)
5682 ("libfixposix" ,libfixposix)
5683 ("cffi" ,sbcl-cffi)))
5685 `(("fiveam" ,sbcl-fiveam)))
5687 '(#:asd-file "iolib.asd"
5688 #:asd-system-name "iolib/syscalls"
5690 (modify-phases %standard-phases
5691 (add-after 'unpack 'fix-paths
5692 (lambda* (#:key inputs #:allow-other-keys)
5693 (substitute* "src/syscalls/ffi-functions-unix.lisp"
5694 (("\\(:default \"libfixposix\"\\)")
5697 (assoc-ref inputs "libfixposix") "/lib/libfixposix\")")))
5698 ;; Socket tests need Internet access, disable them.
5699 (substitute* "iolib.asd"
5700 (("\\(:file \"sockets\" :depends-on \\(\"pkgdcl\" \"defsuites\"\\)\\)")
5702 (synopsis "Common Lisp I/O library")))
5704 (define sbcl-iolib+multiplex
5706 (inherit sbcl-iolib+syscalls)
5707 (name "sbcl-iolib+multiplex")
5709 `(("iolib+syscalls" ,sbcl-iolib+syscalls)
5710 ,@(package-inputs sbcl-iolib+syscalls)))
5712 (substitute-keyword-arguments (package-arguments sbcl-iolib+syscalls)
5713 ((#:asd-system-name _) "iolib/multiplex")))))
5715 (define sbcl-iolib+streams
5717 (inherit sbcl-iolib+syscalls)
5718 (name "sbcl-iolib+streams")
5720 `(("iolib+multiplex" ,sbcl-iolib+multiplex)
5721 ,@(package-inputs sbcl-iolib+syscalls)))
5723 (substitute-keyword-arguments (package-arguments sbcl-iolib+syscalls)
5724 ((#:asd-system-name _) "iolib/streams")))))
5726 (define sbcl-iolib+sockets
5728 (inherit sbcl-iolib+syscalls)
5729 (name "sbcl-iolib+sockets")
5731 `(("iolib+syscalls" ,sbcl-iolib+syscalls)
5732 ("iolib+streams" ,sbcl-iolib+streams)
5733 ,@(package-inputs sbcl-iolib+syscalls)))
5735 (substitute-keyword-arguments (package-arguments sbcl-iolib+syscalls)
5736 ((#:asd-system-name _) "iolib/sockets")))))
5738 (define-public sbcl-iolib
5740 (inherit sbcl-iolib+syscalls)
5743 `(("iolib+multiplex" ,sbcl-iolib+multiplex)
5744 ("iolib+streams" ,sbcl-iolib+streams)
5745 ("iolib+sockets" ,sbcl-iolib+sockets)
5746 ,@(package-inputs sbcl-iolib+syscalls)))
5748 (substitute-keyword-arguments (package-arguments sbcl-iolib+syscalls)
5749 ((#:asd-system-name _) "iolib")))))
5751 (define-public cl-iolib
5752 (let ((parent (sbcl-package->cl-source-package sbcl-iolib)))
5756 ;; Need header to compile.
5757 `(("libfixposix" ,libfixposix)
5758 ,@(package-propagated-inputs parent))))))
5760 (define-public sbcl-ieee-floats
5761 (let ((commit "566b51a005e81ff618554b9b2f0b795d3b29398d")
5764 (name "sbcl-ieee-floats")
5765 (build-system asdf-build-system/sbcl)
5766 (version (git-version "20170924" revision commit))
5767 (home-page "https://github.com/marijnh/ieee-floats/")
5774 (file-name (git-file-name name version))
5777 "1xyj49j9x3lc84cv3dhbf9ja34ywjk1c46dklx425fxw9mkwm83m"))))
5779 `(("fiveam" ,sbcl-fiveam)))
5780 (synopsis "IEEE 754 binary representation for floats in Common Lisp")
5781 (description "This is a Common Lisp library that converts
5782 floating point values to IEEE 754 binary representation.")
5783 (license license:bsd-3))))
5785 (define-public cl-ieee-floats
5786 (sbcl-package->cl-source-package sbcl-ieee-floats))
5788 (define sbcl-closure-common
5789 (let ((commit "e3c5f5f454b72b01b89115e581c3c52a7e201e5c")
5792 (name "sbcl-closure-common")
5793 (build-system asdf-build-system/sbcl)
5794 (version (git-version "20101006" revision commit))
5795 (home-page "https://common-lisp.net/project/cxml/")
5800 (url "https://github.com/sharplispers/closure-common")
5802 (file-name (git-file-name name version))
5805 "0k5r2qxn122pxi301ijir3nayi9sg4d7yiy276l36qmzwhp4mg5n"))))
5807 `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)
5808 ("babel" ,sbcl-babel)))
5809 (synopsis "Support Common Lisp library for CXML")
5810 (description "Closure-common is an internal helper library. The name
5811 Closure is a reference to the web browser it was originally written for.")
5815 (define-public sbcl-cxml+xml
5816 (let ((commit "00b22bf4c4cf11c993d5866fae284f95ab18e6bf")
5819 (name "sbcl-cxml+xml")
5820 (build-system asdf-build-system/sbcl)
5821 (version (git-version "0.0.0" revision commit))
5822 (home-page "https://common-lisp.net/project/cxml/")
5827 (url "https://github.com/sharplispers/cxml")
5829 (file-name (git-file-name name version))
5832 "13kif7rf3gqdycsk9zq0d7y0g9y81krkl0z87k0p2fkbjfgrph37"))))
5834 `(("closure-common" ,sbcl-closure-common)
5836 ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
5838 `(#:asd-file "cxml.asd"
5839 #:asd-system-name "cxml/xml"))
5840 (synopsis "Common Lisp XML parser")
5841 (description "CXML implements a namespace-aware, validating XML 1.0
5842 parser as well as the DOM Level 2 Core interfaces. Two parser interfaces are
5843 offered, one SAX-like, the other similar to StAX.")
5844 (license license:llgpl))))
5846 (define sbcl-cxml+dom
5848 (inherit sbcl-cxml+xml)
5849 (name "sbcl-cxml+dom")
5851 `(("closure-common" ,sbcl-closure-common)
5853 ("cxml+xml" ,sbcl-cxml+xml)))
5855 `(#:asd-file "cxml.asd"
5856 #:asd-system-name "cxml/dom"))))
5858 (define sbcl-cxml+klacks
5860 (inherit sbcl-cxml+xml)
5861 (name "sbcl-cxml+klacks")
5863 `(("closure-common" ,sbcl-closure-common)
5865 ("cxml+xml" ,sbcl-cxml+xml)))
5867 `(#:asd-file "cxml.asd"
5868 #:asd-system-name "cxml/klacks"))))
5870 (define sbcl-cxml+test
5872 (inherit sbcl-cxml+xml)
5873 (name "sbcl-cxml+test")
5875 `(("closure-common" ,sbcl-closure-common)
5877 ("cxml+xml" ,sbcl-cxml+xml)))
5879 `(#:asd-file "cxml.asd"
5880 #:asd-system-name "cxml/test"))))
5882 (define-public sbcl-cxml
5884 (inherit sbcl-cxml+xml)
5887 `(("closure-common" ,sbcl-closure-common)
5889 ("trivial-gray-streams" ,sbcl-trivial-gray-streams)
5890 ("cxml+dom" ,sbcl-cxml+dom)
5891 ("cxml+klacks" ,sbcl-cxml+klacks)
5892 ("cxml+test" ,sbcl-cxml+test)))
5894 `(#:asd-file "cxml.asd"
5895 #:asd-system-name "cxml"
5897 (modify-phases %standard-phases
5898 (add-after 'build 'install-dtd
5899 (lambda* (#:key outputs #:allow-other-keys)
5900 (install-file "catalog.dtd"
5902 (assoc-ref outputs "out")
5903 "/lib/" (%lisp-type))))))))))
5905 (define-public cl-cxml
5906 (sbcl-package->cl-source-package sbcl-cxml))
5908 (define-public sbcl-cl-reexport
5909 (let ((commit "312f3661bbe187b5f28536cd7ec2956e91366c3b")
5912 (name "sbcl-cl-reexport")
5913 (build-system asdf-build-system/sbcl)
5914 (version (git-version "0.1" revision commit))
5915 (home-page "https://github.com/takagi/cl-reexport")
5922 (file-name (git-file-name name version))
5925 "1cwpn1m3wrl0fl9plznn7p464db646gnfc8zkyk97dyxski2aq0x"))))
5927 `(("alexandria" ,sbcl-alexandria)))
5929 ;; TODO: Tests fail because cl-test-more is missing, but I can't find it online.
5931 (synopsis "HTTP cookie manager for Common Lisp")
5932 (description "cl-cookie is a Common Lisp library featuring parsing of
5933 cookie headers, cookie creation, cookie jar creation and more.")
5934 (license license:llgpl))))
5936 (define-public cl-reexport
5937 (sbcl-package->cl-source-package sbcl-cl-reexport))
5939 (define-public sbcl-cl-cookie
5940 (let ((commit "cea55aed8b9ad25fafd13defbcb9fe8f41b29546")
5943 (name "sbcl-cl-cookie")
5944 (build-system asdf-build-system/sbcl)
5945 (version (git-version "0.9.10" revision commit))
5946 (home-page "https://github.com/fukamachi/cl-cookie")
5953 (file-name (git-file-name name version))
5956 "090g7z75h98zvc1ldx0vh4jn4086dhjm2w30jcwkq553qmyxwl8h"))))
5958 `(("proc-parse" ,sbcl-proc-parse)
5959 ("alexandria" ,sbcl-alexandria)
5961 ("cl-ppcre" ,sbcl-cl-ppcre)
5962 ("local-time" ,sbcl-local-time)))
5964 `(("prove-asdf" ,sbcl-prove-asdf)
5965 ("prove" ,sbcl-prove)))
5967 ;; TODO: Tests fail because cl-cookie depends on cl-cookie-test.
5969 (synopsis "HTTP cookie manager for Common Lisp")
5970 (description "cl-cookie is a Common Lisp library featuring parsing of
5971 cookie headers, cookie creation, cookie jar creation and more.")
5972 (license license:bsd-2))))
5974 (define-public cl-cookie
5975 (sbcl-package->cl-source-package sbcl-cl-cookie))
5977 (define-public sbcl-dexador
5978 (let ((commit "953090f04c4d1a9ee6632b90133cdc297b68badc")
5981 (name "sbcl-dexador")
5982 (build-system asdf-build-system/sbcl)
5984 (home-page "https://github.com/fukamachi/dexador")
5991 (file-name (git-file-name name version))
5994 "0w18fz3301rpmwc3kwb810czcd24mbf7r1z8vdyc0v5crjfpw3mn"))))
5996 `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)
5997 ("babel" ,sbcl-babel)
5998 ("usocket" ,sbcl-usocket)
5999 ("fast-http" ,sbcl-fast-http)
6001 ("fast-io" ,sbcl-fast-io)
6002 ("chunga" ,sbcl-chunga)
6003 ("cl-ppcre" ,sbcl-cl-ppcre)
6004 ("cl-cookie" ,sbcl-cl-cookie)
6005 ("trivial-mimes" ,sbcl-trivial-mimes)
6006 ("chipz" ,sbcl-chipz)
6007 ("cl-base64" ,sbcl-cl-base64)
6008 ("cl-reexport" ,sbcl-cl-reexport)
6009 ("cl+ssl" ,sbcl-cl+ssl)
6010 ("bordeaux-threads" ,sbcl-bordeaux-threads)
6011 ("alexandria" ,sbcl-alexandria)))
6013 `(("prove" ,sbcl-prove)
6014 ("prove-asdf" ,sbcl-prove-asdf)
6015 ("lack-request" ,sbcl-lack-request)
6016 ("clack" ,sbcl-clack)
6017 ("babel" ,sbcl-babel)
6018 ("alexandria" ,sbcl-alexandria)
6019 ("cl-ppcre" ,sbcl-cl-ppcre)
6020 ("local-time" ,sbcl-local-time)
6021 ("trivial-features" ,sbcl-trivial-features)))
6023 ;; TODO: Circular dependency: tests depend on clack-test which depends on dexador.
6026 (modify-phases %standard-phases
6027 (add-after 'unpack 'fix-permissions
6028 (lambda _ (make-file-writable "t/data/test.gz") #t)))))
6029 (synopsis "Yet another HTTP client for Common Lisp")
6030 (description "Dexador is yet another HTTP client for Common Lisp with
6031 neat APIs and connection-pooling. It is meant to supersede Drakma.")
6032 (license license:expat))))
6034 (define-public cl-dexador
6036 (inherit (sbcl-package->cl-source-package sbcl-dexador))
6039 ;; asdf-build-system/source has its own phases and does not inherit
6040 ;; from asdf-build-system/sbcl phases.
6041 (modify-phases %standard-phases/source
6042 ;; Already done in SBCL package.
6043 (delete 'reset-gzip-timestamps))))))
6045 (define-public ecl-dexador
6046 (sbcl-package->ecl-package sbcl-dexador))
6048 (define-public sbcl-lisp-namespace
6049 (let ((commit "28107cafe34e4c1c67490fde60c7f92dc610b2e0")
6052 (name "sbcl-lisp-namespace")
6053 (build-system asdf-build-system/sbcl)
6054 (version (git-version "0.1" revision commit))
6055 (home-page "https://github.com/guicho271828/lisp-namespace")
6062 (file-name (git-file-name name version))
6065 "1jw2wykp06z2afb9nm1lgfzll5cjlj36pnknjx614057zkkxq4iy"))))
6067 `(("alexandria" ,sbcl-alexandria)))
6069 `(("fiveam" ,sbcl-fiveam)))
6071 `(#:test-asd-file "lisp-namespace.test.asd"
6072 ;; XXX: Component LISP-NAMESPACE-ASD::LISP-NAMESPACE.TEST not found
6074 (synopsis "LISP-N, or extensible namespaces in Common Lisp")
6075 (description "Common Lisp already has major 2 namespaces, function
6076 namespace and value namespace (or variable namespace), but there are actually
6077 more — e.g., class namespace.
6078 This library offers macros to deal with symbols from any namespace.")
6079 (license license:llgpl))))
6081 (define-public cl-lisp-namespace
6082 (sbcl-package->cl-source-package sbcl-lisp-namespace))
6084 (define-public sbcl-trivial-cltl2
6085 (let ((commit "8a3bda30dc25d2f65fcf514d0eb6e6db75252c61")
6088 (name "sbcl-trivial-cltl2")
6089 (build-system asdf-build-system/sbcl)
6090 (version (git-version "0.1.1" revision commit))
6091 (home-page "https://github.com/Zulu-Inuoe/trivial-cltl2")
6098 (file-name (git-file-name name version))
6101 "08cnzb9rnczn4pn2zpf0587ny4wjy1mjndy885fz9pw7xrlx37ip"))))
6102 (synopsis "Simple CLtL2 compatibility layer for Common Lisp")
6103 (description "This library is a portable compatibility layer around
6104 \"Common Lisp the Language, 2nd
6105 Edition\" (@url{https://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node102.html})
6106 and it exports symbols from implementation-specific packages.")
6107 (license license:llgpl))))
6109 (define-public cl-trivial-cltl2
6110 (sbcl-package->cl-source-package sbcl-trivial-cltl2))
6112 (define-public sbcl-introspect-environment
6113 (let ((commit "fff42f8f8fd0d99db5ad6c5812e53de7d660020b")
6116 (name "sbcl-introspect-environment")
6117 (build-system asdf-build-system/sbcl)
6118 (version (git-version "0.1" revision commit))
6119 (home-page "https://github.com/Bike/introspect-environment")
6126 (file-name (git-file-name name version))
6129 "1i305n0wfmpac63ni4i3vixnnkl8daw5ncxy0k3dv92krgx6qzhp"))))
6131 `(("fiveam" ,sbcl-fiveam)))
6132 (synopsis "Common Lisp environment introspection portability layer")
6133 (description "This library is a small interface to portable but
6134 nonstandard introspection of Common Lisp environments. It is intended to
6135 allow a bit more compile-time introspection of environments in Common Lisp.
6137 Quite a bit of information is available at the time a macro or compiler-macro
6138 runs; inlining info, type declarations, that sort of thing. This information
6139 is all standard - any Common Lisp program can @code{(declare (integer x))} and
6142 This info ought to be accessible through the standard @code{&environment}
6143 parameters, but it is not. Several implementations keep the information for
6144 their own purposes but do not make it available to user programs, because
6145 there is no standard mechanism to do so.
6147 This library uses implementation-specific hooks to make information available
6148 to users. This is currently supported on SBCL, CCL, and CMUCL. Other
6149 implementations have implementations of the functions that do as much as they
6150 can and/or provide reasonable defaults.")
6151 (license license:wtfpl2))))
6153 (define-public cl-introspect-environment
6154 (sbcl-package->cl-source-package sbcl-introspect-environment))
6156 (define-public sbcl-type-i
6157 (let ((commit "d34440ab4ebf5a46a58deccb35950b15670e3667")
6160 (name "sbcl-type-i")
6161 (build-system asdf-build-system/sbcl)
6162 (version (git-version "0.1" revision commit))
6163 (home-page "https://github.com/guicho271828/type-i")
6170 (file-name (git-file-name name version))
6173 "12wsga0pwjkkr176lnjwkmmlm3ccp0n310sjj9h20lk53iyd0z69"))))
6175 `(("alexandria" ,sbcl-alexandria)
6176 ("introspect-environment" ,sbcl-introspect-environment)
6177 ("trivia.trivial" ,sbcl-trivia.trivial)))
6179 `(("fiveam" ,sbcl-fiveam)))
6181 `(#:test-asd-file "type-i.test.asd"))
6182 (synopsis "Type inference utility on unary predicates for Common Lisp")
6183 (description "This library tries to provide a way to detect what kind of
6184 type the given predicate is trying to check. This is different from inferring
6185 the return type of a function.")
6186 (license license:llgpl))))
6188 (define-public cl-type-i
6189 (sbcl-package->cl-source-package sbcl-type-i))
6191 (define-public sbcl-optima
6192 (let ((commit "373b245b928c1a5cce91a6cb5bfe5dd77eb36195")
6195 (name "sbcl-optima")
6196 (build-system asdf-build-system/sbcl)
6197 (version (git-version "1.0" revision commit))
6198 (home-page "https://github.com/m2ym/optima")
6205 (file-name (git-file-name name version))
6208 "1yw4ymq7ms89342kkvb3aqxgv0w38m9kd8ikdqxxzyybnkjhndal"))))
6210 `(("alexandria" ,sbcl-alexandria)
6211 ("closer-mop" ,sbcl-closer-mop)))
6213 `(("eos" ,sbcl-eos)))
6215 ;; XXX: Circular dependencies: tests depend on optima.ppcre which depends on optima.
6217 #:test-asd-file "optima.test.asd"))
6218 (synopsis "Optimized pattern matching library for Common Lisp")
6219 (description "Optima is a fast pattern matching library which uses
6220 optimizing techniques widely used in the functional programming world.")
6221 (license license:expat))))
6223 (define-public cl-optima
6224 (sbcl-package->cl-source-package sbcl-optima))
6226 (define-public sbcl-fare-quasiquote
6227 (let ((commit "640d39a0451094071b3e093c97667b3947f43639")
6230 (name "sbcl-fare-quasiquote")
6231 (build-system asdf-build-system/sbcl)
6232 (version (git-version "1.0.1" revision commit))
6233 (home-page "https://gitlab.common-lisp.net/frideau/fare-quasiquote")
6238 (url (string-append "https://gitlab.common-lisp.net/frideau/"
6239 "fare-quasiquote.git"))
6241 (file-name (git-file-name name version))
6243 (base32 "1g6q11l50kgija9f55lzqpcwvaq0ljiw8v1j265hnyg6nahjwjvg"))))
6245 `(("fare-utils" ,sbcl-fare-utils)))
6247 ;; XXX: Circular dependencies: Tests depend on subsystems,
6248 ;; which depend on the main systems.
6251 (modify-phases %standard-phases
6252 ;; XXX: Require 1.0.0 version of fare-utils, and we package some
6253 ;; commits after 1.0.0.5, but ASDF fails to read the
6254 ;; "-REVISION-COMMIT" part generated by Guix.
6255 (add-after 'unpack 'patch-requirement
6257 (substitute* "fare-quasiquote.asd"
6258 (("\\(:version \"fare-utils\" \"1.0.0\"\\)")
6259 "\"fare-utils\"")))))))
6260 (synopsis "Pattern-matching friendly implementation of quasiquote")
6261 (description "The main purpose of this n+2nd reimplementation of
6262 quasiquote is enable matching of quasiquoted patterns, using Optima or
6264 (license license:expat))))
6266 (define-public cl-fare-quasiquote
6267 (sbcl-package->cl-source-package sbcl-fare-quasiquote))
6269 (define-public sbcl-fare-quasiquote-optima
6271 (inherit sbcl-fare-quasiquote)
6272 (name "sbcl-fare-quasiquote-optima")
6274 `(("optima" ,sbcl-optima)
6275 ("fare-quasiquote" ,sbcl-fare-quasiquote)))
6278 (modify-phases %standard-phases
6279 (add-after 'unpack 'patch-requirement
6281 (substitute* "fare-quasiquote-optima.asd"
6282 (("\\(:version \"optima\" \"1\\.0\"\\)")
6286 (define-public cl-fare-quasiquote-optima
6287 (sbcl-package->cl-source-package sbcl-fare-quasiquote-optima))
6289 (define-public sbcl-fare-quasiquote-readtable
6291 (inherit sbcl-fare-quasiquote)
6292 (name "sbcl-fare-quasiquote-readtable")
6294 `(("fare-quasiquote" ,sbcl-fare-quasiquote)
6295 ("named-readtables" ,sbcl-named-readtables)))
6296 (description "The main purpose of this n+2nd reimplementation of
6297 quasiquote is enable matching of quasiquoted patterns, using Optima or
6300 This package uses fare-quasiquote with named-readtable.")))
6302 (define-public cl-fare-quasiquote-readtable
6303 (sbcl-package->cl-source-package sbcl-fare-quasiquote-readtable))
6305 (define-public sbcl-fare-quasiquote-extras
6307 (inherit sbcl-fare-quasiquote)
6308 (name "sbcl-fare-quasiquote-extras")
6309 (build-system asdf-build-system/sbcl)
6311 `(("fare-quasiquote-optima" ,sbcl-fare-quasiquote-optima)
6312 ("fare-quasiquote-readtable" ,sbcl-fare-quasiquote-readtable)))
6315 (modify-phases %standard-phases
6317 (lambda* (#:key outputs #:allow-other-keys)
6318 (let* ((out (assoc-ref outputs "out"))
6319 (lib (string-append out "/lib/" (%lisp-type))))
6321 (install-file "fare-quasiquote-extras.asd" lib)
6323 (string-append lib "/fare-quasiquote-extras.asd"))
6325 (description "This library combines @code{fare-quasiquote-readtable} and
6326 @code{fare-quasiquote-optima}.")))
6328 (define-public cl-fare-quasiquote-extras
6330 (inherit cl-fare-quasiquote)
6331 (name "cl-fare-quasiquote-extras")
6332 (build-system asdf-build-system/source)
6334 `(("fare-quasiquote" ,cl-fare-quasiquote)
6335 ("fare-quasiquote-optima" ,cl-fare-quasiquote-optima)
6336 ("fare-quasiquote-readtable" ,cl-fare-quasiquote-readtable)))
6337 (description "This library combines @code{fare-quasiquote-readtable} and
6338 @code{fare-quasiquote-optima}.")))
6340 (define-public sbcl-trivia.level0
6341 (let ((commit "37698b47a14c2007630468de7a993694ef7bd475")
6344 (name "sbcl-trivia.level0")
6345 (build-system asdf-build-system/sbcl)
6346 (version (git-version "0.0.0" revision commit))
6347 (home-page "https://github.com/guicho271828/trivia")
6354 (file-name (git-file-name name version))
6357 "0rsbwbw3ipxxgr6zzhci12nilq8zky475kmhz1rcxy4q8a85vn72"))))
6359 `(("alexandria" ,sbcl-alexandria)))
6360 (synopsis "Pattern matching in Common Lisp")
6361 (description "Trivia is a pattern matching compiler that is compatible
6362 with Optima, another pattern matching library for Common Lisp. It is meant to
6363 be faster and more extensible than Optima.")
6364 (license license:llgpl))))
6366 (define-public sbcl-trivia.level1
6368 (inherit sbcl-trivia.level0)
6369 (name "sbcl-trivia.level1")
6371 `(("trivia.level0" ,sbcl-trivia.level0)))
6372 (description "Trivia is a pattern matching compiler that is compatible
6373 with Optima, another pattern matching library for Common Lisp. It is meant to
6374 be faster and more extensible than Optima.
6376 This system contains the core patterns of Trivia.")))
6378 (define-public sbcl-trivia.level2
6380 (inherit sbcl-trivia.level0)
6381 (name "sbcl-trivia.level2")
6383 `(("trivia.level1" ,sbcl-trivia.level1)
6384 ("lisp-namespace" ,sbcl-lisp-namespace)
6385 ("trivial-cltl2" ,sbcl-trivial-cltl2)
6386 ("closer-mop" ,sbcl-closer-mop)))
6387 (description "Trivia is a pattern matching compiler that is compatible
6388 with Optima, another pattern matching library for Common Lisp. It is meant to
6389 be faster and more extensible than Optima.
6391 This system contains a non-optimized pattern matcher compatible with Optima,
6392 with extensible optimizer interface.")))
6394 (define-public sbcl-trivia.trivial
6396 (inherit sbcl-trivia.level0)
6397 (name "sbcl-trivia.trivial")
6399 `(("trivia.level2" ,sbcl-trivia.level2)))
6400 (description "Trivia is a pattern matching compiler that is compatible
6401 with Optima, another pattern matching library for Common Lisp. It is meant to
6402 be faster and more extensible than Optima.
6404 This system contains the base level system of Trivia with a trivial optimizer.")))
6406 (define-public sbcl-trivia.balland2006
6408 (inherit sbcl-trivia.level0)
6409 (name "sbcl-trivia.balland2006")
6411 `(("trivia.trivial" ,sbcl-trivia.trivial)
6412 ("iterate" ,sbcl-iterate)
6413 ("type-i" ,sbcl-type-i)
6414 ("alexandria" ,sbcl-alexandria)))
6416 ;; Tests are done in trivia itself.
6418 (description "Trivia is a pattern matching compiler that is compatible
6419 with Optima, another pattern matching library for Common Lisp. It is meant to
6420 be faster and more extensible than Optima.
6422 This system contains the base level system of Trivia with a trivial optimizer.")))
6424 (define-public sbcl-trivia.ppcre
6426 (inherit sbcl-trivia.level0)
6427 (name "sbcl-trivia.ppcre")
6429 `(("trivia.trivial" ,sbcl-trivia.trivial)
6430 ("cl-ppcre" ,sbcl-cl-ppcre)))
6431 (description "Trivia is a pattern matching compiler that is compatible
6432 with Optima, another pattern matching library for Common Lisp. It is meant to
6433 be faster and more extensible than Optima.
6435 This system contains the PPCRE extension.")))
6437 (define-public sbcl-trivia.quasiquote
6439 (inherit sbcl-trivia.level0)
6440 (name "sbcl-trivia.quasiquote")
6442 `(("trivia.trivial" ,sbcl-trivia.trivial)
6443 ("fare-quasiquote" ,sbcl-fare-quasiquote)
6444 ("fare-quasiquote-readtable" ,sbcl-fare-quasiquote-readtable)))
6445 (description "Trivia is a pattern matching compiler that is compatible
6446 with Optima, another pattern matching library for Common Lisp. It is meant to
6447 be faster and more extensible than Optima.
6449 This system contains the fare-quasiquote extension.")))
6451 (define-public sbcl-trivia.cffi
6453 (inherit sbcl-trivia.level0)
6454 (name "sbcl-trivia.cffi")
6456 `(("cffi" ,sbcl-cffi)
6457 ("trivia.trivial" ,sbcl-trivia.trivial)))
6458 (description "Trivia is a pattern matching compiler that is compatible
6459 with Optima, another pattern matching library for Common Lisp. It is meant to
6460 be faster and more extensible than Optima.
6462 This system contains the CFFI foreign slot access extension.")))
6464 (define-public sbcl-trivia
6466 (inherit sbcl-trivia.level0)
6467 (name "sbcl-trivia")
6469 `(("trivia.balland2006" ,sbcl-trivia.balland2006)))
6471 `(("fiveam" ,sbcl-fiveam)
6472 ("trivia.ppcre" ,sbcl-trivia.ppcre)
6473 ("trivia.quasiquote" ,sbcl-trivia.quasiquote)
6474 ("trivia.cffi" ,sbcl-trivia.cffi)
6475 ("optima" ,sbcl-optima)))
6477 `(#:test-asd-file "trivia.test.asd"))
6478 (description "Trivia is a pattern matching compiler that is compatible
6479 with Optima, another pattern matching library for Common Lisp. It is meant to
6480 be faster and more extensible than Optima.")))
6482 (define-public cl-trivia
6483 (sbcl-package->cl-source-package sbcl-trivia))
6485 (define-public sbcl-mk-string-metrics
6487 (name "sbcl-mk-string-metrics")
6489 (home-page "https://github.com/cbaggers/mk-string-metrics/")
6496 (base32 "0bg0bv2mfd4k0g3x72x563hvmrx18xavaffr6xk5rh4if5j7kcf6"))
6497 (file-name (git-file-name name version))))
6498 (build-system asdf-build-system/sbcl)
6499 (synopsis "Calculate various string metrics efficiently in Common Lisp")
6500 (description "This library implements efficient algorithms that calculate
6501 various string metrics in Common Lisp:
6504 @item Damerau-Levenshtein distance
6505 @item Hamming distance
6506 @item Jaccard similarity coefficient
6508 @item Jaro-Winkler distance
6509 @item Levenshtein distance
6510 @item Normalized Damerau-Levenshtein distance
6511 @item Normalized Levenshtein distance
6512 @item Overlap coefficient
6514 (license license:x11)))
6516 (define-public cl-mk-string-metrics
6517 (sbcl-package->cl-source-package sbcl-mk-string-metrics))
6519 (define-public sbcl-cl-str
6521 (name "sbcl-cl-str")
6523 (home-page "https://github.com/vindarel/cl-str")
6530 (base32 "1jyza2jhn7w6fl4w87pv0m87z5ia48m6dqw12k0mdh7l3mgjq839"))
6531 (file-name (git-file-name name version))))
6532 (build-system asdf-build-system/sbcl)
6534 `(("cl-ppcre" ,sbcl-cl-ppcre)
6535 ("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)
6536 ("cl-change-case" ,sbcl-cl-change-case)))
6538 `(("prove" ,sbcl-prove)
6539 ("prove-asdf" ,sbcl-prove-asdf)))
6541 `(#:asd-file "str.asd"
6542 #:asd-system-name "str"
6543 #:test-asd-file "str.test.asd"))
6544 (synopsis "Modern, consistent and terse Common Lisp string manipulation library")
6545 (description "A modern and consistent Common Lisp string manipulation
6546 library that focuses on modernity, simplicity and discoverability:
6547 @code{(str:trim s)} instead of @code{(string-trim '(#\\Space ...) s)}), or
6548 @code{str:concat strings} instead of an unusual format construct; one
6549 discoverable library instead of many; consistency and composability, where
6550 @code{s} is always the last argument, which makes it easier to feed pipes and
6552 (license license:expat)))
6554 (define-public cl-str
6555 (sbcl-package->cl-source-package sbcl-cl-str))
6557 (define-public sbcl-cl-xmlspam
6558 (let ((commit "ea06abcca2a73a9779bcfb09081e56665f94e22a"))
6560 (name "sbcl-cl-xmlspam")
6561 (build-system asdf-build-system/sbcl)
6562 (version (git-version "0.0.0" "1" commit))
6563 (home-page "https://github.com/rogpeppe/cl-xmlspam")
6570 (file-name (string-append name "-" version))
6573 "0w4rqvrgdgk3fwfq3kx4r7wwdr2bv3b6n3bdqwsiriw9psqzpz2s"))))
6575 `(("cxml" ,sbcl-cxml)
6576 ("cl-ppcre" ,sbcl-cl-ppcre)))
6577 (synopsis "Concise, regexp-like pattern matching on streaming XML for Common Lisp")
6578 (description "CXML does an excellent job at parsing XML elements, but what
6579 do you do when you have a XML file that's larger than you want to fit in
6580 memory, and you want to extract some information from it? Writing code to deal
6581 with SAX events, or even using Klacks, quickly becomes tedious.
6582 @code{cl-xmlspam} (for XML Stream PAttern Matcher) is designed to make it easy
6583 to write code that mirrors the structure of the XML that it's parsing. It
6584 also makes it easy to shift paradigms when necessary - the usual Lisp control
6585 constructs can be used interchangeably with pattern matching, and the full
6586 power of CXML is available when necessary.")
6587 (license license:bsd-3))))
6589 ;; TODO: dbus uses ASDF's package-inferred-system which is not supported by
6590 ;; asdf-build-system/sbcl as of 2019-08-02. We should fix
6591 ;; asdf-build-system/sbcl.
6592 (define-public cl-dbus
6593 (let ((commit "24b452df3a45ca5dc95015500f34baad175c981a")
6597 (build-system asdf-build-system/source)
6598 (version (git-version "20190408" revision commit))
6599 (home-page "https://github.com/death/dbus")
6606 (file-name (git-file-name name version))
6609 "0fw2q866yddbf23nk9pxphm9gsasx35vjyss82xzvndnjmzlqfl5"))))
6610 ;; Inputs must be propagated or else packages depending on this won't
6611 ;; have the necessary packages.
6613 `(("alexandria" ,sbcl-alexandria)
6614 ("trivial-garbage" ,sbcl-trivial-garbage)
6615 ("babel" ,sbcl-babel)
6616 ("iolib" ,sbcl-iolib)
6617 ("ieee-floats" ,sbcl-ieee-floats)
6618 ("flexi-streams" ,sbcl-flexi-streams)
6619 ("cl-xmlspam" ,sbcl-cl-xmlspam)
6620 ("ironclad" ,sbcl-ironclad)))
6621 (synopsis "D-Bus client library for Common Lisp")
6622 (description "This is a Common Lisp library that publishes D-Bus
6623 objects as well as send and notify other objects connected to a bus.")
6624 (license license:bsd-2))))
6626 (define-public sbcl-cl-hooks
6627 (let ((commit "5b638083f3b4f1221a52631d9c8a0a265565cac7")
6630 (name "sbcl-cl-hooks")
6631 (build-system asdf-build-system/sbcl)
6632 (version (git-version "0.2.1" revision commit))
6633 (home-page "https://github.com/scymtym/architecture.hooks")
6640 (file-name (git-file-name name version))
6643 "0bg3l0a28lw5gqqjp6p6b5nhwqk46sgkb7184w5qbfngw1hk8x9y"))))
6645 `(("alexandria" ,sbcl-alexandria)
6646 ("let-plus" ,sbcl-let-plus)
6647 ("trivial-garbage" ,sbcl-trivial-garbage)
6648 ("closer-mop" ,sbcl-closer-mop)))
6650 `(("fiveam" ,sbcl-fiveam)))
6651 (synopsis "Hooks extension point mechanism (as in Emacs) for Common Lisp")
6652 (description "A hook, in the present context, is a certain kind of
6653 extension point in a program that allows interleaving the execution of
6654 arbitrary code with the execution of a the program without introducing any
6655 coupling between the two. Hooks are used extensively in the extensible editor
6658 In the Common LISP Object System (CLOS), a similar kind of extensibility is
6659 possible using the flexible multi-method dispatch mechanism. It may even seem
6660 that the concept of hooks does not provide any benefits over the possibilities
6661 of CLOS. However, there are some differences:
6665 @item There can be only one method for each combination of specializers and
6666 qualifiers. As a result this kind of extension point cannot be used by
6667 multiple extensions independently.
6668 @item Removing code previously attached via a @code{:before}, @code{:after} or
6669 @code{:around} method can be cumbersome.
6670 @item There could be other or even multiple extension points besides @code{:before}
6671 and @code{:after} in a single method.
6672 @item Attaching codes to individual objects using eql specializers can be
6674 @item Introspection of code attached a particular extension point is
6675 cumbersome since this requires enumerating and inspecting the methods of a
6679 This library tries to complement some of these weaknesses of method-based
6680 extension-points via the concept of hooks.")
6681 (license license:llgpl))))
6683 (define-public cl-hooks
6684 (sbcl-package->cl-source-package sbcl-cl-hooks))
6686 (define-public ecl-cl-hooks
6687 (sbcl-package->ecl-package sbcl-cl-hooks))
6689 (define-public sbcl-s-sysdeps
6690 ;; No release since 2013.
6691 (let ((commit "9aa23bbdceb24bcdbe0e7c39fa1901858f823106")
6694 (name "sbcl-s-sysdeps")
6695 (build-system asdf-build-system/sbcl)
6696 (version (git-version "1" revision commit))
6697 (home-page "https://github.com/svenvc/s-sysdeps")
6704 (file-name (git-file-name name version))
6707 "1fh8r7kf8s3hvqdg6b71b8p7w3v2kkga9bw8j3qqdxhzr6anpm0b"))))
6709 `(("bordeaux-threads" ,sbcl-bordeaux-threads)
6710 ("usocket" ,sbcl-usocket)
6711 ("usocket-server" ,sbcl-usocket-server)))
6712 (synopsis "Common Lisp abstraction layer over platform dependent functionality")
6713 (description "@code{s-sysdeps} is an abstraction layer over platform
6714 dependent functionality. This simple package is used as a building block in a
6715 number of other open source projects.
6717 @code{s-sysdeps} abstracts:
6720 @item managing processes,
6721 @item implementing a standard TCP/IP server,
6722 @item opening a client TCP/IP socket stream,
6723 @item working with process locks.
6725 (license license:llgpl))))
6727 (define-public cl-s-sysdeps
6728 (sbcl-package->cl-source-package sbcl-s-sysdeps))
6730 (define-public ecl-s-sysdeps
6731 (sbcl-package->ecl-package sbcl-s-sysdeps))
6733 (define-public sbcl-cl-prevalence
6734 (let ((commit "5a76be036092ed6c18cb695a9e03bce87e21b840")
6737 (name "sbcl-cl-prevalence")
6738 (build-system asdf-build-system/sbcl)
6739 (version (git-version "5" revision commit))
6740 (home-page "https://github.com/40ants/cl-prevalence")
6747 (file-name (git-file-name name version))
6750 "050h6hwv8f16b5v6fzba8zmih92hgaaq27i2x9wv1iib41gbia3r"))))
6752 `(("s-sysdeps" ,sbcl-s-sysdeps)
6753 ("s-xml" ,sbcl-s-xml)))
6755 `(("fiveam" ,sbcl-fiveam)))
6756 (synopsis "Implementation of object prevalence for Common Lisp")
6757 (description "This Common Lisp library implements object prevalence (see
6758 @url{https://en.wikipedia.org/wiki/System_prevalence}). It allows
6759 for (de)serializing to and from s-exps as well as XML. Serialization of arbitrary
6760 classes and cyclic data structures are supported.")
6761 (license license:llgpl))))
6763 (define-public cl-prevalence
6764 (sbcl-package->cl-source-package sbcl-cl-prevalence))
6766 (define-public ecl-cl-prevalence
6767 (sbcl-package->ecl-package sbcl-cl-prevalence))
6769 (define-public sbcl-series
6770 (let ((commit "da9061b336119d1e5214aff9117171d494d5a58a")
6773 (name "sbcl-series")
6774 (version (git-version "2.2.11" revision commit))
6779 (url "git://git.code.sf.net/p/series/series")
6781 (file-name (git-file-name name version))
6784 "07hk2lhfx42zk018pxqvn4gs77vd4n4g8m4xxbqaxgca76mifwfw"))))
6785 (build-system asdf-build-system/sbcl)
6787 ;; Disable the tests, they are apparently buggy and I didn't find
6788 ;; a simple way to make them run and pass.
6790 (synopsis "Series data structure for Common Lisp")
6792 "This Common Lisp library provides a series data structure much like
6793 a sequence, with similar kinds of operations. The difference is that in many
6794 situations, operations on series may be composed functionally and yet execute
6795 iteratively, without the need to construct intermediate series values
6796 explicitly. In this manner, series provide both the clarity of a functional
6797 programming style and the efficiency of an iterative programming style.")
6798 (home-page "http://series.sourceforge.net/")
6799 (license license:expat))))
6801 (define-public cl-series
6802 (sbcl-package->cl-source-package sbcl-series))
6804 (define-public ecl-series
6805 (sbcl-package->ecl-package sbcl-series))
6807 (define-public sbcl-periods
6808 (let ((commit "983d4a57325db3c8def942f163133cec5391ec28")
6811 (name "sbcl-periods")
6812 (version (git-version "0.0.2" revision commit))
6817 (url "https://github.com/jwiegley/periods")
6819 (file-name (git-file-name name version))
6822 "0z30jr3lxz3cmi019fsl4lgcgwf0yqpn95v9zkkkwgymdrkd4lga"))))
6823 (build-system asdf-build-system/sbcl)
6825 `(("local-time" ,sbcl-local-time)))
6826 (synopsis "Common Lisp library for manipulating date/time objects")
6828 "Periods is a Common Lisp library providing a set of utilities for
6829 manipulating times, distances between times, and both contiguous and
6830 discontiguous ranges of time.")
6831 (home-page "https://github.com/jwiegley/periods")
6832 (license license:bsd-3))))
6834 (define-public cl-periods
6835 (sbcl-package->cl-source-package sbcl-periods))
6837 (define-public ecl-periods
6838 (sbcl-package->ecl-package sbcl-periods))
6840 (define-public sbcl-periods-series
6842 (inherit sbcl-periods)
6843 (name "sbcl-periods-series")
6845 `(("periods" ,sbcl-periods)
6846 ("series" ,sbcl-series)))
6848 '(#:asd-file "periods-series.asd"
6849 #:asd-system-name "periods-series"))
6851 "Periods-series is an extension of the periods Common Lisp library
6852 providing functions compatible with the series Common Lisp library.")))
6854 (define-public cl-periods-series
6855 (sbcl-package->cl-source-package sbcl-periods-series))
6857 (define-public ecl-periods-series
6858 (sbcl-package->ecl-package sbcl-periods-series))
6860 (define-public sbcl-metatilities-base
6861 (let ((commit "6eaa9e3ff0939a93a92109dd0fcd218de85417d5")
6864 (name "sbcl-metatilities-base")
6865 (version (git-version "0.6.6" revision commit))
6870 (url "https://github.com/gwkkwg/metatilities-base")
6872 (file-name (git-file-name name version))
6875 "0xpa86pdzlnf4v5g64j3ifaplx71sx2ha8b7vvakswi652679ma0"))))
6876 (build-system asdf-build-system/sbcl)
6878 `(("lift" ,sbcl-lift)))
6879 (synopsis "Core of the metatilities Common Lisp library")
6881 "Metatilities-base is the core of the metatilities Common Lisp library
6882 which implements a set of utilities.")
6883 (home-page "https://common-lisp.net/project/metatilities-base/")
6884 (license license:expat))))
6886 (define-public cl-metatilities-base
6887 (sbcl-package->cl-source-package sbcl-metatilities-base))
6889 (define-public ecl-metatilities-base
6890 (sbcl-package->ecl-package sbcl-metatilities-base))
6892 (define-public sbcl-cl-containers
6893 (let ((commit "3d1df53c22403121bffb5d553cf7acb1503850e7")
6896 (name "sbcl-cl-containers")
6897 (version (git-version "0.12.1" revision commit))
6902 (url "https://github.com/gwkkwg/cl-containers")
6904 (file-name (git-file-name name version))
6907 "18s6jfq11n8nv9k4biz32pm1s7y9zl054ry1gmdbcf39nisy377y"))))
6908 (build-system asdf-build-system/sbcl)
6910 `(("lift" ,sbcl-lift)))
6912 `(("metatilities-base" ,sbcl-metatilities-base)))
6915 (modify-phases %standard-phases
6916 (add-after 'unpack 'relax-version-checks
6918 (substitute* "cl-containers.asd"
6919 (("\\(:version \"metatilities-base\" \"0\\.6\\.6\"\\)")
6920 "\"metatilities-base\""))
6921 (substitute* "cl-containers-test.asd"
6922 (("\\(:version \"lift\" \"1\\.7\\.0\"\\)")
6925 (synopsis "Container library for Common Lisp")
6927 "Common Lisp ships with a set of powerful built in data structures
6928 including the venerable list, full featured arrays, and hash-tables.
6929 CL-containers enhances and builds on these structures by adding containers
6930 that are not available in native Lisp (for example: binary search trees,
6931 red-black trees, sparse arrays and so on), and by providing a standard
6932 interface so that they are simpler to use and so that changing design
6933 decisions becomes significantly easier.")
6934 (home-page "https://common-lisp.net/project/cl-containers/")
6935 (license license:expat))))
6937 (define-public cl-containers
6938 (sbcl-package->cl-source-package sbcl-cl-containers))
6940 (define-public ecl-cl-containers
6941 (sbcl-package->ecl-package sbcl-cl-containers))
6943 (define-public sbcl-xlunit
6944 (let ((commit "3805d34b1d8dc77f7e0ee527a2490194292dd0fc")
6947 (name "sbcl-xlunit")
6948 (version (git-version "0.6.3" revision commit))
6953 (url "http://git.kpe.io/xlunit.git")
6955 (file-name (git-file-name name version))
6958 "0argfmp9nghs4sihyj3f8ch9qfib2b7ll07v5m9ziajgzsfl5xw3"))))
6959 (build-system asdf-build-system/sbcl)
6962 (modify-phases %standard-phases
6963 (add-after 'unpack 'fix-tests
6965 (substitute* "xlunit.asd"
6968 (synopsis "Unit testing package for Common Lisp")
6970 "The XLUnit package is a toolkit for building test suites. It is based
6971 on the XPTest package by Craig Brozensky and the JUnit package by Kent Beck.")
6972 (home-page "http://quickdocs.org/xlunit/")
6973 (license license:bsd-3))))
6975 (define-public cl-xlunit
6976 (sbcl-package->cl-source-package sbcl-xlunit))
6978 (define-public ecl-xlunit
6979 (sbcl-package->ecl-package sbcl-xlunit))
6981 (define-public sbcl-fprog
6982 (let ((commit "7016d1a98215f82605d1c158e7a16504ca1f4636")
6986 (version (git-version "1.0.0" revision commit))
6991 (url "https://github.com/jwiegley/cambl")
6993 (file-name (git-file-name name version))
6996 "103mry04j2k9vznsxm7wcvccgxkil92cdrv52miwcmxl8daa4jiz"))))
6997 (build-system asdf-build-system/sbcl)
6998 (synopsis "Functional programming utilities for Common Lisp")
7000 "@code{fprog} is a Common Lisp library allowing iteration over
7001 immutable lists sharing identical sublists.")
7002 (home-page "https://github.com/jwiegley/cambl")
7003 (license license:bsd-3))))
7005 (define-public cl-fprog
7006 (sbcl-package->cl-source-package sbcl-fprog))
7008 (define-public ecl-fprog
7009 (sbcl-package->ecl-package sbcl-fprog))
7011 (define-public sbcl-cambl
7012 (let ((commit "7016d1a98215f82605d1c158e7a16504ca1f4636")
7015 (inherit sbcl-fprog)
7017 (version (git-version "4.0.0" revision commit))
7019 `(("xlunit" ,sbcl-xlunit)))
7021 `(("alexandria" ,sbcl-alexandria)
7022 ("cl-containers" ,sbcl-cl-containers)
7023 ("local-time" ,sbcl-local-time)
7024 ("periods" ,sbcl-periods)
7025 ("fprog" ,sbcl-fprog)))
7026 (synopsis "Commoditized amounts and balances for Common Lisp")
7028 "CAMBL is a Common Lisp library providing a convenient facility for
7029 working with commoditized values. It does not allow compound units (and so is
7030 not suited for scientific operations) but does work rather nicely for the
7031 purpose of financial calculations."))))
7033 (define-public cl-cambl
7034 (sbcl-package->cl-source-package sbcl-cambl))
7036 (define-public ecl-cambl
7037 (sbcl-package->ecl-package sbcl-cambl))
7039 (define-public sbcl-cl-ledger
7040 (let ((commit "08e0be41795e804cd36142e51756ad0b1caa377b")
7043 (name "sbcl-cl-ledger")
7044 (version (git-version "4.0.0" revision commit))
7049 (url "https://github.com/ledger/cl-ledger")
7051 (file-name (git-file-name name version))
7054 "1via0qf6wjcyxnfbmfxjvms0ik9j8rqbifgpmnhrzvkhrq9pv8h1"))))
7055 (build-system asdf-build-system/sbcl)
7057 `(("cambl" ,sbcl-cambl)
7058 ("cl-ppcre" ,sbcl-cl-ppcre)
7059 ("local-time" ,sbcl-local-time)
7060 ("periods-series" ,sbcl-periods-series)))
7063 (modify-phases %standard-phases
7064 (add-after 'unpack 'fix-system-definition
7066 (substitute* "cl-ledger.asd"
7067 ((" :build-operation program-op") "")
7068 ((" :build-pathname \"cl-ledger\"") "")
7069 ((" :entry-point \"ledger::main\"") ""))
7071 (synopsis "Common Lisp port of the Ledger accounting system")
7073 "CL-Ledger is a Common Lisp port of the Ledger double-entry accounting
7075 (home-page "https://github.com/ledger/cl-ledger")
7076 (license license:bsd-3))))
7078 (define-public cl-ledger
7079 (sbcl-package->cl-source-package sbcl-cl-ledger))
7081 (define-public ecl-cl-ledger
7082 (sbcl-package->ecl-package sbcl-cl-ledger))
7084 (define-public sbcl-bst
7085 (let ((commit "34f9c7e8e0a9f2c952fe310ab36cb630d5d9c15a")
7089 (version (git-version "1.1" revision commit))
7094 (url "https://github.com/glv2/bst")
7096 (file-name (git-file-name name version))
7099 "1amxns7hvvh4arwbh8ciwfzplg127vh37dnbamv1m1kmmnmihfc8"))))
7100 (build-system asdf-build-system/sbcl)
7102 `(("alexandria" ,sbcl-alexandria)
7103 ("fiveam" ,sbcl-fiveam)))
7104 (synopsis "Binary search tree for Common Lisp")
7106 "BST is a Common Lisp library for working with binary search trees that
7107 can contain any kind of values.")
7108 (home-page "https://github.com/glv2/bst")
7109 (license license:gpl3))))
7111 (define-public cl-bst
7112 (sbcl-package->cl-source-package sbcl-bst))
7114 (define-public ecl-bst
7115 (sbcl-package->ecl-package sbcl-bst))
7117 (define-public sbcl-cl-octet-streams
7119 (name "sbcl-cl-octet-streams")
7125 (url "https://github.com/glv2/cl-octet-streams")
7126 (commit (string-append "v" version))))
7127 (file-name (git-file-name name version))
7130 "1d7mn6ydv0j2x4r7clpc9ijjwrnfpxmvhifv8n5j7jh7s744sf8d"))))
7131 (build-system asdf-build-system/sbcl)
7133 `(("fiveam" ,sbcl-fiveam)))
7135 `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
7136 (synopsis "In-memory octet streams for Common Lisp")
7138 "CL-octet-streams is a library implementing in-memory octet
7139 streams for Common Lisp. It was inspired by the trivial-octet-streams and
7140 cl-plumbing libraries.")
7141 (home-page "https://github.com/glv2/cl-octet-streams")
7142 (license license:gpl3+)))
7144 (define-public cl-octet-streams
7145 (sbcl-package->cl-source-package sbcl-cl-octet-streams))
7147 (define-public ecl-cl-octet-streams
7148 (sbcl-package->ecl-package sbcl-cl-octet-streams))
7150 (define-public sbcl-lzlib
7151 (let ((commit "0de1db7129fef9a58a059d35a2fa2ecfc5b47b47")
7155 (version (git-version "1.0" revision commit))
7160 (url "https://github.com/glv2/cl-lzlib")
7162 (file-name (git-file-name name version))
7165 "12ny7vj52fgnd8hb8fc8mry92vq4c1x72x2350191m4476j95clz"))))
7166 (build-system asdf-build-system/sbcl)
7168 `(("fiveam" ,sbcl-fiveam)))
7170 `(("cffi" ,sbcl-cffi)
7171 ("cl-octet-streams" ,sbcl-cl-octet-streams)
7175 (modify-phases %standard-phases
7176 (add-after 'unpack 'fix-paths
7177 (lambda* (#:key inputs #:allow-other-keys)
7178 (substitute* "src/lzlib.lisp"
7180 (string-append (assoc-ref inputs "lzlib") "/lib/liblz.so")))
7182 (synopsis "Common Lisp library for lzip (de)compression")
7184 "This Common Lisp library provides functions for lzip (LZMA)
7185 compression/decompression using bindings to the lzlib C library.")
7186 (home-page "https://github.com/glv2/cl-lzlib")
7187 (license license:gpl3+))))
7189 (define-public cl-lzlib
7190 (sbcl-package->cl-source-package sbcl-lzlib))
7192 (define-public ecl-lzlib
7193 (sbcl-package->ecl-package sbcl-lzlib))
7195 (define-public sbcl-chanl
7196 (let ((commit "56e90a126c78b39bb621a01585e8d3b985238e8c")
7200 (version (git-version "0.4.1" revision commit))
7205 (url "https://github.com/zkat/chanl")
7207 (file-name (git-file-name name version))
7210 "0b1cf6c12qx5cy1fw2z42jgh566rp3l8nv5qf0qqc569s7bgmrh4"))))
7211 (build-system asdf-build-system/sbcl)
7213 `(("fiveam" ,sbcl-fiveam)))
7215 `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
7216 (synopsis "Portable channel-based concurrency for Common Lisp")
7217 (description "Common Lisp library for channel-based concurrency. In
7218 a nutshell, you create various threads sequentially executing tasks you need
7219 done, and use channel objects to communicate and synchronize the state of these
7221 (home-page "https://github.com/zkat/chanl")
7222 (license (list license:expat license:bsd-3)))))
7224 (define-public cl-chanl
7225 (sbcl-package->cl-source-package sbcl-chanl))
7227 (define-public ecl-chanl
7228 (sbcl-package->ecl-package sbcl-chanl))
7230 (define-public sbcl-cl-store
7231 (let ((commit "c787337a16ea8cf8a06227f35933a4ec774746b3")
7234 (name "sbcl-cl-store")
7235 (version (git-version "0.8.11" revision commit))
7240 (url "https://github.com/skypher/cl-store")
7242 (file-name (git-file-name name version))
7245 "194srkg8nrym19c6i7zbnkzshc1qhqa82m53qnkirz9fw928bqxr"))))
7246 (build-system asdf-build-system/sbcl)
7249 (synopsis "Common Lisp library to serialize data")
7251 "CL-STORE is a portable serialization package which should give you the
7252 ability to store all Common Lisp data types into streams.")
7253 (home-page "https://www.common-lisp.net/project/cl-store/")
7254 (license license:expat))))
7256 (define-public cl-store
7257 (sbcl-package->cl-source-package sbcl-cl-store))
7259 (define-public ecl-cl-store
7260 (sbcl-package->ecl-package sbcl-cl-store))
7262 (define-public sbcl-cl-gobject-introspection
7263 (let ((commit "7b703e2384945ea0ac39d9b766de434a08d81560")
7266 (name "sbcl-cl-gobject-introspection")
7267 (version (git-version "0.3" revision commit))
7268 (home-page "https://github.com/andy128k/cl-gobject-introspection")
7275 (file-name (git-file-name name version))
7278 "1zcqd2qj14f6b38vys8gr89s6cijsp9r8j43xa8lynilwva7bwyh"))))
7279 (build-system asdf-build-system/sbcl)
7281 `(("alexandria" ,sbcl-alexandria)
7283 ("iterate" ,sbcl-iterate)
7284 ("trivial-garbage" ,sbcl-trivial-garbage)
7286 ("gobject-introspection" ,gobject-introspection)))
7288 `(("fiveam" ,sbcl-fiveam)))
7290 ;; TODO: Tests fail, see
7291 ;; https://github.com/andy128k/cl-gobject-introspection/issues/70.
7294 (modify-phases %standard-phases
7295 (add-after (quote unpack) (quote fix-paths)
7296 (lambda* (#:key inputs #:allow-other-keys)
7297 (substitute* "src/init.lisp"
7298 (("libgobject-2\\.0\\.so")
7299 (string-append (assoc-ref inputs "glib") "/lib/libgobject-2.0.so"))
7300 (("libgirepository-1\\.0\\.so")
7301 (string-append (assoc-ref inputs "gobject-introspection")
7302 "/lib/libgirepository-1.0.so")))
7304 (synopsis "Common Lisp bindings to GObject Introspection")
7306 "This library is a bridge between Common Lisp and GObject
7307 Introspection, which enables Common Lisp programs to access the full interface
7308 of C+GObject libraries without the need of writing dedicated bindings.")
7309 (license (list license:bsd-3
7310 ;; Tests are under a different license.
7313 (define-public cl-gobject-introspection
7314 (sbcl-package->cl-source-package sbcl-cl-gobject-introspection))
7316 (define-public sbcl-string-case
7317 (let ((commit "718c761e33749e297cd2809c7ba3ade1985c49f7")
7320 (name "sbcl-string-case")
7321 (version (git-version "0.0.2" revision commit))
7322 (home-page "https://github.com/pkhuong/string-case")
7329 (file-name (git-file-name name version))
7332 "1n5i3yh0h5s636rcnwn7jwqy3rjflikra04lymimhpcshhjsk0md"))))
7333 (build-system asdf-build-system/sbcl)
7334 (synopsis "Efficient string= case in Common Lisp")
7336 "@code{string-case} is a Common Lisp macro that generates specialised decision
7337 trees to dispatch on string equality.")
7338 (license license:bsd-3))))
7340 (define-public cl-string-case
7341 (sbcl-package->cl-source-package sbcl-string-case))
7343 (define-public ecl-string-case
7344 (sbcl-package->ecl-package sbcl-string-case))
7346 (define-public sbcl-global-vars
7347 (let ((commit "c749f32c9b606a1457daa47d59630708ac0c266e")
7350 (name "sbcl-global-vars")
7351 (version (git-version "1.0.0" revision commit))
7352 (home-page "https://github.com/lmj/global-vars")
7359 (file-name (git-file-name name version))
7362 "06m3xc8l3pgsapl8fvsi9wf6y46zs75cp9zn7zh6dc65v4s5wz3d"))))
7363 (build-system asdf-build-system/sbcl)
7364 (synopsis "Efficient global variables in Common Lisp")
7366 "In Common Lisp, a special variable that is never dynamically bound
7367 typically serves as a stand-in for a global variable. The @code{global-vars}
7368 library provides true global variables that are implemented by some compilers.
7369 An attempt to rebind a global variable properly results in a compiler error.
7370 That is, a global variable cannot be dynamically bound.
7372 Global variables therefore allow us to communicate an intended usage that
7373 differs from special variables. Global variables are also more efficient than
7374 special variables, especially in the presence of threads.")
7375 (license license:expat))))
7377 (define-public cl-global-vars
7378 (sbcl-package->cl-source-package sbcl-global-vars))
7380 (define-public ecl-global-vars
7381 (sbcl-package->ecl-package sbcl-global-vars))
7383 (define-public sbcl-trivial-file-size
7384 (let ((commit "1c1d672a01a446ba0391dbb4ffc40be3b0476f23")
7387 (name "sbcl-trivial-file-size")
7388 (version (git-version "0.0.0" revision commit))
7389 (home-page "https://github.com/ruricolist/trivial-file-size")
7396 (file-name (git-file-name name version))
7399 "17pp86c9zs4y7i1sh7q9gbfw9iqv6655k7fz8qbj9ly1ypgxp4qs"))))
7400 (build-system asdf-build-system/sbcl)
7402 `(("fiveam" ,sbcl-fiveam)))
7403 (synopsis "Size of a file in bytes in Common Lisp")
7405 "The canonical way to determine the size of a file in bytes, using Common Lisp,
7406 is to open the file with an element type of (unsigned-byte 8) and then
7407 calculate the length of the stream. This is less than ideal. In most cases
7408 it is better to get the size of the file from its metadata, using a system
7411 This library exports a single function, file-size-in-octets. It returns the
7412 size of a file in bytes, using system calls when possible.")
7413 (license license:expat))))
7415 (define-public cl-trivial-file-size
7416 (sbcl-package->cl-source-package sbcl-trivial-file-size))
7418 (define-public ecl-trivial-file-size
7419 (sbcl-package->ecl-package sbcl-trivial-file-size))
7421 (define-public sbcl-trivial-macroexpand-all
7422 (let ((commit "933270ac7107477de1bc92c1fd641fe646a7a8a9")
7425 (name "sbcl-trivial-macroexpand-all")
7426 (version (git-version "0.0.0" revision commit))
7427 (home-page "https://github.com/cbaggers/trivial-macroexpand-all")
7434 (file-name (git-file-name name version))
7437 "191hnn4b5j4i3crydmlzbm231kj0h7l8zj6mzj69r1npbzkas4bd"))))
7438 (build-system asdf-build-system/sbcl)
7440 `(("fiveam" ,sbcl-fiveam)))
7441 (synopsis "Portable macroexpand-all for Common Lisp")
7443 "This library provides a macroexpand-all function that calls the
7444 implementation specific equivalent.")
7445 (license license:unlicense))))
7447 (define-public cl-trivial-macroexpand-all
7448 (sbcl-package->cl-source-package sbcl-trivial-macroexpand-all))
7450 (define-public ecl-trivial-macroexpand-all
7451 (sbcl-package->ecl-package sbcl-trivial-macroexpand-all))
7453 (define-public sbcl-serapeum
7454 (let ((commit "c5e352a9f04a84a93742193c01734f4fb31d9f82")
7457 (name "sbcl-serapeum")
7458 (version (git-version "0.0.0" revision commit))
7459 (home-page "https://github.com/ruricolist/serapeum")
7466 (file-name (git-file-name name version))
7469 "16767pxl766c15jznr4srcbp7cnxf8w9lkyaqpp5w5crqymw84nw"))))
7470 (build-system asdf-build-system/sbcl)
7472 `(("alexandria" ,sbcl-alexandria)
7473 ("trivia" ,sbcl-trivia)
7474 ("trivia.quasiquote" ,sbcl-trivia.quasiquote)
7475 ("split-sequence" ,sbcl-split-sequence)
7476 ("string-case" ,sbcl-string-case)
7477 ("parse-number" ,sbcl-parse-number)
7478 ("trivial-garbage" ,sbcl-trivial-garbage)
7479 ("bordeaux-threads" ,sbcl-bordeaux-threads)
7480 ("named-readtables" ,sbcl-named-readtables)
7481 ("fare-quasiquote-extras" ,sbcl-fare-quasiquote-extras)
7482 ("parse-declarations-1.0" ,sbcl-parse-declarations)
7483 ("global-vars" ,sbcl-global-vars)
7484 ("trivial-file-size" ,sbcl-trivial-file-size)
7485 ("trivial-macroexpand-all" ,sbcl-trivial-macroexpand-all)))
7487 `(("fiveam" ,sbcl-fiveam)
7488 ("local-time" ,sbcl-local-time)))
7491 (modify-phases %standard-phases
7492 (add-after 'unpack 'disable-failing-tests
7493 (lambda* (#:key inputs #:allow-other-keys)
7494 (substitute* "serapeum.asd"
7495 ;; Guix does not have Quicklisp, and probably never will.
7496 (("\\(:file \"quicklisp\"\\)") ""))
7498 (synopsis "Common Lisp utility library beyond Alexandria")
7500 "Serapeum is a conservative library of Common Lisp utilities. It is a
7501 supplement, not a competitor, to Alexandria.")
7502 (license license:expat))))
7504 (define-public cl-serapeum
7505 (sbcl-package->cl-source-package sbcl-serapeum))
7507 (define-public sbcl-arrows
7508 (let ((commit "df7cf0067e0132d9697ac8b1a4f1b9c88d4f5382")
7511 (name "sbcl-arrows")
7512 (version (git-version "0.2.0" revision commit))
7517 (url "https://gitlab.com/Harleqin/arrows.git")
7519 (file-name (git-file-name name version))
7522 "042k9vkssrqx9nhp14wdzm942zgdxvp35mba0p2syz98i75im2yy"))))
7523 (build-system asdf-build-system/sbcl)
7525 `(("hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
7526 (synopsis "Clojure-like arrow macros for Common Lisp")
7528 "This library implements the @code{->} and @code{->>} macros from
7529 Clojure, as well as several expansions on the idea.")
7530 (home-page "https://gitlab.com/Harleqin/arrows")
7531 (license license:public-domain))))
7533 (define-public cl-arrows
7534 (sbcl-package->cl-source-package sbcl-arrows))
7536 (define-public ecl-arrows
7537 (sbcl-package->ecl-package sbcl-arrows))
7539 (define-public sbcl-simple-parallel-tasks
7540 (let ((commit "db460f7a3f7bbfe2d3a2223ed21e162068d04dda")
7543 (name "sbcl-simple-parallel-tasks")
7544 (version (git-version "1.0" revision commit))
7549 (url "https://github.com/glv2/simple-parallel-tasks")
7551 (file-name (git-file-name name version))
7554 "0amw3qk23wnlyrsgzszs6rs7y4zvxv8dr03rnqhc60mnm8ds4dd5"))))
7555 (build-system asdf-build-system/sbcl)
7557 `(("fiveam" ,sbcl-fiveam)))
7559 `(("chanl" ,sbcl-chanl)))
7560 (synopsis "Common Lisp library to evaluate some forms in parallel")
7561 (description "This is a simple Common Lisp library to evaluate some
7562 forms in parallel.")
7563 (home-page "https://github.com/glv2/simple-parallel-tasks")
7564 (license license:gpl3))))
7566 (define-public cl-simple-parallel-tasks
7567 (sbcl-package->cl-source-package sbcl-simple-parallel-tasks))
7569 (define-public ecl-simple-parallel-tasks
7570 (sbcl-package->ecl-package sbcl-simple-parallel-tasks))
7572 (define-public sbcl-cl-heap
7574 (name "sbcl-cl-heap")
7579 (uri (string-append "https://common-lisp.net/project/cl-heap/releases/"
7580 "cl-heap_" version ".tar.gz"))
7583 "163hb07p2nxz126rpq3cj5dyala24n0by5i5786n2qcr1w0bak4i"))))
7584 (build-system asdf-build-system/sbcl)
7586 `(("xlunit" ,sbcl-xlunit)))
7588 `(#:test-asd-file "cl-heap-tests.asd"))
7589 (synopsis "Heap and priority queue data structures for Common Lisp")
7591 "CL-HEAP provides various implementations of heap data structures (a
7592 binary heap and a Fibonacci heap) as well as an efficient priority queue.")
7593 (home-page "https://common-lisp.net/project/cl-heap/")
7594 (license license:gpl3+)))
7596 (define-public cl-heap
7597 (sbcl-package->cl-source-package sbcl-cl-heap))
7599 (define-public ecl-cl-heap
7600 (sbcl-package->ecl-package sbcl-cl-heap))
7602 (define-public sbcl-curry-compose-reader-macros
7603 (let ((commit "beaa92dedf392726c042184bfd6149fa8d9e6ac2")
7606 (name "sbcl-curry-compose-reader-macros")
7607 (version (git-version "1.0.0" revision commit))
7613 (url "https://github.com/eschulte/curry-compose-reader-macros")
7615 (file-name (git-file-name name version))
7618 "0rv9bl8xrad5wfcg5zs1dazvnpmvqz6297lbn8bywsrcfnlf7h98"))))
7619 (build-system asdf-build-system/sbcl)
7621 `(("alexandria" ,sbcl-alexandria)
7622 ("named-readtables" ,sbcl-named-readtables)))
7623 (synopsis "Reader macros for partial application and composition")
7625 "This Common Lisp library provides reader macros for concise expression
7626 of function partial application and composition.")
7627 (home-page "https://eschulte.github.io/curry-compose-reader-macros/")
7628 (license license:public-domain))))
7630 (define-public cl-curry-compose-reader-macros
7631 (sbcl-package->cl-source-package sbcl-curry-compose-reader-macros))
7633 (define-public ecl-curry-compose-reader-macros
7634 (sbcl-package->ecl-package sbcl-curry-compose-reader-macros))
7636 (define-public sbcl-yason
7644 (url "https://github.com/phmarek/yason")
7645 (commit (string-append "v" version))))
7646 (file-name (git-file-name name version))
7649 "0479rbjgbj80jpk5bby18inlv1kfp771a82rlcq5psrz65qqa9bj"))))
7650 (build-system asdf-build-system/sbcl)
7652 `(("alexandria" ,sbcl-alexandria)
7653 ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
7654 (synopsis "Common Lisp JSON parser/encoder")
7656 "YASON is a Common Lisp library for encoding and decoding data in the
7657 JSON interchange format.")
7658 (home-page "https://github.com/phmarek/yason")
7659 (license license:bsd-3)))
7661 (define-public cl-yason
7662 (sbcl-package->cl-source-package sbcl-yason))
7664 (define-public ecl-yason
7665 (sbcl-package->ecl-package sbcl-yason))
7667 (define-public sbcl-stefil
7668 (let ((commit "0398548ec95dceb50fc2c2c03e5fb0ce49b86c7a")
7671 (name "sbcl-stefil")
7672 (version (git-version "0.1" revision commit))
7677 (url "https://gitlab.common-lisp.net/stefil/stefil.git")
7679 (file-name (git-file-name name version))
7682 "0bqz64q2szzhf91zyqyssmvrz7da6442rs01808pf3wrdq28bclh"))))
7683 (build-system asdf-build-system/sbcl)
7685 `(("alexandria" ,sbcl-alexandria)
7686 ("iterate" ,sbcl-iterate)
7687 ("metabang-bind" ,sbcl-metabang-bind)))
7689 ;; Swank doesn't have a pre-compiled package, therefore we must
7690 ;; propagate its sources.
7691 `(("swank" ,cl-slime-swank)))
7694 (modify-phases %standard-phases
7695 (add-after 'unpack 'drop-unnecessary-dependency
7697 (substitute* "package.lisp"
7698 ((":stefil-system") ""))
7700 (home-page "https://common-lisp.net/project/stefil/index-old.shtml")
7701 (synopsis "Simple test framework")
7703 "Stefil is a simple test framework for Common Lisp, with a focus on
7704 interactive development.")
7705 (license license:public-domain))))
7707 (define-public cl-stefil
7708 (sbcl-package->cl-source-package sbcl-stefil))
7710 (define-public sbcl-graph
7711 (let ((commit "78bf9ec930d8eae4f0861b5be76765fb1e45e24f")
7715 (version (git-version "0.0.0" revision commit))
7721 (url "https://github.com/eschulte/graph")
7723 (file-name (git-file-name name version))
7726 "1qpij4xh8bqwc2myahpilcbh916v7vg0acz2fij14d3y0jm02h0g"))
7727 (patches (search-patches "sbcl-graph-asdf-definitions.patch"))))
7728 (build-system asdf-build-system/sbcl)
7730 `(("stefil" ,sbcl-stefil)))
7732 `(("alexandria" ,sbcl-alexandria)
7733 ("cl-heap" ,sbcl-cl-heap)
7734 ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
7735 ("metabang-bind" ,sbcl-metabang-bind)
7736 ("named-readtables" ,sbcl-named-readtables)))
7738 '(#:test-asd-file "graph-test.asd"))
7739 (synopsis "Graph data structure and algorithms for Common Lisp")
7741 "The GRAPH Common Lisp library provides a data structures to represent
7742 graphs, as well as some graph manipulation and analysis algorithms (shortest
7743 path, maximum flow, minimum spanning tree, etc.).")
7744 (home-page "https://eschulte.github.io/graph/")
7745 (license license:gpl3+))))
7747 (define-public cl-graph
7748 (sbcl-package->cl-source-package sbcl-graph))
7750 (define-public sbcl-graph-dot
7752 (inherit sbcl-graph)
7753 (name "sbcl-graph-dot")
7755 `(("alexandria" ,sbcl-alexandria)
7756 ("cl-ppcre" ,sbcl-cl-ppcre)
7757 ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
7758 ("graph" ,sbcl-graph)
7759 ("metabang-bind" ,sbcl-metabang-bind)
7760 ("named-readtables" ,sbcl-named-readtables)))
7762 (substitute-keyword-arguments (package-arguments sbcl-graph)
7763 ((#:asd-file _ "") "graph-dot.asd")
7764 ((#:asd-system-name _ #f) "graph-dot")))
7765 (synopsis "Serialize graphs to and from DOT format")))
7767 (define-public sbcl-graph-json
7769 (inherit sbcl-graph)
7770 (name "sbcl-graph-json")
7772 `(("alexandria" ,sbcl-alexandria)
7773 ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
7774 ("graph" ,sbcl-graph)
7775 ("metabang-bind" ,sbcl-metabang-bind)
7776 ("named-readtables" ,sbcl-named-readtables)
7777 ("yason" ,sbcl-yason)))
7779 (substitute-keyword-arguments (package-arguments sbcl-graph)
7780 ((#:asd-file _ "") "graph-json.asd")
7781 ((#:asd-system-name _ #f) "graph-json")))
7782 (synopsis "Serialize graphs to and from JSON format")))
7784 (define-public sbcl-trivial-indent
7785 (let ((commit "2d016941751647c6cc5bd471751c2cf68861c94a")
7788 (name "sbcl-trivial-indent")
7789 (version (git-version "1.0.0" revision commit))
7795 (url "https://github.com/Shinmera/trivial-indent")
7797 (file-name (git-file-name name version))
7800 "1sj90nqz17w4jq0ixz00gb9g5g6d2s7l8r17zdby27gxxh51w266"))))
7801 (build-system asdf-build-system/sbcl)
7802 (synopsis "Simple Common Lisp library to allow indentation hints for SWANK")
7804 "This library allows you to define custom indentation hints for your
7805 macros if the one recognised by SLIME automatically produces unwanted
7807 (home-page "https://shinmera.github.io/trivial-indent/")
7808 (license license:zlib))))
7810 (define-public cl-trivial-indent
7811 (sbcl-package->cl-source-package sbcl-trivial-indent))
7813 (define-public sbcl-documentation-utils
7814 (let ((commit "98630dd5f7e36ae057fa09da3523f42ccb5d1f55")
7817 (name "sbcl-documentation-utils")
7818 (version (git-version "1.2.0" revision commit))
7824 (url "https://github.com/Shinmera/documentation-utils")
7826 (file-name (git-file-name name version))
7829 "098qhkqskmmrh4wix34mawf7p5c87yql28r51r75yjxj577k5idq"))))
7830 (build-system asdf-build-system/sbcl)
7832 `(("trivial-indent" ,sbcl-trivial-indent)))
7833 (synopsis "Few simple tools to document Common Lisp libraries")
7835 "This is a small library to help you with managing the Common Lisp
7836 docstrings for your library.")
7837 (home-page "https://shinmera.github.io/documentation-utils/")
7838 (license license:zlib))))
7840 (define-public cl-documentation-utils
7841 (sbcl-package->cl-source-package sbcl-documentation-utils))
7843 (define-public ecl-documentation-utils
7844 (sbcl-package->ecl-package sbcl-documentation-utils))
7846 (define-public sbcl-form-fiddle
7847 (let ((commit "e0c23599dbb8cff3e83e012f3d86d0764188ad18")
7850 (name "sbcl-form-fiddle")
7851 (version (git-version "1.1.0" revision commit))
7857 (url "https://github.com/Shinmera/form-fiddle")
7859 (file-name (git-file-name name version))
7862 "041iznc9mpfyrl0sv5893ys9pbb2pvbn9g3clarqi7gsfj483jln"))))
7863 (build-system asdf-build-system/sbcl)
7865 `(("documentation-utils" ,sbcl-documentation-utils)))
7866 (synopsis "Utilities to destructure Common Lisp lambda forms")
7868 "Often times we need to destructure a form definition in a Common Lisp
7869 macro. This library provides a set of simple utilities to help with that.")
7870 (home-page "https://shinmera.github.io/form-fiddle/")
7871 (license license:zlib))))
7873 (define-public cl-form-fiddle
7874 (sbcl-package->cl-source-package sbcl-form-fiddle))
7876 (define-public sbcl-parachute
7877 (let ((commit "ca04dd8e43010a6dfffa26dbe1d62af86008d666")
7880 (name "sbcl-parachute")
7881 (version (git-version "1.1.1" revision commit))
7887 (url "https://github.com/Shinmera/parachute")
7889 (file-name (git-file-name name version))
7892 "1mvsm3r0r6a2bg75nw0q7n9vlby3ch45qjl7hnb5k1z2n5x5lh60"))))
7893 (build-system asdf-build-system/sbcl)
7895 `(("documentation-utils" ,sbcl-documentation-utils)
7896 ("form-fiddle" ,sbcl-form-fiddle)))
7897 (synopsis "Extensible and cross-compatible testing framework for Common Lisp")
7899 "Parachute is a simple-to-use and extensible testing framework.
7900 In Parachute, things are organised as a bunch of named tests within a package.
7901 Each test can contain a bunch of test forms that make up its body.")
7902 (home-page "https://shinmera.github.io/parachute/")
7903 (license license:zlib))))
7905 (define-public cl-parachute
7906 (sbcl-package->cl-source-package sbcl-parachute))
7908 (define-public sbcl-array-utils
7909 (let ((commit "f90eb9070d0b2205af51126a35033574725e5c56")
7912 (name "sbcl-array-utils")
7913 (version (git-version "1.1.1" revision commit))
7919 (url "https://github.com/Shinmera/array-utils")
7921 (file-name (git-file-name name version))
7924 "0zhwfbpr53vs1ii4sx75dz2k9yhh1xpwdqqpg8nmfndxkmhpbi3x"))))
7925 (build-system asdf-build-system/sbcl)
7927 `(("parachute" ,sbcl-parachute)))
7929 `(("documentation-utils" ,sbcl-documentation-utils)))
7930 (synopsis "Tiny collection of array and vector utilities for Common Lisp")
7932 "A miniature toolkit that contains some useful shifting/popping/pushing
7933 functions for arrays and vectors. Originally from Plump.")
7934 (home-page "https://shinmera.github.io/array-utils/")
7935 (license license:zlib))))
7937 (define-public cl-array-utils
7938 (sbcl-package->cl-source-package sbcl-array-utils))
7940 (define-public sbcl-plump
7941 (let ((commit "34f890fe46efdebe7bb70d218f1937e98f632bf9")
7945 (version (git-version "2.0.0" revision commit))
7951 (url "https://github.com/Shinmera/plump")
7953 (file-name (git-file-name name version))
7956 "0a0x8wn6vv1ylxcwck12k18gy0a366kdm6ddxxk7yynl4mwnqgkh"))))
7957 (build-system asdf-build-system/sbcl)
7959 `(("array-utils" ,sbcl-array-utils)
7960 ("documentation-utils" ,sbcl-documentation-utils)))
7961 (synopsis "Lenient XML / XHTML / HTML parser for Common Lisp")
7963 "Plump is a parser for HTML/XML-like documents, focusing on being
7964 lenient towards invalid markup. It can handle things like invalid attributes,
7965 bad closing tag order, unencoded entities, inexistent tag types, self-closing
7966 tags and so on. It parses documents to a class representation and offers a
7967 small set of DOM functions to manipulate it. It can be extended to parse to
7969 (home-page "https://shinmera.github.io/plump/")
7970 (license license:zlib))))
7972 (define-public cl-plump
7973 (sbcl-package->cl-source-package sbcl-plump))
7975 (define-public sbcl-antik-base
7976 (let ((commit "e4711a69b3d6bf37b5727af05c3cfd03e8428ba3")
7979 (name "sbcl-antik-base")
7980 (version (git-version "0.0.0" revision commit))
7985 (url "https://gitlab.common-lisp.net/antik/antik.git")
7987 (file-name (git-file-name name version))
7990 "047ga2c38par2xbgg4qx6hwv06qhf1c1f67as8xvir6s80lip1km"))))
7991 (build-system asdf-build-system/sbcl)
7993 `(("alexandria" ,sbcl-alexandria)
7994 ("cl-ppcre" ,sbcl-cl-ppcre)
7995 ("iterate" ,sbcl-iterate)
7996 ("metabang-bind" ,sbcl-metabang-bind)
7997 ("named-readtables" ,sbcl-named-readtables)
7998 ("split-sequence" ,sbcl-split-sequence)))
8000 `(("lisp-unit" ,sbcl-lisp-unit)))
8001 (synopsis "Scientific and engineering computation in Common Lisp")
8003 "Antik provides a foundation for scientific and engineering
8004 computation in Common Lisp. It is designed not only to facilitate
8005 numerical computations, but to permit the use of numerical computation
8006 libraries and the interchange of data and procedures, whether
8007 foreign (non-Lisp) or Lisp libraries. It is named after the
8008 Antikythera mechanism, one of the oldest examples of a scientific
8010 (home-page "https://common-lisp.net/project/antik/")
8011 (license license:gpl3))))
8013 (define-public cl-antik-base
8014 (sbcl-package->cl-source-package sbcl-antik-base))
8016 (define-public ecl-antik-base
8017 (sbcl-package->ecl-package sbcl-antik-base))
8019 (define-public sbcl-foreign-array
8021 (inherit sbcl-antik-base)
8022 (name "sbcl-foreign-array")
8024 (substitute-keyword-arguments (package-arguments sbcl-antik-base)
8025 ((#:asd-file _ "") "foreign-array.asd")
8026 ((#:asd-system-name _ #f) "foreign-array")))
8028 `(("antik-base" ,sbcl-antik-base)
8030 ("trivial-garbage" ,sbcl-trivial-garbage)
8031 ("static-vectors" ,sbcl-static-vectors)))
8032 (synopsis "Common Lisp library providing access to foreign arrays")))
8034 (define-public cl-foreign-array
8035 (sbcl-package->cl-source-package sbcl-foreign-array))
8037 (define-public ecl-foreign-array
8038 (sbcl-package->ecl-package sbcl-foreign-array))
8040 (define-public sbcl-physical-dimension
8042 (inherit sbcl-antik-base)
8043 (name "sbcl-physical-dimension")
8045 `(("fare-utils" ,sbcl-fare-utils)
8046 ("foreign-array" ,sbcl-foreign-array)
8047 ("trivial-utf-8" ,sbcl-trivial-utf-8)))
8049 (substitute-keyword-arguments (package-arguments sbcl-antik-base)
8050 ((#:asd-file _ "") "physical-dimension.asd")
8051 ((#:asd-system-name _ #f) "physical-dimension")))
8053 "Common Lisp library providing computations with physical units")))
8055 (define-public cl-physical-dimension
8056 (sbcl-package->cl-source-package sbcl-physical-dimension))
8058 (define-public sbcl-science-data
8060 (inherit sbcl-antik-base)
8061 (name "sbcl-science-data")
8063 `(("physical-dimension" ,sbcl-physical-dimension)
8064 ("drakma" ,sbcl-drakma)))
8066 (substitute-keyword-arguments (package-arguments sbcl-antik-base)
8067 ((#:asd-file _ "") "science-data.asd")
8068 ((#:asd-system-name _ #f) "science-data")))
8070 "Common Lisp library for scientific and engineering numerical data")))
8072 (define-public cl-science-data
8073 (sbcl-package->cl-source-package sbcl-science-data))
8075 (define-public sbcl-gsll
8076 (let ((commit "1a8ada22f9cf5ed7372d352b2317f4ccdb6ab308")
8080 (version (git-version "0.0.0" revision commit))
8085 (url "https://gitlab.common-lisp.net/antik/gsll.git")
8087 (file-name (git-file-name name version))
8090 "0z5nypfk26hxihb08p085644afawicrgb4xvadh3lmrn46qbjfn4"))))
8091 (build-system asdf-build-system/sbcl)
8093 `(("lisp-unit" ,sbcl-lisp-unit)))
8095 `(("alexandria" ,sbcl-alexandria)
8096 ("cffi-grovel" ,sbcl-cffi-grovel)
8097 ("cffi-libffi" ,sbcl-cffi-libffi)
8098 ("foreign-array" ,sbcl-foreign-array)
8100 ("metabang-bind" ,sbcl-metabang-bind)
8101 ("trivial-features" ,sbcl-trivial-features)
8102 ("trivial-garbage" ,sbcl-trivial-garbage)))
8106 (modify-phases %standard-phases
8107 (add-after 'unpack 'fix-cffi-paths
8108 (lambda* (#:key inputs #:allow-other-keys)
8109 (substitute* "gsll.asd"
8110 ((":depends-on \\(#:foreign-array")
8111 ":depends-on (#:foreign-array #:cffi-libffi"))
8112 (substitute* "init/init.lisp"
8113 (("libgslcblas.so" all)
8115 (assoc-ref inputs "gsl") "/lib/" all)))
8116 (substitute* "init/init.lisp"
8119 (assoc-ref inputs "gsl") "/lib/" all))))))))
8120 (synopsis "GNU Scientific Library for Lisp")
8122 "The GNU Scientific Library for Lisp (GSLL) allows the use of the
8123 GNU Scientific Library (GSL) from Common Lisp. This library provides a
8124 full range of common mathematical operations useful to scientific and
8125 engineering applications. The design of the GSLL interface is such
8126 that access to most of the GSL library is possible in a Lisp-natural
8127 way; the intent is that the user not be hampered by the restrictions
8128 of the C language in which GSL has been written. GSLL thus provides
8129 interactive use of GSL for getting quick answers, even for someone not
8130 intending to program in Lisp.")
8131 (home-page "https://common-lisp.net/project/gsll/")
8132 (license license:gpl3))))
8134 (define-public cl-gsll
8135 (sbcl-package->cl-source-package sbcl-gsll))
8137 (define-public sbcl-antik
8139 (inherit sbcl-antik-base)
8142 `(("gsll" ,sbcl-gsll)
8143 ("physical-dimension" ,sbcl-physical-dimension)))
8145 (substitute-keyword-arguments (package-arguments sbcl-antik-base)
8146 ((#:asd-file _ "") "antik.asd")
8147 ((#:asd-system-name _ #f) "antik")))))
8149 (define-public cl-antik
8150 (sbcl-package->cl-source-package sbcl-antik))
8152 (define-public sbcl-cl-interpol
8153 (let ((commit "1fd288d861db85bc4677cff3cdd6af75fda1afb4")
8156 (name "sbcl-cl-interpol")
8157 (version (git-version "0.2.6" revision commit))
8162 (url "https://github.com/edicl/cl-interpol")
8164 (file-name (git-file-name name version))
8167 "1hnikak52hmcq1r5f616m6qq1108qnkw80pja950nv1fq5p0ppjn"))))
8168 (build-system asdf-build-system/sbcl)
8170 `(("cl-unicode" ,sbcl-cl-unicode)
8171 ("named-readtables" ,sbcl-named-readtables)))
8173 `(("flexi-streams" ,sbcl-flexi-streams)))
8174 (synopsis "String interpolation for Common Lisp")
8176 "CL-INTERPOL is a library for Common Lisp which modifies the
8177 reader so that you can have interpolation within strings similar to
8178 Perl or Unix Shell scripts. It also provides various ways to insert
8179 arbitrary characters into literal strings even if your editor/IDE
8180 doesn't support them.")
8181 (home-page "https://edicl.github.io/cl-interpol/")
8182 (license license:bsd-3))))
8184 (define-public cl-interpol
8185 (sbcl-package->cl-source-package sbcl-cl-interpol))
8187 (define-public ecl-cl-interpol
8188 (sbcl-package->ecl-package sbcl-cl-interpol))
8190 (define sbcl-symbol-munger-boot0
8191 ;; There is a cyclical dependency between symbol-munger and lisp-unit2.
8192 ;; See https://github.com/AccelerationNet/symbol-munger/issues/4
8193 (let ((commit "cc2bb4b7acd454d756484aec81ba487648385fc3")
8196 (name "sbcl-symbol-munger-boot0")
8197 (version (git-version "0.0.1" revision commit))
8202 (url "https://github.com/AccelerationNet/symbol-munger")
8204 (file-name (git-file-name name version))
8207 "0diav5ricqsybqvbp4bkxyj3bn3v9n7xb2pqqc4vg1algsw2pyjl"))))
8208 (build-system asdf-build-system/sbcl)
8210 `(#:asd-file "symbol-munger.asd"
8211 #:asd-system-name "symbol-munger"))
8213 `(("iterate" ,sbcl-iterate)
8214 ("alexandria" ,sbcl-alexandria)))
8216 `(("lisp-unit" ,sbcl-lisp-unit)))
8218 "Capitalization and spacing conversion functions for Common Lisp")
8220 "This is a Common Lisp library to change the capitalization and spacing
8221 of a string or a symbol. It can convert to and from Lisp, english, underscore
8222 and camel-case rules.")
8223 (home-page "https://github.com/AccelerationNet/symbol-munger")
8224 ;; The package declares a BSD license, but all of the license
8226 ;; See https://github.com/AccelerationNet/symbol-munger/issues/5
8227 (license license:expat))))
8229 (define sbcl-lisp-unit2-boot0
8230 ;; There is a cyclical dependency between symbol-munger and lisp-unit2.
8231 ;; See https://github.com/AccelerationNet/symbol-munger/issues/4
8232 (let ((commit "fb9721524d1e4e73abb223ee036d74ce14a5505c")
8235 (name "sbcl-lisp-unit2-boot0")
8236 (version (git-version "0.2.0" revision commit))
8241 (url "https://github.com/AccelerationNet/lisp-unit2")
8243 (file-name (git-file-name name version))
8246 "1rsqy8y0jqll6xn9a593848f5wvd5ribv4csry1ly0hmdhfnqzlp"))))
8247 (build-system asdf-build-system/sbcl)
8249 `(#:asd-file "lisp-unit2.asd"
8250 #:asd-system-name "lisp-unit2"))
8252 `(("alexandria" ,sbcl-alexandria)
8253 ("cl-interpol" ,sbcl-cl-interpol)
8254 ("iterate" ,sbcl-iterate)
8255 ("symbol-munger-boot0" ,sbcl-symbol-munger-boot0)))
8256 (synopsis "Test Framework for Common Lisp")
8258 "LISP-UNIT2 is a Common Lisp library that supports unit testing in the
8259 style of JUnit for Java. It is a new version of the lisp-unit library written
8260 by Chris Riesbeck.")
8261 (home-page "https://github.com/AccelerationNet/lisp-unit2")
8262 (license license:expat))))
8264 (define-public sbcl-symbol-munger
8265 (let ((commit "97598d4c3c53fd5da72ab78908fbd5d8c7a13416")
8268 (name "sbcl-symbol-munger")
8269 (version (git-version "0.0.1" revision commit))
8274 (url "https://github.com/AccelerationNet/symbol-munger")
8276 (file-name (git-file-name name version))
8279 "0y8jywjy0ldyhp7bxf16fdvdd2qgqnd7nlhlqfpfnzxcqk4xy1km"))))
8280 (build-system asdf-build-system/sbcl)
8282 `(("alexandria" ,sbcl-alexandria)
8283 ("iterate" ,sbcl-iterate)))
8285 `(("lisp-unit2-boot0" ,sbcl-lisp-unit2-boot0)))
8287 "Capitalization and spacing conversion functions for Common Lisp")
8289 "This is a Common Lisp library to change the capitalization and spacing
8290 of a string or a symbol. It can convert to and from Lisp, english, underscore
8291 and camel-case rules.")
8292 (home-page "https://github.com/AccelerationNet/symbol-munger")
8293 ;; The package declares a BSD license, but all of the license
8295 ;; See https://github.com/AccelerationNet/symbol-munger/issues/5
8296 (license license:expat))))
8298 (define-public cl-symbol-munger
8299 (sbcl-package->cl-source-package sbcl-symbol-munger))
8301 (define-public ecl-symbol-munger
8302 (sbcl-package->ecl-package sbcl-symbol-munger))
8304 (define-public sbcl-lisp-unit2
8306 (inherit sbcl-lisp-unit2-boot0)
8307 (name "sbcl-lisp-unit2")
8309 `(("alexandria" ,sbcl-alexandria)
8310 ("cl-interpol" ,sbcl-cl-interpol)
8311 ("iterate" ,sbcl-iterate)
8312 ("symbol-munger" ,sbcl-symbol-munger)))))
8314 (define-public cl-lisp-unit2
8315 (sbcl-package->cl-source-package sbcl-lisp-unit2))
8317 (define-public ecl-lisp-unit2
8318 (sbcl-package->ecl-package sbcl-lisp-unit2))
8320 (define-public sbcl-cl-csv
8321 (let ((commit "68ecb5d816545677513d7f6308d9e5e8d2265651")
8324 (name "sbcl-cl-csv")
8325 (version (git-version "1.0.6" revision commit))
8330 (url "https://github.com/AccelerationNet/cl-csv")
8332 (file-name (git-file-name name version))
8335 "0gcmlbwx5m3kwgk12qi80w08ak8fgdnvyia429fz6gnxmhg0k54x"))))
8336 (build-system asdf-build-system/sbcl)
8338 ;; See: https://github.com/AccelerationNet/cl-csv/pull/34
8341 `(("alexandria" ,sbcl-alexandria)
8342 ("cl-interpol" ,sbcl-cl-interpol)
8343 ("iterate" ,sbcl-iterate)))
8345 `(("lisp-unit2" ,sbcl-lisp-unit2)))
8346 (synopsis "Common lisp library for comma-separated values")
8348 "This is a Common Lisp library providing functions to read/write CSV
8349 from/to strings, streams and files.")
8350 (home-page "https://github.com/AccelerationNet/cl-csv")
8351 (license license:bsd-3))))
8353 (define-public cl-csv
8354 (sbcl-package->cl-source-package sbcl-cl-csv))
8356 (define-public ecl-cl-csv
8357 (sbcl-package->ecl-package sbcl-cl-csv))
8359 (define-public sbcl-external-program
8360 (let ((commit "5888b8f1fd3953feeeacecbba4384ddda584a749")
8363 (name "sbcl-external-program")
8364 (version (git-version "0.0.6" revision commit))
8369 (url "https://github.com/sellout/external-program")
8371 (file-name (git-file-name name version))
8374 "0vww1x3yilb3bjwg6k184vaj4vxyxw4vralhnlm6lk4xac67kc9z"))))
8375 (build-system asdf-build-system/sbcl)
8377 `(("trivial-features" ,sbcl-trivial-features)))
8379 `(("fiveam" ,sbcl-fiveam)))
8380 (synopsis "Common Lisp library for running external programs")
8382 "EXTERNAL-PROGRAM enables running programs outside the Lisp
8383 process. It is an attempt to make the RUN-PROGRAM functionality in
8384 implementations like SBCL and CCL as portable as possible without
8385 sacrificing much in the way of power.")
8386 (home-page "https://github.com/sellout/external-program")
8387 (license license:llgpl))))
8389 (define-public cl-external-program
8390 (sbcl-package->cl-source-package sbcl-external-program))
8392 (define-public ecl-external-program
8393 (sbcl-package->ecl-package sbcl-external-program))
8395 (define sbcl-cl-ana-boot0
8396 (let ((commit "fa7cee4c50aa1c859652813049ba0da7c18a0df9")
8399 (name "sbcl-cl-ana-boot0")
8400 (version (git-version "0.0.0" revision commit))
8405 (url "https://github.com/ghollisjr/cl-ana")
8407 (file-name (git-file-name name version))
8410 "0mr47l57m276dbpap7irr4fcnk5fgknhf6mgv4043s8h73amk5qh"))))
8411 (build-system asdf-build-system/sbcl)
8412 (synopsis "Common Lisp data analysis library")
8414 "CL-ANA is a data analysis library in Common Lisp providing tabular and
8415 binned data analysis along with nonlinear least squares fitting and
8417 (home-page "https://github.com/ghollisjr/cl-ana")
8418 (license license:gpl3))))
8420 (define-public sbcl-cl-ana.pathname-utils
8422 (inherit sbcl-cl-ana-boot0)
8423 (name "sbcl-cl-ana.pathname-utils")
8425 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8426 ((#:asd-file _ "") "pathname-utils/cl-ana.pathname-utils.asd")
8427 ((#:asd-system-name _ #f) "cl-ana.pathname-utils")))))
8429 (define-public cl-ana.pathname-utils
8430 (sbcl-package->cl-source-package sbcl-cl-ana.pathname-utils))
8432 (define-public ecl-cl-ana.pathname-utils
8433 (sbcl-package->ecl-package sbcl-cl-ana.pathname-utils))
8435 (define-public sbcl-cl-ana.package-utils
8437 (inherit sbcl-cl-ana-boot0)
8438 (name "sbcl-cl-ana.package-utils")
8440 `(("alexandria" ,sbcl-alexandria)))
8442 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8443 ((#:asd-file _ "") "package-utils/cl-ana.package-utils.asd")
8444 ((#:asd-system-name _ #f) "cl-ana.package-utils")))))
8446 (define-public cl-ana.package-utils
8447 (sbcl-package->cl-source-package sbcl-cl-ana.package-utils))
8449 (define-public ecl-cl-ana.package-utils
8450 (sbcl-package->ecl-package sbcl-cl-ana.package-utils))
8452 (define-public sbcl-cl-ana.string-utils
8454 (inherit sbcl-cl-ana-boot0)
8455 (name "sbcl-cl-ana.string-utils")
8457 `(("split-sequence" ,sbcl-split-sequence)))
8459 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8460 ((#:asd-file _ "") "string-utils/cl-ana.string-utils.asd")
8461 ((#:asd-system-name _ #f) "cl-ana.string-utils")))))
8463 (define-public cl-ana.string-utils
8464 (sbcl-package->cl-source-package sbcl-cl-ana.string-utils))
8466 (define-public ecl-cl-ana.string-utils
8467 (sbcl-package->ecl-package sbcl-cl-ana.string-utils))
8469 (define-public sbcl-cl-ana.functional-utils
8471 (inherit sbcl-cl-ana-boot0)
8472 (name "sbcl-cl-ana.functional-utils")
8474 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8475 ((#:asd-file _ "") "functional-utils/cl-ana.functional-utils.asd")
8476 ((#:asd-system-name _ #f) "cl-ana.functional-utils")))))
8478 (define-public cl-ana.functional-utils
8479 (sbcl-package->cl-source-package sbcl-cl-ana.functional-utils))
8481 (define-public ecl-cl-ana.functional-utils
8482 (sbcl-package->ecl-package sbcl-cl-ana.functional-utils))
8484 (define-public sbcl-cl-ana.list-utils
8486 (inherit sbcl-cl-ana-boot0)
8487 (name "sbcl-cl-ana.list-utils")
8489 `(("alexandria" ,sbcl-alexandria)
8490 ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
8491 ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)))
8493 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8494 ((#:asd-file _ "") "list-utils/cl-ana.list-utils.asd")
8495 ((#:asd-system-name _ #f) "cl-ana.list-utils")))))
8497 (define-public cl-ana.list-utils
8498 (sbcl-package->cl-source-package sbcl-cl-ana.list-utils))
8500 (define-public ecl-cl-ana.list-utils
8501 (sbcl-package->ecl-package sbcl-cl-ana.list-utils))
8503 (define-public sbcl-cl-ana.generic-math
8505 (inherit sbcl-cl-ana-boot0)
8506 (name "sbcl-cl-ana.generic-math")
8508 `(("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8509 ("cl-ana.package-utils" ,sbcl-cl-ana.package-utils)))
8511 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8512 ((#:asd-file _ "") "generic-math/cl-ana.generic-math.asd")
8513 ((#:asd-system-name _ #f) "cl-ana.generic-math")))))
8515 (define-public cl-ana.generic-math
8516 (sbcl-package->cl-source-package sbcl-cl-ana.generic-math))
8518 (define-public ecl-cl-ana.generic-math
8519 (sbcl-package->ecl-package sbcl-cl-ana.generic-math))
8521 (define-public sbcl-cl-ana.math-functions
8523 (inherit sbcl-cl-ana-boot0)
8524 (name "sbcl-cl-ana.math-functions")
8526 `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8527 ("gsll" ,sbcl-gsll)))
8529 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8530 ((#:asd-file _ "") "math-functions/cl-ana.math-functions.asd")
8531 ((#:asd-system-name _ #f) "cl-ana.math-functions")))))
8533 (define-public cl-ana.math-functions
8534 (sbcl-package->cl-source-package sbcl-cl-ana.math-functions))
8536 (define-public sbcl-cl-ana.calculus
8538 (inherit sbcl-cl-ana-boot0)
8539 (name "sbcl-cl-ana.calculus")
8541 `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)))
8543 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8544 ((#:asd-file _ "") "calculus/cl-ana.calculus.asd")
8545 ((#:asd-system-name _ #f) "cl-ana.calculus")))))
8547 (define-public cl-ana.calculus
8548 (sbcl-package->cl-source-package sbcl-cl-ana.calculus))
8550 (define-public ecl-cl-ana.calculus
8551 (sbcl-package->ecl-package sbcl-cl-ana.calculus))
8553 (define-public sbcl-cl-ana.symbol-utils
8555 (inherit sbcl-cl-ana-boot0)
8556 (name "sbcl-cl-ana.symbol-utils")
8558 `(("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)))
8560 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8561 ((#:asd-file _ "") "symbol-utils/cl-ana.symbol-utils.asd")
8562 ((#:asd-system-name _ #f) "cl-ana.symbol-utils")))))
8564 (define-public cl-ana.symbol-utils
8565 (sbcl-package->cl-source-package sbcl-cl-ana.symbol-utils))
8567 (define-public ecl-cl-ana.symbol-utils
8568 (sbcl-package->ecl-package sbcl-cl-ana.symbol-utils))
8570 (define-public sbcl-cl-ana.macro-utils
8572 (inherit sbcl-cl-ana-boot0)
8573 (name "sbcl-cl-ana.macro-utils")
8575 `(("alexandria" ,sbcl-alexandria)
8576 ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8577 ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8578 ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8579 ("split-sequence" ,sbcl-split-sequence)))
8581 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8582 ((#:asd-file _ "") "macro-utils/cl-ana.macro-utils.asd")
8583 ((#:asd-system-name _ #f) "cl-ana.macro-utils")))))
8585 (define-public cl-ana.macro-utils
8586 (sbcl-package->cl-source-package sbcl-cl-ana.macro-utils))
8588 (define-public ecl-cl-ana.macro-utils
8589 (sbcl-package->ecl-package sbcl-cl-ana.macro-utils))
8591 (define-public sbcl-cl-ana.binary-tree
8593 (inherit sbcl-cl-ana-boot0)
8594 (name "sbcl-cl-ana.binary-tree")
8596 `(("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
8597 ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8598 ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)))
8600 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8601 ((#:asd-file _ "") "binary-tree/cl-ana.binary-tree.asd")
8602 ((#:asd-system-name _ #f) "cl-ana.binary-tree")))))
8604 (define-public cl-ana.binary-tree
8605 (sbcl-package->cl-source-package sbcl-cl-ana.binary-tree))
8607 (define-public ecl-cl-ana.binary-tree
8608 (sbcl-package->ecl-package sbcl-cl-ana.binary-tree))
8610 (define-public sbcl-cl-ana.tensor
8612 (inherit sbcl-cl-ana-boot0)
8613 (name "sbcl-cl-ana.tensor")
8615 `(("alexandria" ,sbcl-alexandria)
8616 ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8617 ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8618 ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8619 ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)))
8621 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8622 ((#:asd-file _ "") "tensor/cl-ana.tensor.asd")
8623 ((#:asd-system-name _ #f) "cl-ana.tensor")))))
8625 (define-public cl-ana.tensor
8626 (sbcl-package->cl-source-package sbcl-cl-ana.tensor))
8628 (define-public ecl-cl-ana.tensor
8629 (sbcl-package->ecl-package sbcl-cl-ana.tensor))
8631 (define-public sbcl-cl-ana.error-propogation
8633 (inherit sbcl-cl-ana-boot0)
8634 (name "sbcl-cl-ana.error-propogation")
8636 `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8637 ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)))
8639 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8640 ((#:asd-file _ "") "error-propogation/cl-ana.error-propogation.asd")
8641 ((#:asd-system-name _ #f) "cl-ana.error-propogation")))))
8643 (define-public cl-ana.error-propogation
8644 (sbcl-package->cl-source-package sbcl-cl-ana.error-propogation))
8646 (define-public sbcl-cl-ana.quantity
8648 (inherit sbcl-cl-ana-boot0)
8649 (name "sbcl-cl-ana.quantity")
8651 `(("alexandria" ,sbcl-alexandria)
8652 ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
8653 ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8654 ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8655 ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8656 ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)))
8658 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8659 ((#:asd-file _ "") "quantity/cl-ana.quantity.asd")
8660 ((#:asd-system-name _ #f) "cl-ana.quantity")))))
8662 (define-public cl-ana.quantity
8663 (sbcl-package->cl-source-package sbcl-cl-ana.quantity))
8665 (define-public sbcl-cl-ana.table
8667 (inherit sbcl-cl-ana-boot0)
8668 (name "sbcl-cl-ana.table")
8670 `(("alexandria" ,sbcl-alexandria)
8671 ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
8672 ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8673 ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8674 ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8675 ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)))
8677 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8678 ((#:asd-file _ "") "table/cl-ana.table.asd")
8679 ((#:asd-system-name _ #f) "cl-ana.table")))))
8681 (define-public cl-ana.table
8682 (sbcl-package->cl-source-package sbcl-cl-ana.table))
8684 (define-public ecl-cl-ana.table
8685 (sbcl-package->ecl-package sbcl-cl-ana.table))
8687 (define-public sbcl-cl-ana.table-utils
8689 (inherit sbcl-cl-ana-boot0)
8690 (name "sbcl-cl-ana.table-utils")
8692 `(("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8693 ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8694 ("cl-ana.table" ,sbcl-cl-ana.table)))
8696 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8697 ((#:asd-file _ "") "table-utils/cl-ana.table-utils.asd")
8698 ((#:asd-system-name _ #f) "cl-ana.table-utils")))))
8700 (define-public cl-ana.table-utils
8701 (sbcl-package->cl-source-package sbcl-cl-ana.table-utils))
8703 (define-public ecl-cl-ana.table-utils
8704 (sbcl-package->ecl-package sbcl-cl-ana.table-utils))
8706 (define-public sbcl-cl-ana.hdf-cffi
8708 (inherit sbcl-cl-ana-boot0)
8709 (name "sbcl-cl-ana.hdf-cffi")
8711 `(("cffi" ,sbcl-cffi)
8712 ("hdf5" ,hdf5-parallel-openmpi)))
8714 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8715 ((#:asd-file _ "") "hdf-cffi/cl-ana.hdf-cffi.asd")
8716 ((#:asd-system-name _ #f) "cl-ana.hdf-cffi")
8717 ((#:phases phases '%standard-phases)
8718 `(modify-phases ,phases
8719 (add-after 'unpack 'fix-paths
8720 (lambda* (#:key inputs #:allow-other-keys)
8721 (substitute* "hdf-cffi/hdf-cffi.lisp"
8722 (("/usr/lib/i386-linux-gnu/hdf5/serial/libhdf5.so")
8724 (assoc-ref inputs "hdf5")
8725 "/lib/libhdf5.so")))))))))))
8727 (define-public cl-ana.hdf-cffi
8728 (sbcl-package->cl-source-package sbcl-cl-ana.hdf-cffi))
8730 (define-public ecl-cl-ana.hdf-cffi
8731 (sbcl-package->ecl-package sbcl-cl-ana.hdf-cffi))
8733 (define-public sbcl-cl-ana.int-char
8735 (inherit sbcl-cl-ana-boot0)
8736 (name "sbcl-cl-ana.int-char")
8738 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8739 ((#:asd-file _ "") "int-char/cl-ana.int-char.asd")
8740 ((#:asd-system-name _ #f) "cl-ana.int-char")))))
8742 (define-public cl-ana.int-char
8743 (sbcl-package->cl-source-package sbcl-cl-ana.int-char))
8745 (define-public ecl-cl-ana.int-char
8746 (sbcl-package->ecl-package sbcl-cl-ana.int-char))
8748 (define-public sbcl-cl-ana.memoization
8750 (inherit sbcl-cl-ana-boot0)
8751 (name "sbcl-cl-ana.memoization")
8753 `(("alexandria" ,sbcl-alexandria)))
8755 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8756 ((#:asd-file _ "") "memoization/cl-ana.memoization.asd")
8757 ((#:asd-system-name _ #f) "cl-ana.memoization")))))
8759 (define-public cl-ana.memoization
8760 (sbcl-package->cl-source-package sbcl-cl-ana.memoization))
8762 (define-public ecl-cl-ana.memoization
8763 (sbcl-package->ecl-package sbcl-cl-ana.memoization))
8765 (define-public sbcl-cl-ana.typespec
8767 (inherit sbcl-cl-ana-boot0)
8768 (name "sbcl-cl-ana.typespec")
8770 `(("alexandria" ,sbcl-alexandria)
8772 ("cl-ana.int-char" ,sbcl-cl-ana.int-char)
8773 ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8774 ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
8775 ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8776 ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8777 ("cl-ana.tensor" ,sbcl-cl-ana.tensor)))
8779 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8780 ((#:asd-file _ "") "typespec/cl-ana.typespec.asd")
8781 ((#:asd-system-name _ #f) "cl-ana.typespec")))))
8783 (define-public cl-ana.typespec
8784 (sbcl-package->cl-source-package sbcl-cl-ana.typespec))
8786 (define-public ecl-cl-ana.typespec
8787 (sbcl-package->ecl-package sbcl-cl-ana.typespec))
8789 (define-public sbcl-cl-ana.hdf-typespec
8791 (inherit sbcl-cl-ana-boot0)
8792 (name "sbcl-cl-ana.hdf-typespec")
8794 `(("alexandria" ,sbcl-alexandria)
8796 ("cl-ana.hdf-cffi" ,sbcl-cl-ana.hdf-cffi)
8797 ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8798 ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
8799 ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8800 ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8801 ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
8803 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8804 ((#:asd-file _ "") "hdf-typespec/cl-ana.hdf-typespec.asd")
8805 ((#:asd-system-name _ #f) "cl-ana.hdf-typespec")))))
8807 (define-public cl-ana.hdf-typespec
8808 (sbcl-package->cl-source-package sbcl-cl-ana.hdf-typespec))
8810 (define-public ecl-cl-ana.hdf-typespec
8811 (sbcl-package->ecl-package sbcl-cl-ana.hdf-typespec))
8813 (define-public sbcl-cl-ana.hdf-utils
8815 (inherit sbcl-cl-ana-boot0)
8816 (name "sbcl-cl-ana.hdf-utils")
8818 `(("alexandria" ,sbcl-alexandria)
8820 ("cl-ana.hdf-cffi" ,sbcl-cl-ana.hdf-cffi)
8821 ("cl-ana.hdf-typespec" ,sbcl-cl-ana.hdf-typespec)
8822 ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
8823 ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
8824 ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
8825 ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8826 ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
8828 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8829 ((#:asd-file _ "") "hdf-utils/cl-ana.hdf-utils.asd")
8830 ((#:asd-system-name _ #f) "cl-ana.hdf-utils")))))
8832 (define-public cl-ana.hdf-utils
8833 (sbcl-package->cl-source-package sbcl-cl-ana.hdf-utils))
8835 (define-public ecl-cl-ana.hdf-utils
8836 (sbcl-package->ecl-package sbcl-cl-ana.hdf-utils))
8838 (define-public sbcl-cl-ana.typed-table
8840 (inherit sbcl-cl-ana-boot0)
8841 (name "sbcl-cl-ana.typed-table")
8843 `(("alexandria" ,sbcl-alexandria)
8844 ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8845 ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
8846 ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
8847 ("cl-ana.table" ,sbcl-cl-ana.table)
8848 ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
8850 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8851 ((#:asd-file _ "") "typed-table/cl-ana.typed-table.asd")
8852 ((#:asd-system-name _ #f) "cl-ana.typed-table")))))
8854 (define-public cl-ana.typed-table
8855 (sbcl-package->cl-source-package sbcl-cl-ana.typed-table))
8857 (define-public ecl-cl-ana.typed-table
8858 (sbcl-package->ecl-package sbcl-cl-ana.typed-table))
8860 (define-public sbcl-cl-ana.hdf-table
8862 (inherit sbcl-cl-ana-boot0)
8863 (name "sbcl-cl-ana.hdf-table")
8865 `(("alexandria" ,sbcl-alexandria)
8866 ("cl-ana.binary-tree" ,sbcl-cl-ana.binary-tree)
8867 ("cl-ana.hdf-cffi" ,sbcl-cl-ana.hdf-cffi)
8868 ("cl-ana.hdf-typespec" ,sbcl-cl-ana.hdf-typespec)
8869 ("cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
8870 ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8871 ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
8872 ("cl-ana.table" ,sbcl-cl-ana.table)
8873 ("cl-ana.typed-table" ,sbcl-cl-ana.typed-table)
8874 ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
8876 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8877 ((#:asd-file _ "") "hdf-table/cl-ana.hdf-table.asd")
8878 ((#:asd-system-name _ #f) "cl-ana.hdf-table")))))
8880 (define-public cl-ana.hdf-table
8881 (sbcl-package->cl-source-package sbcl-cl-ana.hdf-table))
8883 (define-public ecl-cl-ana.hdf-table
8884 (sbcl-package->ecl-package sbcl-cl-ana.hdf-table))
8886 (define-public sbcl-cl-ana.gsl-cffi
8888 (inherit sbcl-cl-ana-boot0)
8889 (name "sbcl-cl-ana.gsl-cffi")
8891 `(("cffi" ,sbcl-cffi)
8894 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8895 ((#:asd-file _ "") "gsl-cffi/cl-ana.gsl-cffi.asd")
8896 ((#:asd-system-name _ #f) "cl-ana.gsl-cffi")
8897 ((#:phases phases '%standard-phases)
8898 `(modify-phases ,phases
8899 (add-after 'unpack 'fix-paths
8900 (lambda* (#:key inputs #:allow-other-keys)
8901 (substitute* "gsl-cffi/gsl-cffi.lisp"
8902 (("define-foreign-library gsl-cffi" all)
8903 (string-append all " (:unix "
8904 (assoc-ref inputs "gsl")
8905 "/lib/libgsl.so)")))))))))))
8907 (define-public cl-ana.gsl-cffi
8908 (sbcl-package->cl-source-package sbcl-cl-ana.gsl-cffi))
8910 (define-public ecl-cl-ana.gsl-cffi
8911 (sbcl-package->ecl-package sbcl-cl-ana.gsl-cffi))
8913 (define-public sbcl-cl-ana.ntuple-table
8915 (inherit sbcl-cl-ana-boot0)
8916 (name "sbcl-cl-ana.ntuple-table")
8918 `(("alexandria" ,sbcl-alexandria)
8920 ("cl-ana.gsl-cffi" ,sbcl-cl-ana.gsl-cffi)
8921 ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8922 ("cl-ana.table" ,sbcl-cl-ana.table)
8923 ("cl-ana.typed-table" ,sbcl-cl-ana.typed-table)
8924 ("cl-ana.typespec" ,sbcl-cl-ana.typespec)
8925 ("gsll" ,sbcl-gsll)))
8927 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8928 ((#:asd-file _ "") "ntuple-table/cl-ana.ntuple-table.asd")
8929 ((#:asd-system-name _ #f) "cl-ana.ntuple-table")))))
8931 (define-public cl-ana.ntuple-table
8932 (sbcl-package->cl-source-package sbcl-cl-ana.ntuple-table))
8934 (define-public sbcl-cl-ana.csv-table
8936 (inherit sbcl-cl-ana-boot0)
8937 (name "sbcl-cl-ana.csv-table")
8939 `(("alexandria" ,sbcl-alexandria)
8940 ("antik" ,sbcl-antik)
8941 ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8942 ("cl-ana.table" ,sbcl-cl-ana.table)
8943 ("cl-csv" ,sbcl-cl-csv)
8944 ("iterate" ,sbcl-iterate)))
8946 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8947 ((#:asd-file _ "") "csv-table/cl-ana.csv-table.asd")
8948 ((#:asd-system-name _ #f) "cl-ana.csv-table")))))
8950 (define-public cl-ana.csv-table
8951 (sbcl-package->cl-source-package sbcl-cl-ana.csv-table))
8953 (define-public sbcl-cl-ana.reusable-table
8955 (inherit sbcl-cl-ana-boot0)
8956 (name "sbcl-cl-ana.reusable-table")
8958 `(("alexandria" ,sbcl-alexandria)
8959 ("cl-ana.table" ,sbcl-cl-ana.table)))
8961 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8962 ((#:asd-file _ "") "reusable-table/cl-ana.reusable-table.asd")
8963 ((#:asd-system-name _ #f) "cl-ana.reusable-table")))))
8965 (define-public cl-ana.reusable-table
8966 (sbcl-package->cl-source-package sbcl-cl-ana.reusable-table))
8968 (define-public ecl-cl-ana.reusable-table
8969 (sbcl-package->ecl-package sbcl-cl-ana.reusable-table))
8971 (define-public sbcl-cl-ana.linear-algebra
8973 (inherit sbcl-cl-ana-boot0)
8974 (name "sbcl-cl-ana.linear-algebra")
8976 `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8977 ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
8978 ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
8979 ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
8980 ("gsll" ,sbcl-gsll)))
8982 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
8983 ((#:asd-file _ "") "linear-algebra/cl-ana.linear-algebra.asd")
8984 ((#:asd-system-name _ #f) "cl-ana.linear-algebra")))))
8986 (define-public cl-ana.linear-algebra
8987 (sbcl-package->cl-source-package sbcl-cl-ana.linear-algebra))
8989 (define-public sbcl-cl-ana.lorentz
8991 (inherit sbcl-cl-ana-boot0)
8992 (name "sbcl-cl-ana.lorentz")
8994 `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
8995 ("cl-ana.linear-algebra" ,sbcl-cl-ana.linear-algebra)
8996 ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
8997 ("iterate" ,sbcl-iterate)))
8999 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9000 ((#:asd-file _ "") "lorentz/cl-ana.lorentz.asd")
9001 ((#:asd-system-name _ #f) "cl-ana.lorentz")))))
9003 (define-public cl-ana.lorentz
9004 (sbcl-package->cl-source-package sbcl-cl-ana.lorentz))
9006 (define-public sbcl-cl-ana.clos-utils
9008 (inherit sbcl-cl-ana-boot0)
9009 (name "sbcl-cl-ana.clos-utils")
9011 `(("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9012 ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
9013 ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
9014 ("closer-mop" ,sbcl-closer-mop)))
9016 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9017 ((#:asd-file _ "") "clos-utils/cl-ana.clos-utils.asd")
9018 ((#:asd-system-name _ #f) "cl-ana.clos-utils")))))
9020 (define-public cl-ana.clos-utils
9021 (sbcl-package->cl-source-package sbcl-cl-ana.clos-utils))
9023 (define-public ecl-cl-ana.clos-utils
9024 (sbcl-package->ecl-package sbcl-cl-ana.clos-utils))
9026 (define-public sbcl-cl-ana.hash-table-utils
9028 (inherit sbcl-cl-ana-boot0)
9029 (name "sbcl-cl-ana.hash-table-utils")
9031 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9032 ((#:asd-file _ "") "hash-table-utils/cl-ana.hash-table-utils.asd")
9033 ((#:asd-system-name _ #f) "cl-ana.hash-table-utils")))))
9035 (define-public cl-ana.hash-table-utils
9036 (sbcl-package->cl-source-package sbcl-cl-ana.hash-table-utils))
9038 (define-public ecl-cl-ana.hash-table-utils
9039 (sbcl-package->ecl-package sbcl-cl-ana.hash-table-utils))
9041 (define-public sbcl-cl-ana.map
9043 (inherit sbcl-cl-ana-boot0)
9044 (name "sbcl-cl-ana.map")
9046 `(("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)))
9048 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9049 ((#:asd-file _ "") "map/cl-ana.map.asd")
9050 ((#:asd-system-name _ #f) "cl-ana.map")))))
9052 (define-public cl-ana.map
9053 (sbcl-package->cl-source-package sbcl-cl-ana.map))
9055 (define-public ecl-cl-ana.map
9056 (sbcl-package->ecl-package sbcl-cl-ana.map))
9058 (define-public sbcl-cl-ana.fitting
9060 (inherit sbcl-cl-ana-boot0)
9061 (name "sbcl-cl-ana.fitting")
9063 `(("alexandria" ,sbcl-alexandria)
9064 ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
9065 ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9066 ("cl-ana.map" ,sbcl-cl-ana.map)
9067 ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
9068 ("gsll" ,sbcl-gsll)))
9070 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9071 ((#:asd-file _ "") "fitting/cl-ana.fitting.asd")
9072 ((#:asd-system-name _ #f) "cl-ana.fitting")))))
9074 (define-public cl-ana.fitting
9075 (sbcl-package->cl-source-package sbcl-cl-ana.fitting))
9077 (define-public sbcl-cl-ana.histogram
9079 (inherit sbcl-cl-ana-boot0)
9080 (name "sbcl-cl-ana.histogram")
9082 `(("alexandria" ,sbcl-alexandria)
9083 ("iterate" ,sbcl-iterate)
9084 ("cl-ana.binary-tree" ,sbcl-cl-ana.binary-tree)
9085 ("cl-ana.clos-utils" ,sbcl-cl-ana.clos-utils)
9086 ("cl-ana.fitting" ,sbcl-cl-ana.fitting)
9087 ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
9088 ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9089 ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
9090 ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9091 ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9092 ("cl-ana.map" ,sbcl-cl-ana.map)
9093 ("cl-ana.tensor" ,sbcl-cl-ana.tensor)))
9095 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9096 ((#:asd-file _ "") "histogram/cl-ana.histogram.asd")
9097 ((#:asd-system-name _ #f) "cl-ana.histogram")))))
9099 (define-public cl-ana.histogram
9100 (sbcl-package->cl-source-package sbcl-cl-ana.histogram))
9102 (define-public sbcl-cl-ana.file-utils
9104 (inherit sbcl-cl-ana-boot0)
9105 (name "sbcl-cl-ana.file-utils")
9107 `(("external-program" ,sbcl-external-program)
9108 ("split-sequence" ,sbcl-split-sequence)))
9110 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9111 ((#:asd-file _ "") "file-utils/cl-ana.file-utils.asd")
9112 ((#:asd-system-name _ #f) "cl-ana.file-utils")))))
9114 (define-public cl-ana.file-utils
9115 (sbcl-package->cl-source-package sbcl-cl-ana.file-utils))
9117 (define-public ecl-cl-ana.file-utils
9118 (sbcl-package->ecl-package sbcl-cl-ana.file-utils))
9120 (define-public sbcl-cl-ana.statistics
9122 (inherit sbcl-cl-ana-boot0)
9123 (name "sbcl-cl-ana.statistics")
9125 `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9126 ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9127 ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9128 ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9129 ("cl-ana.map" ,sbcl-cl-ana.map)))
9131 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9132 ((#:asd-file _ "") "statistics/cl-ana.statistics.asd")
9133 ((#:asd-system-name _ #f) "cl-ana.statistics")))))
9135 (define-public cl-ana.statistics
9136 (sbcl-package->cl-source-package sbcl-cl-ana.statistics))
9138 (define-public sbcl-cl-ana.gnuplot-interface
9140 (inherit sbcl-cl-ana-boot0)
9141 (name "sbcl-cl-ana.gnuplot-interface")
9143 `(("external-program" ,sbcl-external-program)))
9145 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9146 ((#:asd-file _ "") "gnuplot-interface/cl-ana.gnuplot-interface.asd")
9147 ((#:asd-system-name _ #f) "cl-ana.gnuplot-interface")))))
9149 (define-public cl-ana.gnuplot-interface
9150 (sbcl-package->cl-source-package sbcl-cl-ana.gnuplot-interface))
9152 (define-public ecl-cl-ana.gnuplot-interface
9153 (sbcl-package->ecl-package sbcl-cl-ana.gnuplot-interface))
9155 (define-public sbcl-cl-ana.plotting
9157 (inherit sbcl-cl-ana-boot0)
9158 (name "sbcl-cl-ana.plotting")
9160 `(("alexandria" ,sbcl-alexandria)
9161 ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
9162 ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
9163 ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9164 ("cl-ana.gnuplot-interface" ,sbcl-cl-ana.gnuplot-interface)
9165 ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9166 ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9167 ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9168 ("cl-ana.map" ,sbcl-cl-ana.map)
9169 ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
9170 ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
9171 ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
9172 ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
9173 ("external-program" ,sbcl-external-program)
9174 ("split-sequence" ,sbcl-split-sequence)))
9176 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9177 ((#:asd-file _ "") "plotting/cl-ana.plotting.asd")
9178 ((#:asd-system-name _ #f) "cl-ana.plotting")))))
9180 (define-public cl-ana.plotting
9181 (sbcl-package->cl-source-package sbcl-cl-ana.plotting))
9183 (define-public sbcl-cl-ana.table-viewing
9185 (inherit sbcl-cl-ana-boot0)
9186 (name "sbcl-cl-ana.table-viewing")
9188 `(("alexandria" ,sbcl-alexandria)
9189 ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9190 ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9191 ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9192 ("cl-ana.plotting" ,sbcl-cl-ana.plotting)
9193 ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
9194 ("cl-ana.table" ,sbcl-cl-ana.table)))
9196 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9197 ((#:asd-file _ "") "table-viewing/cl-ana.table-viewing.asd")
9198 ((#:asd-system-name _ #f) "cl-ana.table-viewing")))))
9200 (define-public cl-ana.table-viewing
9201 (sbcl-package->cl-source-package sbcl-cl-ana.table-viewing))
9203 (define-public sbcl-cl-ana.serialization
9205 (inherit sbcl-cl-ana-boot0)
9206 (name "sbcl-cl-ana.serialization")
9208 `(("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
9209 ("cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
9210 ("cl-ana.hdf-table" ,sbcl-cl-ana.hdf-table)
9211 ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9212 ("cl-ana.int-char" ,sbcl-cl-ana.int-char)
9213 ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9214 ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
9216 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9217 ((#:asd-file _ "") "serialization/cl-ana.serialization.asd")
9218 ((#:asd-system-name _ #f) "cl-ana.serialization")))))
9220 (define-public cl-ana.serialization
9221 (sbcl-package->cl-source-package sbcl-cl-ana.serialization))
9223 (define-public sbcl-cl-ana.makeres
9225 (inherit sbcl-cl-ana-boot0)
9226 (name "sbcl-cl-ana.makeres")
9228 `(("alexandria" ,sbcl-alexandria)
9229 ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
9230 ("cl-ana.file-utils" ,sbcl-cl-ana.file-utils)
9231 ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
9232 ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9233 ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
9234 ("cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
9235 ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9236 ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9237 ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9238 ("cl-ana.map" ,sbcl-cl-ana.map)
9239 ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
9240 ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
9241 ("cl-ana.plotting" ,sbcl-cl-ana.plotting)
9242 ("cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
9243 ("cl-ana.serialization" ,sbcl-cl-ana.serialization)
9244 ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
9245 ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
9246 ("cl-ana.table" ,sbcl-cl-ana.table)
9247 ("external-program" ,sbcl-external-program)))
9249 `(("cl-fad" ,sbcl-cl-fad)))
9251 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9252 ((#:asd-file _ "") "makeres/cl-ana.makeres.asd")
9253 ((#:asd-system-name _ #f) "cl-ana.makeres")))))
9255 (define-public cl-ana.makeres
9256 (sbcl-package->cl-source-package sbcl-cl-ana.makeres))
9258 (define-public sbcl-cl-ana.makeres-macro
9260 (inherit sbcl-cl-ana-boot0)
9261 (name "sbcl-cl-ana.makeres-macro")
9263 `(("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9264 ("cl-ana.makeres" ,sbcl-cl-ana.makeres)))
9266 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9267 ((#:asd-file _ "") "makeres-macro/cl-ana.makeres-macro.asd")
9268 ((#:asd-system-name _ #f) "cl-ana.makeres-macro")))))
9270 (define-public cl-ana.makeres-macro
9271 (sbcl-package->cl-source-package sbcl-cl-ana.makeres-macro))
9273 (define-public sbcl-cl-ana.makeres-block
9275 (inherit sbcl-cl-ana-boot0)
9276 (name "sbcl-cl-ana.makeres-block")
9278 `(("alexandria" ,sbcl-alexandria)
9279 ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9280 ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9281 ("cl-ana.makeres" ,sbcl-cl-ana.makeres)))
9283 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9284 ((#:asd-file _ "") "makeres-block/cl-ana.makeres-block.asd")
9285 ((#:asd-system-name _ #f) "cl-ana.makeres-block")))))
9287 (define-public cl-ana.makeres-block
9288 (sbcl-package->cl-source-package sbcl-cl-ana.makeres-block))
9290 (define-public sbcl-cl-ana.makeres-progress
9292 (inherit sbcl-cl-ana-boot0)
9293 (name "sbcl-cl-ana.makeres-progress")
9295 `(("alexandria" ,sbcl-alexandria)
9296 ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9297 ("cl-ana.makeres" ,sbcl-cl-ana.makeres)))
9299 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9300 ((#:asd-file _ "") "makeres-progress/cl-ana.makeres-progress.asd")
9301 ((#:asd-system-name _ #f) "cl-ana.makeres-progress")))))
9303 (define-public cl-ana.makeres-progress
9304 (sbcl-package->cl-source-package sbcl-cl-ana.makeres-progress))
9306 (define-public sbcl-cl-ana.makeres-table
9308 (inherit sbcl-cl-ana-boot0)
9309 (name "sbcl-cl-ana.makeres-table")
9311 `(("cl-ana.csv-table" ,sbcl-cl-ana.csv-table)
9312 ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
9313 ("cl-ana.hdf-table" ,sbcl-cl-ana.hdf-table)
9314 ("cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
9315 ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9316 ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9317 ("cl-ana.makeres" ,sbcl-cl-ana.makeres)
9318 ("cl-ana.makeres-macro" ,sbcl-cl-ana.makeres-macro)
9319 ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
9320 ("cl-ana.ntuple-table" ,sbcl-cl-ana.ntuple-table)
9321 ("cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
9322 ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
9323 ("cl-ana.table" ,sbcl-cl-ana.table)))
9325 `(("cl-fad" ,sbcl-cl-fad)))
9327 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9328 ((#:asd-file _ "") "makeres-table/cl-ana.makeres-table.asd")
9329 ((#:asd-system-name _ #f) "cl-ana.makeres-table")))))
9331 (define-public cl-ana.makeres-table
9332 (sbcl-package->cl-source-package sbcl-cl-ana.makeres-table))
9334 (define-public sbcl-cl-ana.makeres-graphviz
9336 (inherit sbcl-cl-ana-boot0)
9337 (name "sbcl-cl-ana.makeres-graphviz")
9339 `(("cl-ana.makeres" ,sbcl-cl-ana.makeres)
9340 ("external-program" ,sbcl-external-program)))
9342 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9343 ((#:asd-file _ "") "makeres-graphviz/cl-ana.makeres-graphviz.asd")
9344 ((#:asd-system-name _ #f) "cl-ana.makeres-graphviz")))))
9346 (define-public cl-ana.makeres-graphviz
9347 (sbcl-package->cl-source-package sbcl-cl-ana.makeres-graphviz))
9349 (define-public sbcl-cl-ana.makeres-branch
9351 (inherit sbcl-cl-ana-boot0)
9352 (name "sbcl-cl-ana.makeres-branch")
9354 `(("alexandria" ,sbcl-alexandria)
9355 ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9356 ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
9357 ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9358 ("cl-ana.map" ,sbcl-cl-ana.map)
9359 ("cl-ana.makeres" ,sbcl-cl-ana.makeres)))
9361 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9362 ((#:asd-file _ "") "makeres-branch/cl-ana.makeres-branch.asd")
9363 ((#:asd-system-name _ #f) "cl-ana.makeres-branch")))))
9365 (define-public cl-ana.makeres-branch
9366 (sbcl-package->cl-source-package sbcl-cl-ana.makeres-branch))
9368 (define-public sbcl-cl-ana.makeres-utils
9370 (inherit sbcl-cl-ana-boot0)
9371 (name "sbcl-cl-ana.makeres-utils")
9373 `(("alexandria" ,sbcl-alexandria)
9374 ("cl-ana.file-utils" ,sbcl-cl-ana.file-utils)
9375 ("cl-ana.fitting" ,sbcl-cl-ana.fitting)
9376 ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
9377 ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9378 ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9379 ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9380 ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9381 ("cl-ana.makeres" ,sbcl-cl-ana.makeres)
9382 ("cl-ana.map" ,sbcl-cl-ana.map)
9383 ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
9384 ("cl-ana.plotting" ,sbcl-cl-ana.plotting)
9385 ("cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
9386 ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
9387 ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
9388 ("cl-ana.table" ,sbcl-cl-ana.table)))
9390 `(("cl-fad" ,sbcl-cl-fad)))
9392 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9393 ((#:asd-file _ "") "makeres-utils/cl-ana.makeres-utils.asd")
9394 ((#:asd-system-name _ #f) "cl-ana.makeres-utils")))))
9396 (define-public cl-ana.makeres-utils
9397 (sbcl-package->cl-source-package sbcl-cl-ana.makeres-utils))
9399 (define-public sbcl-cl-ana.statistical-learning
9401 (inherit sbcl-cl-ana-boot0)
9402 (name "sbcl-cl-ana.statistical-learning")
9404 `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9405 ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
9406 ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9407 ("cl-ana.linear-algebra" ,sbcl-cl-ana.linear-algebra)
9408 ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
9409 ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
9410 ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
9411 ("cl-ana.map" ,sbcl-cl-ana.map)
9412 ("cl-ana.statistics" ,sbcl-cl-ana.statistics)))
9414 `(("cl-fad" ,sbcl-cl-fad)))
9416 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9418 "statistical-learning/cl-ana.statistical-learning.asd")
9419 ((#:asd-system-name _ #f) "cl-ana.statistical-learning")))))
9421 (define-public cl-ana.statistical-learning
9422 (sbcl-package->cl-source-package sbcl-cl-ana.statistical-learning))
9424 (define-public sbcl-cl-ana
9426 (inherit sbcl-cl-ana-boot0)
9427 (name "sbcl-cl-ana")
9429 `(("cl-ana.binary-tree" ,sbcl-cl-ana.binary-tree)
9430 ("cl-ana.calculus" ,sbcl-cl-ana.calculus)
9431 ("cl-ana.clos-utils" ,sbcl-cl-ana.clos-utils)
9432 ("cl-ana.csv-table" ,sbcl-cl-ana.csv-table)
9433 ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
9434 ("cl-ana.file-utils" ,sbcl-cl-ana.file-utils)
9435 ("cl-ana.fitting" ,sbcl-cl-ana.fitting)
9436 ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
9437 ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
9438 ("cl-ana.hdf-table" ,sbcl-cl-ana.hdf-table)
9439 ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
9440 ("cl-ana.int-char" ,sbcl-cl-ana.int-char)
9441 ("cl-ana.linear-algebra" ,sbcl-cl-ana.linear-algebra)
9442 ("cl-ana.lorentz" ,sbcl-cl-ana.lorentz)
9443 ("cl-ana.map" ,sbcl-cl-ana.map)
9444 ("cl-ana.makeres" ,sbcl-cl-ana.makeres)
9445 ("cl-ana.makeres-block" ,sbcl-cl-ana.makeres-block)
9446 ("cl-ana.makeres-branch" ,sbcl-cl-ana.makeres-branch)
9447 ("cl-ana.makeres-graphviz" ,sbcl-cl-ana.makeres-graphviz)
9448 ("cl-ana.makeres-macro" ,sbcl-cl-ana.makeres-macro)
9449 ("cl-ana.makeres-progress" ,sbcl-cl-ana.makeres-progress)
9450 ("cl-ana.makeres-table" ,sbcl-cl-ana.makeres-table)
9451 ("cl-ana.makeres-utils" ,sbcl-cl-ana.makeres-utils)
9452 ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
9453 ("cl-ana.ntuple-table" ,sbcl-cl-ana.ntuple-table)
9454 ("cl-ana.package-utils" ,sbcl-cl-ana.package-utils)
9455 ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
9456 ("cl-ana.plotting" ,sbcl-cl-ana.plotting)
9457 ("cl-ana.quantity" ,sbcl-cl-ana.quantity)
9458 ("cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
9459 ("cl-ana.serialization" ,sbcl-cl-ana.serialization)
9460 ("cl-ana.statistics" ,sbcl-cl-ana.statistics)
9461 ("cl-ana.statistical-learning" ,sbcl-cl-ana.statistical-learning)
9462 ("cl-ana.table" ,sbcl-cl-ana.table)
9463 ("cl-ana.table-utils" ,sbcl-cl-ana.table-utils)
9464 ("cl-ana.table-viewing" ,sbcl-cl-ana.table-viewing)
9465 ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
9466 ("libffi" ,libffi)))
9468 `(("cl-fad" ,sbcl-cl-fad)))
9470 (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
9471 ((#:asd-file _ "") "cl-ana.asd")
9472 ((#:asd-system-name _ #f) "cl-ana")))))
9474 (define-public cl-ana
9475 (sbcl-package->cl-source-package sbcl-cl-ana))
9477 (define-public sbcl-archive
9478 (let ((commit "631271c091ed02994bec3980cb288a2cf32c7cdc")
9481 (name "sbcl-archive")
9482 (version (git-version "0.9" revision commit))
9486 (url "https://github.com/sharplispers/archive")
9488 (file-name (git-file-name name version))
9491 "0pvsc9fmybx7rxd0kmzq4shi6hszdpwdc1sfy7jwyfxf8n3hnv4p"))))
9492 (build-system asdf-build-system/sbcl)
9494 `(("cl-fad" ,sbcl-cl-fad)
9495 ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
9496 (synopsis "Common Lisp library for tar and cpio archives")
9498 "This is a Common Lisp library to read and write disk-based file
9499 archives such as those generated by the tar and cpio programs on Unix.")
9500 (home-page "https://github.com/sharplispers/archive")
9501 (license license:bsd-3))))
9503 (define-public cl-archive
9504 (sbcl-package->cl-source-package sbcl-archive))
9506 (define-public ecl-archive
9507 (sbcl-package->ecl-package sbcl-archive))
9509 (define-public sbcl-misc-extensions
9510 (let ((commit "101c05112bf2f1e1bbf527396822d2f50ca6327a")
9513 (name "sbcl-misc-extensions")
9514 (version (git-version "3.3" revision commit))
9519 (url "https://gitlab.common-lisp.net/misc-extensions/devel.git")
9521 (file-name (git-file-name name version))
9524 "0gz5f4p70qzilnxsnf5lih2n9m4wjcw8hlw4w8mpn9jyhyppyyv0"))))
9525 (build-system asdf-build-system/sbcl)
9526 (synopsis "Collection of small macros and extensions for Common Lisp")
9528 "This project is intended as a catchall for small, general-purpose
9529 extensions to Common Lisp. It contains:
9532 @item @code{new-let}, a macro that combines and generalizes @code{let},
9533 @code{let*} and @code{multiple-value-bind},
9534 @item @code{gmap}, an iteration macro that generalizes @code{map}.
9536 (home-page "https://common-lisp.net/project/misc-extensions/")
9537 (license license:public-domain))))
9539 (define-public cl-misc-extensions
9540 (sbcl-package->cl-source-package sbcl-misc-extensions))
9542 (define-public ecl-misc-extensions
9543 (sbcl-package->ecl-package sbcl-misc-extensions))
9545 (define-public sbcl-mt19937
9547 (name "sbcl-mt19937")
9552 (uri (string-append "https://common-lisp.net/project/asdf-packaging/"
9553 "mt19937-latest.tar.gz"))
9556 "1iw636b0iw5ygkv02y8i41lh7xj0acglv0hg5agryn0zzi2nf1xv"))))
9557 (build-system asdf-build-system/sbcl)
9558 (synopsis "Mersenne Twister pseudo-random number generator")
9560 "MT19937 is a portable Mersenne Twister pseudo-random number generator
9562 (home-page "https://www.cliki.net/mt19937")
9563 (license license:public-domain)))
9565 (define-public cl-mt19937
9566 (sbcl-package->cl-source-package sbcl-mt19937))
9568 (define-public ecl-mt19937
9569 (sbcl-package->ecl-package sbcl-mt19937))
9571 (define-public sbcl-fset
9572 (let ((commit "6d2f9ded8934d2b42f2571a0ba5bda091037d852")
9576 (version (git-version "1.3.2" revision commit))
9581 (url "https://github.com/slburson/fset")
9583 (file-name (git-file-name name version))
9586 "127acblwrbqicx47h6sgvknz1cqyfn8p4xkhkn1m7hxh8w5gk1zy"))
9588 ;; Remove obsolete copy of system definition.
9589 (delete-file "Code/fset.asd")
9591 (build-system asdf-build-system/sbcl)
9593 `(("misc-extensions" ,sbcl-misc-extensions)
9594 ("mt19937" ,sbcl-mt19937)
9595 ("named-readtables" ,sbcl-named-readtables)))
9596 (synopsis "Functional set-theoretic collections library")
9598 "FSet is a functional set-theoretic collections library for Common Lisp.
9599 Functional means that all update operations return a new collection rather than
9600 modifying an existing one in place. Set-theoretic means that collections may
9601 be nested arbitrarily with no additional programmer effort; for instance, sets
9602 may contain sets, maps may be keyed by sets, etc.")
9603 (home-page "https://common-lisp.net/project/fset/Site/index.html")
9604 (license license:llgpl))))
9606 (define-public cl-fset
9607 (sbcl-package->cl-source-package sbcl-fset))
9609 (define-public sbcl-cl-cont
9610 (let ((commit "fc1fa7e6eb64894fdca13e688e6015fad5290d2a")
9613 (name "sbcl-cl-cont")
9614 (version (git-version "0.3.8" revision commit))
9619 (url "https://gitlab.common-lisp.net/cl-cont/cl-cont.git")
9621 (file-name (git-file-name name version))
9624 "1zf8zvb0i6jm3hhfks4w74hibm6avgc6f9s1qwgjrn2bcik8lrvz"))))
9625 (build-system asdf-build-system/sbcl)
9627 `(("alexandria" ,sbcl-alexandria)
9628 ("closer-mop" ,sbcl-closer-mop)))
9631 (synopsis "Delimited continuations for Common Lisp")
9633 "This is a library that implements delimited continuations by
9634 transforming Common Lisp code to continuation passing style.")
9635 (home-page "https://common-lisp.net/project/cl-cont/")
9636 (license license:llgpl))))
9638 (define-public cl-cont
9639 (sbcl-package->cl-source-package sbcl-cl-cont))
9641 (define-public ecl-cl-cont
9642 (sbcl-package->ecl-package sbcl-cl-cont))
9644 (define-public sbcl-cl-coroutine
9645 (let ((commit "de098f8d5debd8b14ef6864b5bdcbbf5ddbcfd72")
9648 (name "sbcl-cl-coroutine")
9649 (version (git-version "0.1" revision commit))
9654 (url "https://github.com/takagi/cl-coroutine")
9656 (file-name (git-file-name name version))
9659 "1cqdhdjxffgfs116l1swjlsmcbly0xgcgrckvaajd566idj9yj4l"))))
9660 (build-system asdf-build-system/sbcl)
9662 `(("alexandria" ,sbcl-alexandria)
9663 ("cl-cont" ,sbcl-cl-cont)))
9665 `(("prove" ,sbcl-prove)))
9667 `(;; TODO: Fix the tests. They fail with:
9668 ;; "Component CL-COROUTINE-ASD::CL-COROUTINE-TEST not found"
9671 (modify-phases %standard-phases
9672 (add-after 'unpack 'fix-tests
9674 (substitute* "cl-coroutine-test.asd"
9678 (synopsis "Coroutine library for Common Lisp")
9680 "This is a coroutine library for Common Lisp implemented using the
9681 continuations of the @code{cl-cont} library.")
9682 (home-page "https://github.com/takagi/cl-coroutine")
9683 (license license:llgpl))))
9685 (define-public cl-coroutine
9686 (sbcl-package->cl-source-package sbcl-cl-coroutine))
9688 (define-public ecl-cl-coroutine
9689 (sbcl-package->ecl-package sbcl-cl-coroutine))
9691 (define-public sbcl-vom
9692 (let ((commit "1aeafeb5b74c53741b79497e0ef4acf85c92ff24")
9696 (version (git-version "0.1.4" revision commit))
9701 (url "https://github.com/orthecreedence/vom")
9703 (file-name (git-file-name name version))
9706 "0536kppj76ax4lrxhv42npkfjsmx45km2g439vf9jmw3apinz9cy"))))
9707 (build-system asdf-build-system/sbcl)
9708 (synopsis "Tiny logging utility for Common Lisp")
9710 "Vom is a logging library for Common Lisp. It's goal is to be useful
9711 and small. It does not provide a lot of features as other loggers do, but
9712 has a small codebase that's easy to understand and use.")
9713 (home-page "https://github.com/orthecreedence/vom")
9714 (license license:expat))))
9716 (define-public cl-vom
9717 (sbcl-package->cl-source-package sbcl-vom))
9719 (define-public ecl-vom
9720 (sbcl-package->ecl-package sbcl-vom))
9722 (define-public sbcl-cl-libuv
9723 (let ((commit "32100c023c518038d0670a103eaa4d50dd785d29")
9726 (name "sbcl-cl-libuv")
9727 (version (git-version "0.1.6" revision commit))
9732 (url "https://github.com/orthecreedence/cl-libuv")
9734 (file-name (git-file-name name version))
9737 "1kwix4si8a8hza34ab2k7whrh7z0yrmx39v2wc3qblv9m244jkh1"))))
9738 (build-system asdf-build-system/sbcl)
9740 `(("alexandria" ,sbcl-alexandria)
9742 ("cffi-grovel" ,sbcl-cffi-grovel)
9746 (modify-phases %standard-phases
9747 (add-after 'unpack 'fix-paths
9748 (lambda* (#:key inputs #:allow-other-keys)
9749 (substitute* "lib.lisp"
9750 (("/usr/lib/libuv.so")
9751 (string-append (assoc-ref inputs "libuv")
9754 (add-after 'fix-paths 'fix-system-definition
9756 (substitute* "cl-libuv.asd"
9757 (("#:cffi #:alexandria")
9758 "#:cffi #:cffi-grovel #:alexandria"))
9760 (synopsis "Common Lisp bindings to libuv")
9762 "This library provides low-level libuv bindings for Common Lisp.")
9763 (home-page "https://github.com/orthecreedence/cl-libuv")
9764 (license license:expat))))
9766 (define-public cl-libuv
9767 (sbcl-package->cl-source-package sbcl-cl-libuv))
9769 (define-public ecl-cl-libuv
9770 (sbcl-package->ecl-package sbcl-cl-libuv))
9772 (define-public sbcl-cl-async-base
9773 (let ((commit "f6423e44404a44434d803605e0d2e17199158e28")
9776 (name "sbcl-cl-async-base")
9777 (version (git-version "0.6.1" revision commit))
9782 (url "https://github.com/orthecreedence/cl-async")
9784 (file-name (git-file-name name version))
9787 "11xi9dxb8mjgwzrkj88i0xkgk26z9w9ddxzbv6xsvfc1d4x5cf4x"))))
9788 (build-system asdf-build-system/sbcl)
9790 `(("bordeaux-threads" ,sbcl-bordeaux-threads)
9792 ("cl-libuv" ,sbcl-cl-libuv)))
9794 `(#:asd-file "cl-async.asd"))
9795 (synopsis "Base system for cl-async")
9797 "Cl-async is a library for general purpose, non-blocking programming in
9798 Common Lisp. It uses the libuv library as backend.")
9799 (home-page "https://orthecreedence.github.io/cl-async/")
9800 (license license:expat))))
9802 (define-public cl-async-base
9803 (sbcl-package->cl-source-package sbcl-cl-async-base))
9805 (define-public ecl-cl-async-base
9806 (sbcl-package->ecl-package sbcl-cl-async-base))
9808 (define-public sbcl-cl-async-util
9810 (inherit sbcl-cl-async-base)
9811 (name "sbcl-cl-async-util")
9813 `(("bordeaux-threads" ,sbcl-bordeaux-threads)
9815 ("cl-async-base" ,sbcl-cl-async-base)
9816 ("cl-libuv" ,sbcl-cl-libuv)
9817 ("cl-ppcre" ,sbcl-cl-ppcre)
9818 ("fast-io" ,sbcl-fast-io)
9820 (synopsis "Internal utilities for cl-async")))
9822 (define-public cl-async-util
9823 (sbcl-package->cl-source-package sbcl-cl-async-util))
9825 (define-public ecl-cl-async-util
9826 (sbcl-package->ecl-package sbcl-cl-async-util))
9828 (define-public sbcl-cl-async
9830 (inherit sbcl-cl-async-base)
9831 (name "sbcl-cl-async")
9833 `(("babel" ,sbcl-babel)
9835 ("cl-async-base" ,sbcl-cl-async-base)
9836 ("cl-async-util" ,sbcl-cl-async-util)
9837 ("cl-libuv" ,sbcl-cl-libuv)
9838 ("cl-ppcre" ,sbcl-cl-ppcre)
9839 ("static-vectors" ,sbcl-static-vectors)
9840 ("trivial-features" ,sbcl-trivial-features)
9841 ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
9842 (synopsis "Asynchronous operations for Common Lisp")))
9844 (define-public cl-async
9845 (sbcl-package->cl-source-package sbcl-cl-async))
9847 (define-public ecl-cl-async
9848 (sbcl-package->ecl-package sbcl-cl-async))
9850 (define-public sbcl-cl-async-repl
9852 (inherit sbcl-cl-async-base)
9853 (name "sbcl-cl-async-repl")
9855 `(("bordeaux-threads" ,sbcl-bordeaux-threads)
9856 ("cl-async" ,sbcl-cl-async)))
9858 (substitute-keyword-arguments (package-arguments sbcl-cl-async-base)
9859 ((#:asd-file _ "") "cl-async-repl.asd")))
9860 (synopsis "REPL integration for cl-async")))
9862 (define-public cl-async-repl
9863 (sbcl-package->cl-source-package sbcl-cl-async-repl))
9865 (define-public ecl-cl-async-repl
9866 (sbcl-package->ecl-package sbcl-cl-async-repl))
9868 (define-public sbcl-cl-async-ssl
9870 (inherit sbcl-cl-async-base)
9871 (name "sbcl-cl-async-ssl")
9873 `(("cffi" ,sbcl-cffi)
9874 ("cl-async" ,sbcl-cl-async)
9875 ("openssl" ,openssl)
9878 (substitute-keyword-arguments (package-arguments sbcl-cl-async-base)
9879 ((#:asd-file _ "") "cl-async-ssl.asd")
9880 ((#:phases phases '%standard-phases)
9881 `(modify-phases ,phases
9882 (add-after 'unpack 'fix-paths
9883 (lambda* (#:key inputs #:allow-other-keys)
9884 (substitute* "src/ssl/package.lisp"
9886 (string-append (assoc-ref inputs "openssl")
9887 "/lib/libcrypto.so"))
9889 (string-append (assoc-ref inputs "openssl")
9892 (synopsis "SSL wrapper around cl-async socket implementation")))
9894 (define-public cl-async-ssl
9895 (sbcl-package->cl-source-package sbcl-cl-async-ssl))
9897 (define-public ecl-cl-async-ssl
9898 (sbcl-package->ecl-package sbcl-cl-async-ssl))
9900 (define-public sbcl-blackbird
9901 (let ((commit "d361f81c1411dec07f6c2dcb11c78f7aea9aaca8")
9904 (name "sbcl-blackbird")
9905 (version (git-version "0.5.2" revision commit))
9910 (url "https://github.com/orthecreedence/blackbird")
9912 (file-name (git-file-name name version))
9915 "0xfds5yaya64arzr7w1x38karyz11swzbhxx1afldpradj9dh19c"))))
9916 (build-system asdf-build-system/sbcl)
9918 `(("vom" ,sbcl-vom)))
9920 `(("cl-async" ,sbcl-cl-async)
9921 ("fiveam" ,sbcl-fiveam)))
9922 (synopsis "Promise implementation for Common Lisp")
9924 "This is a standalone promise implementation for Common Lisp. It is
9925 the successor to the now-deprecated cl-async-future project.")
9926 (home-page "https://orthecreedence.github.io/blackbird/")
9927 (license license:expat))))
9929 (define-public cl-blackbird
9930 (sbcl-package->cl-source-package sbcl-blackbird))
9932 (define-public ecl-blackbird
9933 (sbcl-package->ecl-package sbcl-blackbird))
9935 (define-public sbcl-cl-async-future
9936 (let ((commit "ee36c22a69a9516407458d2ed8b475f1fc473959")
9939 (name "sbcl-cl-async-future")
9940 (version (git-version "0.4.4.1" revision commit))
9945 (url "https://github.com/orthecreedence/cl-async-future")
9947 (file-name (git-file-name name version))
9950 "0z0sc7qlzzxk99f4l26zp6rai9kv0kj0f599sxai5s44p17zbbvh"))))
9951 (build-system asdf-build-system/sbcl)
9953 `(("blackbird" ,sbcl-blackbird)))
9955 `(("cl-async" ,sbcl-cl-async)
9957 (synopsis "Futures implementation for Common Lisp")
9959 "This is futures implementation for Common Lisp. It plugs in nicely
9961 (home-page "https://orthecreedence.github.io/cl-async/future")
9962 (license license:expat))))
9964 (define-public cl-async-future
9965 (sbcl-package->cl-source-package sbcl-cl-async-future))
9967 (define-public ecl-cl-async-future
9968 (sbcl-package->ecl-package sbcl-cl-async-future))
9970 (define-public sbcl-green-threads
9971 (let ((commit "fff5ebecb441a37e5c511773716aafd84a3c5840")
9974 (name "sbcl-green-threads")
9975 (version (git-version "0.3" revision commit))
9980 (url "https://github.com/thezerobit/green-threads")
9982 (file-name (git-file-name name version))
9985 "1czw7nr0dwfps76h8hjvglk1wdh53yqbfbvv30whwbgqx33iippz"))))
9986 (build-system asdf-build-system/sbcl)
9988 `(("cl-async-future" ,sbcl-cl-async-future)
9989 ("cl-cont" ,sbcl-cl-cont)))
9991 `(("prove" ,sbcl-prove)))
9993 `(;; TODO: Fix the tests. They fail with:
9994 ;; "The function BLACKBIRD::PROMISE-VALUES is undefined"
9997 (modify-phases %standard-phases
9998 (add-after 'unpack 'fix-tests
10000 (substitute* "green-threads-test.asd"
10004 (synopsis "Cooperative multitasking library for Common Lisp")
10006 "This library allows for cooperative multitasking with help of cl-cont
10007 for continuations. It tries to mimic the API of bordeaux-threads as much as
10009 (home-page "https://github.com/thezerobit/green-threads")
10010 (license license:bsd-3))))
10012 (define-public cl-green-threads
10013 (sbcl-package->cl-source-package sbcl-green-threads))
10015 (define-public ecl-green-threads
10016 (sbcl-package->ecl-package sbcl-green-threads))
10018 (define-public sbcl-cl-base32
10019 (let ((commit "8cdee06fab397f7b0a19583b57e7f0c98405be85")
10022 (name "sbcl-cl-base32")
10023 (version (git-version "0.1" revision commit))
10027 (uri (git-reference
10028 (url "https://github.com/hargettp/cl-base32")
10030 (file-name (git-file-name name version))
10032 (base32 "17jrng8jb05d64ggyd11hp308c2fl5drvf9g175blgrkkl8l4mf8"))))
10033 (build-system asdf-build-system/sbcl)
10035 `(("lisp-unit" ,sbcl-lisp-unit)))
10036 (synopsis "Common Lisp library for base32 encoding and decoding")
10038 "This package provides functions for base32 encoding and decoding as
10039 defined in RFC4648.")
10040 (home-page "https://github.com/hargettp/cl-base32")
10041 (license license:expat))))
10043 (define-public cl-base32
10044 (sbcl-package->cl-source-package sbcl-cl-base32))
10046 (define-public ecl-cl-base32
10047 (sbcl-package->ecl-package sbcl-cl-base32))
10049 (define-public sbcl-cl-z85
10050 (let ((commit "85b3951a9cfa2603acb6aee15567684f9a108098")
10053 (name "sbcl-cl-z85")
10054 (version (git-version "1.0" revision commit))
10058 (uri (git-reference
10059 (url "https://github.com/glv2/cl-z85")
10061 (file-name (git-file-name name version))
10063 (base32 "0r27pidjaxbm7k1rr90nnajwl5xm2kp65g1fv0fva17lzy45z1mp"))))
10064 (build-system asdf-build-system/sbcl)
10066 `(("cl-octet-streams" ,sbcl-cl-octet-streams)
10067 ("fiveam" ,sbcl-fiveam)))
10068 (synopsis "Common Lisp library for Z85 encoding and decoding")
10070 "This package provides functions to encode or decode byte vectors or
10071 byte streams using the Z85 format, which is a base-85 encoding used by
10073 (home-page "https://github.com/glv2/cl-z85")
10074 (license license:gpl3+))))
10076 (define-public cl-z85
10077 (sbcl-package->cl-source-package sbcl-cl-z85))
10079 (define-public ecl-cl-z85
10080 (sbcl-package->ecl-package sbcl-cl-z85))
10082 (define-public sbcl-ltk
10089 (uri (git-reference
10090 (url "https://github.com/herth/ltk")
10092 (file-name (git-file-name name version))
10094 (base32 "13l2q4mskzilya9xh5wy2xvy30lwn104bd8wrq6ifds56r82iy3x"))))
10095 (build-system asdf-build-system/sbcl)
10097 `(("imagemagick" ,imagemagick)
10100 `(#:asd-file "ltk/ltk.asd"
10102 #:phases (modify-phases %standard-phases
10103 (add-after 'unpack 'fix-paths
10104 (lambda* (#:key inputs #:allow-other-keys)
10105 (substitute* "ltk/ltk.lisp"
10106 (("#-freebsd \"wish\"")
10107 (string-append "#-freebsd \""
10108 (assoc-ref inputs "tk")
10110 (("do-execute \"convert\"")
10111 (string-append "do-execute \""
10112 (assoc-ref inputs "imagemagick")
10113 "/bin/convert\"")))
10115 (synopsis "Common Lisp bindings for the Tk GUI toolkit")
10117 "LTK is a Common Lisp binding for the Tk graphics toolkit. It is written
10118 in pure Common Lisp and does not require any Tk knowledge for its usage.")
10119 (home-page "http://www.peter-herth.de/ltk/")
10120 (license license:llgpl)))
10122 (define-public cl-ltk
10123 (sbcl-package->cl-source-package sbcl-ltk))
10125 (define-public ecl-ltk
10126 (sbcl-package->ecl-package sbcl-ltk))
10128 (define-public sbcl-ltk-mw
10131 (name "sbcl-ltk-mw")
10133 `(("ltk" ,sbcl-ltk)))
10135 (substitute-keyword-arguments (package-arguments sbcl-ltk)
10136 ((#:asd-file _) "ltk/ltk-mw.asd")
10137 ((#:phases _) '%standard-phases)))
10138 (synopsis "Extra widgets for LTK")
10140 "This is a collection of higher-level widgets built on top of LTK.")))
10142 (define-public cl-ltk-mw
10143 (sbcl-package->cl-source-package sbcl-ltk-mw))
10145 (define-public ecl-ltk-mw
10146 (sbcl-package->ecl-package sbcl-ltk-mw))
10148 (define-public sbcl-ltk-remote
10151 (name "sbcl-ltk-remote")
10153 `(("ltk" ,sbcl-ltk)))
10155 (substitute-keyword-arguments (package-arguments sbcl-ltk)
10156 ((#:asd-file _) "ltk/ltk-remote.asd")
10157 ((#:phases _) '%standard-phases)))
10158 (synopsis "Remote GUI support for LTK")
10160 "This LTK extension allows the GUI to be displayed on a computer different
10161 from the one running the Lisp program by using a TCP connection.")))
10163 (define-public cl-ltk-remote
10164 (sbcl-package->cl-source-package sbcl-ltk-remote))
10166 (define-public sbcl-cl-lex
10167 (let ((commit "f2dbbe25ef553005fb402d9a6203180c3fa1093b")
10170 (name "sbcl-cl-lex")
10171 (version (git-version "1.1.3" revision commit))
10175 (uri (git-reference
10176 (url "https://github.com/djr7C4/cl-lex")
10178 (file-name (git-file-name name version))
10180 (base32 "1kg50f76bfpfxcv4dfivq1n9a0xlsra2ajb0vd68lxwgbidgyc2y"))))
10181 (build-system asdf-build-system/sbcl)
10183 `(("cl-ppcre" ,sbcl-cl-ppcre)))
10184 (synopsis "Common Lisp macros for generating lexical analyzers")
10186 "This is a Common Lisp library providing a set of macros for generating
10187 lexical analyzers automatically. The lexers generated using @code{cl-lex} can
10188 be used with @code{cl-yacc}.")
10189 (home-page "https://github.com/djr7C4/cl-lex")
10190 (license license:gpl3))))
10192 (define-public cl-lex
10193 (sbcl-package->cl-source-package sbcl-cl-lex))
10195 (define-public ecl-cl-lex
10196 (sbcl-package->ecl-package sbcl-cl-lex))
10198 (define-public sbcl-clunit2
10199 (let ((commit "5e28343734eb9b7aee39306a614af92c1062d50b")
10202 (name "sbcl-clunit2")
10203 (version (git-version "0.2.4" revision commit))
10207 (uri (git-reference
10208 (url "https://notabug.org/cage/clunit2.git")
10210 (file-name (git-file-name name version))
10212 (base32 "1ngiapfki6nm8a555mzhb5p7ch79i3w665za5bmb5j7q34fy80vw"))))
10213 (build-system asdf-build-system/sbcl)
10214 (synopsis "Unit testing framework for Common Lisp")
10216 "CLUnit is a Common Lisp unit testing framework. It is designed to be
10217 easy to use so that you can quickly start testing.")
10218 (home-page "https://notabug.org/cage/clunit2")
10219 (license license:expat))))
10221 (define-public cl-clunit2
10222 (sbcl-package->cl-source-package sbcl-clunit2))
10224 (define-public ecl-clunit2
10225 (sbcl-package->ecl-package sbcl-clunit2))
10227 (define-public sbcl-cl-colors2
10228 (let ((commit "795aedee593b095fecde574bd999b520dd03ed24")
10231 (name "sbcl-cl-colors2")
10232 (version (git-version "0.2.1" revision commit))
10236 (uri (git-reference
10237 (url "https://notabug.org/cage/cl-colors2.git")
10239 (file-name (git-file-name name version))
10241 (base32 "0hlyf4h5chkjdp9armla5w4kw5acikk159sym7y8c4jbjp9x47ih"))))
10242 (build-system asdf-build-system/sbcl)
10244 `(("clunit2" ,sbcl-clunit2)))
10246 `(("alexandria" ,sbcl-alexandria)
10247 ("cl-ppcre" ,sbcl-cl-ppcre)))
10248 (synopsis "Color library for Common Lisp")
10250 "This is a very simple color library for Common Lisp, providing:
10253 @item Types for representing colors in HSV and RGB spaces.
10254 @item Simple conversion functions between the above types (and also
10255 hexadecimal representation for RGB).
10256 @item Some predefined colors (currently X11 color names -- of course
10257 the library does not depend on X11).
10259 (home-page "https://notabug.org/cage/cl-colors2")
10260 (license license:boost1.0))))
10262 (define-public cl-colors2
10263 (sbcl-package->cl-source-package sbcl-cl-colors2))
10265 (define-public ecl-cl-colors2
10266 (sbcl-package->ecl-package sbcl-cl-colors2))
10268 (define-public sbcl-cl-jpeg
10269 (let ((commit "ec557038128df6895fbfb743bfe8faf8ec2534af")
10272 (name "sbcl-cl-jpeg")
10273 (version (git-version "2.8" revision commit))
10277 (uri (git-reference
10278 (url "https://github.com/sharplispers/cl-jpeg")
10280 (file-name (git-file-name name version))
10282 (base32 "1bkkiqz8fqldlj1wbmrccjsvxcwj98h6s4b6gslr3cg2wmdv5xmy"))))
10283 (build-system asdf-build-system/sbcl)
10284 (synopsis "JPEG image library for Common Lisp")
10286 "This is a baseline JPEG codec written in Common Lisp. It can be used
10287 for reading and writing JPEG image files.")
10288 (home-page "https://github.com/sharplispers/cl-jpeg")
10289 (license license:bsd-3))))
10291 (define-public cl-jpeg
10292 (sbcl-package->cl-source-package sbcl-cl-jpeg))
10294 (define-public ecl-cl-jpeg
10295 (sbcl-package->ecl-package sbcl-cl-jpeg))
10297 (define-public sbcl-nodgui
10298 (let ((commit "bc59ed9b787dfc9e68ae3bd7f7e8507c5c619212")
10301 (name "sbcl-nodgui")
10302 (version (git-version "0.0.5" revision commit))
10306 (uri (git-reference
10307 (url "https://notabug.org/cage/nodgui.git")
10309 (file-name (git-file-name name version))
10311 (base32 "0xx0dk54d882i598ydnwmy7mnfk0b7vib3ddsgpqxhjck1rwq8l8"))))
10312 (build-system asdf-build-system/sbcl)
10314 `(("alexandria" ,sbcl-alexandria)
10315 ("bordeaux-threads" ,sbcl-bordeaux-threads)
10316 ("cl-colors2" ,sbcl-cl-colors2)
10317 ("cl-jpeg" ,sbcl-cl-jpeg)
10318 ("cl-lex" ,sbcl-cl-lex)
10319 ("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)
10320 ("cl-unicode" ,sbcl-cl-unicode)
10321 ("cl-yacc" ,sbcl-cl-yacc)
10322 ("clunit2" ,sbcl-clunit2)
10323 ("named-readtables" ,sbcl-named-readtables)
10324 ("parse-number" ,sbcl-parse-number)
10327 `(#:phases (modify-phases %standard-phases
10328 (add-after 'unpack 'fix-paths
10329 (lambda* (#:key inputs #:allow-other-keys)
10330 (substitute* "src/wish-communication.lisp"
10331 (("#-freebsd \"wish\"")
10332 (string-append "#-freebsd \""
10333 (assoc-ref inputs "tk")
10336 (synopsis "Common Lisp bindings for the Tk GUI toolkit")
10338 "Nodgui (@emph{No Drama GUI}) is a Common Lisp binding for the Tk GUI
10339 toolkit. It also provides a few additional widgets more than the standard Tk
10341 (home-page "https://www.autistici.org/interzona/nodgui.html")
10342 (license license:llgpl))))
10344 (define-public cl-nodgui
10345 (sbcl-package->cl-source-package sbcl-nodgui))
10347 (define-public ecl-nodgui
10348 (sbcl-package->ecl-package sbcl-nodgui))
10350 (define-public sbcl-salza2
10352 (name "sbcl-salza2")
10357 (uri (git-reference
10358 (url "https://github.com/xach/salza2")
10359 (commit (string-append "release-" version))))
10360 (file-name (git-file-name name version))
10362 (base32 "0p38rj4gq7j5k807php7hrz7l2zyyfshv8i9yms7i8lkgg3433ki"))))
10363 (build-system asdf-build-system/sbcl)
10364 (synopsis "Common Lisp library for zlib, deflate and gzip compression")
10366 "Salza2 is a Common Lisp library for creating compressed data in the zlib,
10367 deflate, or gzip data formats, described in RFC 1950, RFC 1951, and RFC 1952,
10369 (home-page "https://www.xach.com/lisp/salza2/")
10370 (license license:bsd-2)))
10372 (define-public cl-salza2
10373 (sbcl-package->cl-source-package sbcl-salza2))
10375 (define-public ecl-salza2
10376 (sbcl-package->ecl-package sbcl-salza2))
10378 (define-public sbcl-png-read
10379 (let ((commit "ec29f38a689972b9f1373f13bbbcd6b05deada88")
10382 (name "sbcl-png-read")
10383 (version (git-version "0.3.1" revision commit))
10387 (uri (git-reference
10388 (url "https://github.com/Ramarren/png-read")
10390 (file-name (git-file-name name version))
10392 (base32 "0vyczbcwskrygrf1hgrsnk0jil8skmvf1kiaalw5jps4fjrfdkw0"))))
10393 (build-system asdf-build-system/sbcl)
10395 `(("babel" ,sbcl-babel)
10396 ("chipz" ,sbcl-chipz)
10397 ("iterate" ,sbcl-iterate)))
10398 (synopsis "PNG decoder for Common Lisp")
10399 (description "This is a Common Lisp library for reading PNG images.")
10400 (home-page "https://github.com/Ramarren/png-read")
10401 (license license:bsd-3))))
10403 (define-public cl-png-read
10404 (sbcl-package->cl-source-package sbcl-png-read))
10406 (define-public ecl-png-read
10407 (sbcl-package->ecl-package sbcl-png-read))
10409 (define-public sbcl-zpng
10416 (uri (git-reference
10417 (url "https://github.com/xach/zpng")
10418 (commit (string-append "release-" version))))
10419 (file-name (git-file-name name version))
10421 (base32 "0b3ag3jhl3z7kdls3ahdsdxsfhhw5qrizk769984f4wkxhb69rcm"))))
10422 (build-system asdf-build-system/sbcl)
10424 `(("salza2" ,sbcl-salza2)))
10425 (synopsis "PNG encoder for Common Lisp")
10426 (description "This is a Common Lisp library for creating PNG images.")
10427 (home-page "https://www.xach.com/lisp/zpng/")
10428 (license license:bsd-2)))
10430 (define-public cl-zpng
10431 (sbcl-package->cl-source-package sbcl-zpng))
10433 (define-public ecl-zpng
10434 (sbcl-package->ecl-package sbcl-zpng))
10436 (define-public sbcl-cl-qrencode
10438 (name "sbcl-cl-qrencode")
10443 (uri (git-reference
10444 (url "https://github.com/jnjcc/cl-qrencode")
10445 (commit (string-append "v" version))))
10446 (file-name (git-file-name name version))
10448 (base32 "1l5k131dchbf6cj8a8xqa731790p01p3qa1kdy2wa9dawy3ymkxr"))))
10449 (build-system asdf-build-system/sbcl)
10451 `(("lisp-unit" ,sbcl-lisp-unit)))
10453 `(("zpng" ,sbcl-zpng)))
10454 (synopsis "QR code encoder for Common Lisp")
10456 "This Common Lisp library provides function to make QR codes and to save
10457 them as PNG files.")
10458 (home-page "https://github.com/jnjcc/cl-qrencode")
10459 (license license:gpl2+)))
10461 (define-public cl-qrencode
10462 (sbcl-package->cl-source-package sbcl-cl-qrencode))
10464 (define-public ecl-cl-qrencode
10465 (sbcl-package->ecl-package sbcl-cl-qrencode))
10467 (define-public sbcl-hdf5-cffi
10468 (let ((commit "5b5c88f191e470e4fe96b462334e3ce0806eed5c")
10471 (name "sbcl-hdf5-cffi")
10472 (version (git-version "1.8.18" revision commit))
10476 (uri (git-reference
10477 (url "https://github.com/hdfgroup/hdf5-cffi")
10479 (file-name (git-file-name name version))
10482 "0vda3075423xz83qky998lpac5b04dwfv7bwgh9jq8cs5v0zrxjf"))))
10483 (build-system asdf-build-system/sbcl)
10484 (synopsis "Common Lisp bindings for the HDF5 library")
10486 "@code{hdf5-cffi} is a CFFI wrapper for the HDF5 library.")
10487 (home-page "https://github.com/hdfgroup/hdf5-cffi")
10488 (license (license:non-copyleft
10489 (string-append "https://github.com/HDFGroup/hdf5-cffi/raw/"
10493 `(("cffi" ,sbcl-cffi)
10494 ("cffi-grovel" ,sbcl-cffi-grovel)
10495 ("hdf5" ,hdf5-1.10)))
10497 `(("fiveam" ,sbcl-fiveam)))
10499 `(#:asd-system-name "hdf5-cffi"
10500 #:asd-file "hdf5-cffi.asd"
10501 #:test-asd-file "hdf5-cffi.test.asd"
10502 ;; Tests depend on hdf5-cffi.examples.asd in addition to hdf5-cffi.asd,
10503 ;; I don't know if there is a way to tell asdf-build-system to load
10504 ;; an additional system first, so tests are disabled.
10507 (modify-phases %standard-phases
10508 (add-after 'unpack 'fix-paths
10509 (lambda* (#:key inputs #:allow-other-keys)
10510 (substitute* "src/library.lisp"
10513 (assoc-ref inputs "hdf5")
10514 "/lib/libhdf5.so")))))
10515 (add-after 'unpack 'fix-dependencies
10516 (lambda* (#:key inputs #:allow-other-keys)
10517 (substitute* "hdf5-cffi.asd"
10518 ((":depends-on \\(:cffi\\)")
10519 ":depends-on (:cffi :cffi-grovel)"))
10520 (substitute* "hdf5-cffi.test.asd"
10521 ((":depends-on \\(:cffi :hdf5-cffi")
10522 ":depends-on (:cffi :cffi-grovel :hdf5-cffi"))))))))))
10524 (define-public cl-hdf5-cffi
10525 (sbcl-package->cl-source-package sbcl-hdf5-cffi))
10527 (define-public ecl-hdf5-cffi
10528 (sbcl-package->ecl-package sbcl-hdf5-cffi))
10530 (define-public sbcl-cl-randist
10532 (name "sbcl-cl-randist")
10537 (uri (git-reference
10538 (url "https://github.com/lvaruzza/cl-randist")
10539 (commit "f088a54b540a7adefab7c04094a6103f9edda3d0")))
10540 (file-name (git-file-name name version))
10543 "0l8hyd6nbxb7f50vyxz3rbbm7kgr1fnadc40jywy4xj5vi5kpj5g"))))
10544 (build-system asdf-build-system/sbcl)
10545 (synopsis "Random distributions for Common Lisp")
10547 "Manual translation from C to Common Lisp of some random number
10548 generation functions from the GSL library.")
10549 (home-page "https://github.com/lvaruzza/cl-randist")
10550 (license license:bsd-2)
10552 `(#:asd-system-name "cl-randist"
10553 #:asd-file "cl-randist.asd"
10556 (define-public cl-randist
10557 (sbcl-package->cl-source-package sbcl-cl-randist))
10559 (define-public ecl-cl-randist
10560 (sbcl-package->ecl-package sbcl-cl-randist))
10562 (define-public sbcl-float-features
10564 (name "sbcl-float-features")
10569 (uri (git-reference
10570 (url "https://github.com/Shinmera/float-features")
10571 (commit "d3ef60181635b0849aa28cfc238053b7ca4644b0")))
10572 (file-name (git-file-name name version))
10575 "0yj419k7n59x6rh3grwr6frgwwyria2il6f7wxpfazm8cskv4lzr"))))
10576 (build-system asdf-build-system/sbcl)
10577 (synopsis "Common Lisp IEEE float portability library")
10579 "Portability library for IEEE float features that are not
10580 covered by the Common Lisp standard.")
10581 (home-page "https://github.com/Shinmera/float-features")
10582 (license license:zlib)
10584 `(("documentation-utils" ,sbcl-documentation-utils)))
10586 `(#:asd-system-name "float-features"
10587 #:asd-file "float-features.asd"
10590 (define-public cl-float-features
10591 (sbcl-package->cl-source-package sbcl-float-features))
10593 (define-public ecl-float-features
10594 (sbcl-package->ecl-package sbcl-float-features))
10596 (define-public sbcl-function-cache
10598 (name "sbcl-function-cache")
10603 (uri (git-reference
10604 (url "https://github.com/AccelerationNet/function-cache")
10605 (commit "6a5ada401e57da2c8abf046f582029926e61fce8")))
10606 (file-name (git-file-name name version))
10609 "000vmd3f5rx5hs9nvphfric0gkzaadns31c6mxaslpv0k7pkrmc6"))))
10610 (build-system asdf-build-system/sbcl)
10611 (synopsis "Function caching / memoization library for Common Lisp")
10613 "A common lisp library that provides extensible function result
10614 caching based on arguments (an expanded form of memoization).")
10615 (home-page "https://github.com/AccelerationNet/function-cache")
10617 (license:non-copyleft
10618 "https://github.com/AccelerationNet/function-cache/blob/master/README.md"))
10620 `(("alexandria" ,sbcl-alexandria)
10621 ("cl-interpol" ,sbcl-cl-interpol)
10622 ("iterate" ,sbcl-iterate)
10623 ("symbol-munger" ,sbcl-symbol-munger)
10624 ("closer-mop" ,sbcl-closer-mop)))
10626 `(#:asd-system-name "function-cache"
10627 #:asd-file "function-cache.asd"
10630 (define-public cl-function-cache
10631 (sbcl-package->cl-source-package sbcl-function-cache))
10633 (define-public ecl-function-cache
10634 (sbcl-package->ecl-package sbcl-function-cache))
10636 (define-public sbcl-type-r
10637 (let ((commit "83c89e38f2f7a7b16f1012777ecaf878cfa6a267")
10640 (name "sbcl-type-r")
10641 (version (git-version "0.0.0" revision commit))
10645 (uri (git-reference
10646 (url "https://github.com/guicho271828/type-r")
10648 (file-name (git-file-name name version))
10651 "1arsxc2539rg8vbrdirz4xxj1b06mc6g6rqndz7a02g127qvk2sm"))))
10652 (build-system asdf-build-system/sbcl)
10653 (synopsis "Parser interface for Common Lisp built-in compound types")
10655 "Collections of accessor functions and patterns to access
10656 the elements in compound type specifier, e.g. @code{dimensions} in
10657 @code{(array element-type dimensions)}")
10658 (home-page "https://github.com/guicho271828/type-r")
10659 (license license:lgpl3+)
10661 `(("trivia" ,sbcl-trivia)
10662 ("alexandria" ,sbcl-alexandria)))
10664 `(("fiveam" ,sbcl-fiveam)))
10666 `(#:asd-system-name "type-r"
10667 #:asd-file "type-r.asd"
10668 #:test-asd-file "type-r.test.asd")))))
10670 (define-public cl-type-r
10671 (sbcl-package->cl-source-package sbcl-type-r))
10673 (define-public sbcl-trivialib-type-unify
10674 (let ((commit "62492ebf04db567dcf435ae84c50b7b8202ecf99")
10677 (name "sbcl-trivialib-type-unify")
10678 (version (git-version "0.1" revision commit))
10682 (uri (git-reference
10683 (url "https://github.com/guicho271828/trivialib.type-unify")
10685 (file-name (git-file-name name version))
10688 "1bkyfzbwv75p50zp8n1n9rh2r29pw3vgz91gmn2gzzkyq3khj1vh"))))
10689 (build-system asdf-build-system/sbcl)
10690 (synopsis "Common Lisp type unification")
10692 "Unifies a parametrized type specifier against an actual type specifier.
10693 Importantly, it handles complicated array-subtypes and number-related types
10695 (home-page "https://github.com/guicho271828/trivialib.type-unify")
10696 (license license:lgpl3+)
10698 `(("alexandria" ,sbcl-alexandria)
10699 ("trivia" ,sbcl-trivia)
10700 ("introspect-environment" ,sbcl-introspect-environment)
10701 ("type-r" ,sbcl-type-r)))
10703 `(("fiveam" ,sbcl-fiveam)))
10705 `(#:asd-system-name "trivialib.type-unify"
10706 #:asd-file "trivialib.type-unify.asd"
10707 #:test-asd-file "trivialib.type-unify.test.asd")))))
10709 (define-public cl-trivialib-type-unify
10710 (sbcl-package->cl-source-package sbcl-trivialib-type-unify))
10712 (define-public sbcl-specialized-function
10713 (let ((commit "b96b6afaf8358bf91cc0703e62a5a4ee20d2b7bc")
10716 (name "sbcl-specialized-function")
10717 (version (git-version "0.0.0" revision commit))
10721 (uri (git-reference
10722 (url "https://github.com/numcl/specialized-function")
10724 (file-name (git-file-name name version))
10727 "12j45ff0n26578vmfbhb9mfbdchw4wy023k0m2ppgl9s0z4bhjaj"))))
10728 (build-system asdf-build-system/sbcl)
10729 (synopsis "Julia-like dispatch for Common Lisp")
10731 "This library is part of NUMCL. It provides a macro
10732 @code{SPECIALIZED} that performs a Julia-like dispatch on the arguments,
10733 lazily compiling a type-specific version of the function from the same
10734 code. The main target of this macro is speed.")
10735 (home-page "https://github.com/numcl/specialized-function")
10736 (license license:lgpl3+)
10738 `(("trivia" ,sbcl-trivia)
10739 ("alexandria" ,sbcl-alexandria)
10740 ("iterate" ,sbcl-iterate)
10741 ("lisp-namespace" ,sbcl-lisp-namespace)
10742 ("type-r" ,sbcl-type-r)
10743 ("trivial-cltl2" ,sbcl-trivial-cltl2)))
10745 `(("fiveam" ,sbcl-fiveam)))
10747 `(#:asd-system-name "specialized-function"
10748 #:asd-file "specialized-function.asd"
10749 #:test-asd-file "specialized-function.test.asd")))))
10751 (define-public cl-specialized-function
10752 (sbcl-package->cl-source-package sbcl-specialized-function))
10754 (define-public sbcl-constantfold
10755 (let ((commit "0ff1d97a3fbcb89264f6a2af6ce62b73e7b421f4")
10758 (name "sbcl-constantfold")
10759 (version (git-version "0.1" revision commit))
10763 (uri (git-reference
10764 (url "https://github.com/numcl/constantfold")
10766 (file-name (git-file-name name version))
10769 "153h0569z6bff1qbad0bdssplwwny75l7ilqwcfqfdvzsxf9jh06"))))
10770 (build-system asdf-build-system/sbcl)
10771 (synopsis "Support library for numcl")
10773 "Support library for numcl. Registers a function as an
10774 additional form that is considered as a candidate for a constant.")
10775 (home-page "https://github.com/numcl/constantfold")
10776 (license license:lgpl3+)
10778 `(("trivia" ,sbcl-trivia)
10779 ("alexandria" ,sbcl-alexandria)
10780 ("iterate" ,sbcl-iterate)
10781 ("lisp-namespace" ,sbcl-lisp-namespace)))
10783 `(("fiveam" ,sbcl-fiveam)))
10785 `(#:asd-system-name "constantfold"
10786 #:asd-file "constantfold.asd"
10787 #:test-asd-file "constantfold.test.asd")))))
10789 (define-public cl-constantfold
10790 (sbcl-package->cl-source-package sbcl-constantfold))
10792 (define-public sbcl-gtype
10793 (let ((commit "42275e3606242ae91e9c8dfa30c18ced50a35b66")
10796 (name "sbcl-gtype")
10797 (version (git-version "0.1" revision commit))
10801 (uri (git-reference
10802 (url "https://github.com/numcl/gtype")
10804 (file-name (git-file-name name version))
10807 "1f56dba998v945jcxhha391557n6md1ql25b7icfwwfivhmlaa9b"))))
10808 (build-system asdf-build-system/sbcl)
10809 (synopsis "C++/Julia-like parametric types in Common Lisp")
10811 "Support library for numcl that provides Julia-like runtime parametric
10812 type correctness in Common Lisp. It is based on CLtL2 extensions.")
10813 (home-page "https://github.com/numcl/gtype")
10814 (license license:lgpl3+)
10816 `(("trivialib.type-unify" ,sbcl-trivialib-type-unify)
10817 ("trivial-cltl2" ,sbcl-trivial-cltl2)
10818 ("trivia" ,sbcl-trivia)
10819 ("alexandria" ,sbcl-alexandria)
10820 ("iterate" ,sbcl-iterate)
10821 ("type-r" ,sbcl-type-r)))
10823 `(("fiveam" ,sbcl-fiveam)))
10825 `(#:asd-system-name "gtype"
10826 #:asd-file "gtype.asd"
10827 #:test-asd-file "gtype.test.asd")))))
10829 (define-public cl-gtype
10830 (sbcl-package->cl-source-package sbcl-gtype))
10832 (define-public sbcl-numcl
10833 (let ((commit "1cf7dfa59f763a24a501092870e9c5ee745d0c17")
10836 (name "sbcl-numcl")
10837 (version (git-version "0.1.0" revision commit))
10841 (uri (git-reference
10842 (url "https://github.com/numcl/numcl")
10844 (file-name (git-file-name name version))
10847 "0i3jby9hf4ii7blivgyza80g0vmjfhk8537i5i7kqqk0i5sdnym2"))))
10848 (build-system asdf-build-system/sbcl)
10849 (synopsis "Numpy clone in Common Lisp")
10851 "This is a Numpy clone in Common Lisp. At the moment the
10852 library is written in pure Common Lisp, focusing more on correctness
10853 and usefulness, not speed. Track the progress at
10854 @url{https://github.com/numcl/numcl/projects/1}.")
10855 (home-page "https://github.com/numcl/numcl")
10856 (license license:lgpl3+)
10858 `(("trivia" ,sbcl-trivia)
10859 ("alexandria" ,sbcl-alexandria)
10860 ("iterate" ,sbcl-iterate)
10861 ("lisp-namespace" ,sbcl-lisp-namespace)
10862 ("type-r" ,sbcl-type-r)
10863 ("constantfold" ,sbcl-constantfold)
10864 ("cl-randist" ,sbcl-cl-randist)
10865 ("float-features" ,sbcl-float-features)
10866 ("function-cache" ,sbcl-function-cache)
10867 ("specialized-function" ,sbcl-specialized-function)
10868 ("gtype" ,sbcl-gtype)))
10870 `(("fiveam" ,sbcl-fiveam)))
10872 `(#:asd-system-name "numcl"
10873 #:asd-file "numcl.asd"
10874 #:test-asd-file "numcl.test.asd")))))
10876 (define-public cl-numcl
10877 (sbcl-package->cl-source-package sbcl-numcl))
10879 (define-public sbcl-pzmq
10880 (let ((commit "7c7390eedc469d033c72dc497984d1536ee75826")
10884 (version (git-version "0.0.0" revision commit))
10888 (uri (git-reference
10889 (url "https://github.com/orivej/pzmq")
10891 (file-name (git-file-name name version))
10893 (base32 "0gmwzf7h90wa7v4wnk49g0hv2mdalljpwhyigxcb967wzv8lqci9"))))
10894 (build-system asdf-build-system/sbcl)
10896 `(("bordeaux-threads" ,sbcl-bordeaux-threads)
10897 ("fiveam" ,sbcl-fiveam)
10898 ("let-plus" ,sbcl-let-plus)))
10900 `(("cffi" ,sbcl-cffi)
10901 ("cffi-grovel" ,sbcl-cffi-grovel)
10902 ("zeromq" ,zeromq)))
10904 `(#:phases (modify-phases %standard-phases
10905 (add-after 'unpack 'fix-paths
10906 (lambda* (#:key inputs #:allow-other-keys)
10907 (substitute* "c-api.lisp"
10909 (string-append "\""
10910 (assoc-ref inputs "zeromq")
10913 (synopsis "Common Lisp bindings for the ZeroMQ library")
10914 (description "This Common Lisp library provides bindings for the ZeroMQ
10915 lightweight messaging kernel.")
10916 (home-page "https://github.com/orivej/pzmq")
10917 (license license:unlicense))))
10919 (define-public cl-pzmq
10920 (sbcl-package->cl-source-package sbcl-pzmq))
10922 (define-public ecl-pzmq
10923 (sbcl-package->ecl-package sbcl-pzmq))
10925 (define-public sbcl-clss
10926 (let ((revision "1")
10927 (commit "2a8e8615ab55870d4ca01928f3ed3bbeb4e75c8d"))
10930 (version (git-version "0.3.1" revision commit))
10936 (url "https://github.com/Shinmera/clss")
10939 (base32 "0la4dbcda78x29szanylccrsljqrn9d1mhh569sqkyp44ni5fv91"))
10940 (file-name (git-file-name name version))))
10942 `(("array-utils" ,sbcl-array-utils)
10943 ("plump" ,sbcl-plump)))
10944 (build-system asdf-build-system/sbcl)
10945 (synopsis "DOM tree searching engine based on CSS selectors")
10946 (description "CLSS is a DOM traversal engine based on CSS
10947 selectors. It makes use of the Plump-DOM and is used by lQuery.")
10948 (home-page "https://github.com/Shinmera/clss")
10949 (license license:zlib))))
10951 (define-public cl-clss
10952 (sbcl-package->cl-source-package sbcl-clss))
10954 (define-public ecl-clss
10955 (sbcl-package->ecl-package sbcl-clss))
10957 (define-public sbcl-lquery
10958 (let ((revision "1")
10959 (commit "8048111c6b83956daa632e7a3ffbd8c9c203bd8d"))
10961 (name "sbcl-lquery")
10962 (version (git-version "3.2.1" revision commit))
10968 (url "https://github.com/Shinmera/lquery")
10971 (base32 "0520mcpxc2d6fdm8z61arpgd2z38kan7cf06qs373n5r64rakz6w"))
10972 (file-name (git-file-name name version))))
10974 `(("fiveam" ,sbcl-fiveam)))
10976 `(("array-utils" ,sbcl-array-utils)
10977 ("form-fiddle" ,sbcl-form-fiddle)
10978 ("plump" ,sbcl-plump)
10979 ("clss" ,sbcl-clss)))
10980 (build-system asdf-build-system/sbcl)
10981 (synopsis "Library to allow jQuery-like HTML/DOM manipulation")
10982 (description "@code{lQuery} is a DOM manipulation library written in
10983 Common Lisp, inspired by and based on the jQuery syntax and
10984 functions. It uses Plump and CLSS as DOM and selector engines. The
10985 main idea behind lQuery is to provide a simple interface for crawling
10986 and modifying HTML sites, as well as to allow for an alternative
10987 approach to templating.")
10988 (home-page "https://github.com/Shinmera/lquery")
10989 (license license:zlib))))
10991 (define-public cl-lquery
10992 (sbcl-package->cl-source-package sbcl-lquery))
10994 (define-public ecl-lquery
10995 (sbcl-package->ecl-package sbcl-lquery))
10997 (define-public sbcl-cl-mysql
10998 (let ((commit "ab56c279c1815aec6ca0bfe85164ff7e85cfb6f9")
11001 (name "sbcl-cl-mysql")
11002 (version (git-version "0.1" revision commit))
11006 (uri (git-reference
11007 (url "https://github.com/hackinghat/cl-mysql")
11009 (file-name (git-file-name name version))
11011 (base32 "0dg5ynx2ww94d0qfwrdrm7plkn43h64hs4iiq9mj2s1s4ixnp3lr"))))
11012 (build-system asdf-build-system/sbcl)
11014 `(("stefil" ,sbcl-stefil)))
11016 `(("cffi" ,sbcl-cffi)
11017 ("mariadb-lib" ,mariadb "lib")))
11019 `(#:tests? #f ; TODO: Tests require a running server
11021 (modify-phases %standard-phases
11022 (add-after 'unpack 'fix-paths
11023 (lambda* (#:key inputs #:allow-other-keys)
11024 (substitute* "system.lisp"
11025 (("libmysqlclient_r" all)
11026 (string-append (assoc-ref inputs "mariadb-lib")
11030 (synopsis "Common Lisp wrapper for MySQL")
11032 "@code{cl-mysql} is a Common Lisp implementation of a MySQL wrapper.")
11033 (home-page "http://www.hackinghat.com/index.php/cl-mysql")
11034 (license license:expat))))
11036 (define-public cl-mysql
11037 (sbcl-package->cl-source-package sbcl-cl-mysql))
11039 (define-public sbcl-simple-date
11040 (let ((commit "74469b25bbda990ec9b77e0d0eccdba0cd7e721a")
11043 (name "sbcl-simple-date")
11044 (version (git-version "1.19" revision commit))
11048 (uri (git-reference
11049 (url "https://github.com/marijnh/Postmodern")
11051 (file-name (git-file-name name version))
11053 (base32 "0im7ymnyxjhn2w74jfg76k5gpr0gl33n31akx33hl28722ljd0hd"))))
11054 (build-system asdf-build-system/sbcl)
11056 `(("fiveam" ,sbcl-fiveam)))
11057 (synopsis "Basic date and time objects for Common Lisp")
11059 "@code{simple-date} is a very basic implementation of date and time
11060 objects, used to support storing and retrieving time-related SQL types.")
11061 (home-page "https://marijnhaverbeke.nl/postmodern/")
11062 (license license:zlib))))
11064 (define-public cl-simple-date
11065 (sbcl-package->cl-source-package sbcl-simple-date))
11067 (define-public ecl-simple-date
11068 (sbcl-package->ecl-package sbcl-simple-date))
11070 (define-public sbcl-cl-postgres
11072 (inherit sbcl-simple-date)
11073 (name "sbcl-cl-postgres")
11075 `(("fiveam" ,sbcl-fiveam)
11076 ("simple-date" ,sbcl-simple-date)))
11078 `(("md5" ,sbcl-md5)
11079 ("split-sequence" ,sbcl-split-sequence)
11080 ("usocket" ,sbcl-usocket)))
11082 `(#:tests? #f)) ; TODO: Break simple-date/postgres-glue circular dependency
11083 (synopsis "Common Lisp interface for PostgreSQL")
11085 "@code{cl-postgres} is a low-level library used for interfacing with
11086 a PostgreSQL server over a socket.")))
11088 (define-public cl-postgres
11089 (sbcl-package->cl-source-package sbcl-cl-postgres))
11091 (define-public ecl-cl-postgres
11093 (inherit (sbcl-package->ecl-package sbcl-cl-postgres))
11096 (modify-phases %standard-phases
11097 (add-after 'unpack 'fix-ecl
11099 (substitute* "cl-postgres.asd"
11100 (("\\) \"usocket\"") " :ecl) \"usocket\""))
11104 (define-public sbcl-simple-date-postgres-glue
11106 (inherit sbcl-simple-date)
11107 (name "sbcl-simple-date-postgres-glue")
11109 `(("cl-postgres" ,sbcl-cl-postgres)
11110 ("simple-date" ,sbcl-simple-date)))
11112 `(#:asd-file "simple-date.asd"
11113 #:asd-system-name "simple-date/postgres-glue"))))
11115 (define-public cl-simple-date-postgres-glue
11116 (sbcl-package->cl-source-package sbcl-simple-date-postgres-glue))
11118 (define-public sbcl-s-sql
11120 (inherit sbcl-simple-date)
11121 (name "sbcl-s-sql")
11123 `(("alexandria" ,sbcl-alexandria)
11124 ("cl-postgres" ,sbcl-cl-postgres)))
11126 `(#:tests? #f)) ; TODO: Break postmodern circular dependency
11127 (synopsis "Lispy DSL for SQL")
11129 "@code{s-sql} is a Common Lisp library that can be used to compile
11130 s-expressions to strings of SQL code, escaping any Lisp values inside, and
11131 doing as much as possible of the work at compile time.")))
11133 (define-public cl-s-sql
11134 (sbcl-package->cl-source-package sbcl-s-sql))
11136 (define-public sbcl-postmodern
11138 (inherit sbcl-simple-date)
11139 (name "sbcl-postmodern")
11141 `(("fiveam" ,sbcl-fiveam)
11142 ("simple-date" ,sbcl-simple-date)
11143 ("simple-date-postgres-glue" ,sbcl-simple-date-postgres-glue)))
11145 `(("alexandria" ,sbcl-alexandria)
11146 ("bordeaux-threads" ,sbcl-bordeaux-threads)
11147 ("cl-postgres" ,sbcl-cl-postgres)
11148 ("closer-mop" ,sbcl-closer-mop)
11149 ("global-vars" ,sbcl-global-vars)
11150 ("s-sql" ,sbcl-s-sql)
11151 ("split-sequence" ,sbcl-split-sequence)))
11153 ;; TODO: Fix missing dependency errors for simple-date/postgres-glue,
11154 ;; cl-postgres/tests and s-sql/tests.
11156 (synopsis "Common Lisp library for interacting with PostgreSQL")
11158 "@code{postmodern} is a Common Lisp library for interacting with
11159 PostgreSQL databases. It provides the following features:
11162 @item Efficient communication with the database server without need for
11164 @item Support for UTF-8 on Unicode-aware Lisp implementations.
11165 @item A syntax for mixing SQL and Lisp code.
11166 @item Convenient support for prepared statements and stored procedures.
11167 @item A metaclass for simple database-access objects.
11170 (define-public cl-postmodern
11171 (sbcl-package->cl-source-package sbcl-postmodern))
11173 (define-public sbcl-dbi
11174 ;; Master includes a breaking change which other packages depend on since
11175 ;; Quicklisp decided to follow it:
11176 ;; https://github.com/fukamachi/cl-dbi/commit/31c46869722f77fd5292a81b5b101f1347d7fce1
11177 (let ((commit "31c46869722f77fd5292a81b5b101f1347d7fce1"))
11180 (version (git-version "0.9.4" "1" commit))
11184 (uri (git-reference
11185 (url "https://github.com/fukamachi/cl-dbi")
11187 (file-name (git-file-name name version))
11189 (base32 "0r3n4rw12qqxad0cryym2ibm4ddl49gbq4ra227afibsr43nw5k3"))))
11190 (build-system asdf-build-system/sbcl)
11192 `(("bordeaux-threads" ,sbcl-bordeaux-threads)
11193 ("closer-mop" ,sbcl-closer-mop)
11194 ("split-sequence" ,sbcl-split-sequence)))
11196 `(#:tests? #f)) ; TODO: Break circular dependency with dbd-*
11197 (synopsis "Database independent interface for Common Lisp")
11199 "@code{dbi} is a Common Lisp library providing a database independent
11200 interface for MySQL, PostgreSQL and SQLite.")
11201 (home-page "https://github.com/fukamachi/cl-dbi")
11202 (license license:llgpl))))
11204 (define-public cl-dbi
11205 (sbcl-package->cl-source-package sbcl-dbi))
11207 (define-public sbcl-dbd-mysql
11210 (name "sbcl-dbd-mysql")
11212 `(("cl-mysql" ,sbcl-cl-mysql)
11213 ("dbi" ,sbcl-dbi)))
11214 (synopsis "Database driver for MySQL")))
11216 (define-public cl-dbd-mysql
11217 (sbcl-package->cl-source-package sbcl-dbd-mysql))
11219 (define-public sbcl-dbd-postgres
11222 (name "sbcl-dbd-postgres")
11224 `(("cl-postgres" ,sbcl-cl-postgres)
11226 ("trivial-garbage" ,sbcl-trivial-garbage)))
11227 (synopsis "Database driver for PostgreSQL")))
11229 (define-public cl-dbd-postgres
11230 (sbcl-package->cl-source-package sbcl-dbd-postgres))
11232 (define-public sbcl-dbd-sqlite3
11235 (name "sbcl-dbd-sqlite3")
11237 `(("cl-sqlite" ,sbcl-cl-sqlite)
11239 ("trivial-garbage" ,sbcl-trivial-garbage)))
11240 (synopsis "Database driver for SQLite3")))
11242 (define-public cl-dbd-sqlite3
11243 (sbcl-package->cl-source-package sbcl-dbd-sqlite3))
11245 (define-public sbcl-uffi
11252 (uri (git-reference
11253 (url "http://git.kpe.io/uffi.git")
11254 (commit (string-append "v" version))))
11255 (file-name (git-file-name name version))
11257 (base32 "1hqszvz0a3wk4s9faa83sc3vjxcb5rxmjclyr17yzwg55z733kry"))))
11258 (build-system asdf-build-system/sbcl)
11260 `(#:tests? #f ; TODO: Fix use of deprecated ASDF functions
11262 (modify-phases %standard-phases
11263 (add-after 'unpack 'fix-permissions
11265 (make-file-writable "doc/html.tar.gz")
11267 (synopsis "Universal foreign function library for Common Lisp")
11269 "UFFI provides a universal foreign function interface (FFI)
11271 (home-page "http://quickdocs.org/uffi/")
11272 (license license:llgpl)))
11274 (define-public cl-uffi
11276 (inherit (sbcl-package->cl-source-package sbcl-uffi))
11279 ;; asdf-build-system/source has its own phases and does not inherit
11280 ;; from asdf-build-system/sbcl phases.
11281 (modify-phases %standard-phases/source
11282 (add-after 'unpack 'fix-permissions
11284 (make-file-writable "doc/html.tar.gz")
11287 (define-public sbcl-clsql
11289 (name "sbcl-clsql")
11294 (uri (git-reference
11295 (url "http://git.kpe.io/clsql.git")
11296 (commit (string-append "v" version))))
11297 (file-name (git-file-name name version))
11299 (base32 "1v1k3s5bsy3lgd9gk459bzpb1r0kdjda25s29samxw4gsgf1fqvp"))
11302 ;; Remove precompiled libraries.
11303 (delete-file "db-mysql/clsql_mysql.dll")
11304 (delete-file "uffi/clsql_uffi.dll")
11305 (delete-file "uffi/clsql_uffi.lib")
11307 (build-system asdf-build-system/sbcl)
11309 `(("cffi-uffi-compat" ,sbcl-cffi-uffi-compat)
11311 ("uffi" ,sbcl-uffi)))
11314 (modify-phases %standard-phases
11315 (add-after 'unpack 'fix-permissions
11317 (make-file-writable "doc/html.tar.gz")
11319 (add-after 'unpack 'fix-tests
11321 (substitute* "clsql.asd"
11322 (("clsql-tests :force t")
11325 (synopsis "Common Lisp SQL Interface library")
11327 "@code{clsql} is a Common Lisp interface to SQL RDBMS based on the
11328 Xanalys CommonSQL interface for Lispworks. It provides low-level database
11329 interfaces as well as a functional and an object oriented interface.")
11330 (home-page "http://clsql.kpe.io/")
11331 (license license:llgpl)))
11333 (define-public cl-clsql
11335 (inherit (sbcl-package->cl-source-package sbcl-clsql))
11340 ("postgresql" ,postgresql)
11344 `(("cl-postgres" ,cl-postgres)
11345 ("cffi-uffi-compat" ,cl-cffi-uffi-compat)
11347 ("uffi" ,cl-uffi)))
11350 ;; asdf-build-system/source has its own phases and does not inherit
11351 ;; from asdf-build-system/sbcl phases.
11352 (modify-phases %standard-phases/source
11353 (add-after 'unpack 'fix-permissions
11355 (make-file-writable "doc/html.tar.gz")
11358 (define-public sbcl-clsql-uffi
11360 (inherit sbcl-clsql)
11361 (name "sbcl-clsql-uffi")
11363 `(("cffi-uffi-compat" ,sbcl-cffi-uffi-compat)
11364 ("clsql" ,sbcl-clsql)
11365 ("uffi" ,sbcl-uffi)))
11366 (synopsis "UFFI helper functions for Common Lisp SQL interface library")))
11368 (define-public sbcl-clsql-sqlite3
11370 (inherit sbcl-clsql)
11371 (name "sbcl-clsql-sqlite3")
11373 `(("clsql" ,sbcl-clsql)
11374 ("clsql-uffi" ,sbcl-clsql-uffi)
11375 ("sqlite" ,sqlite)))
11377 (substitute-keyword-arguments (package-arguments sbcl-clsql)
11378 ((#:phases phases '%standard-phases)
11379 `(modify-phases ,phases
11380 (add-after 'unpack 'fix-paths
11381 (lambda* (#:key inputs #:allow-other-keys)
11382 (substitute* "db-sqlite3/sqlite3-loader.lisp"
11384 (string-append (assoc-ref inputs "sqlite")
11385 "/lib/libsqlite3")))
11387 (synopsis "SQLite3 driver for Common Lisp SQL interface library")))
11389 (define-public sbcl-clsql-postgresql
11391 (inherit sbcl-clsql)
11392 (name "sbcl-clsql-postgresql")
11394 `(("clsql" ,sbcl-clsql)
11395 ("clsql-uffi" ,sbcl-clsql-uffi)
11396 ("postgresql" ,postgresql)))
11398 (substitute-keyword-arguments (package-arguments sbcl-clsql)
11399 ((#:phases phases '%standard-phases)
11400 `(modify-phases ,phases
11401 (add-after 'unpack 'fix-paths
11402 (lambda* (#:key inputs #:allow-other-keys)
11403 (substitute* "db-postgresql/postgresql-loader.lisp"
11405 (string-append (assoc-ref inputs "postgresql")
11408 (synopsis "PostgreSQL driver for Common Lisp SQL interface library")))
11410 (define-public sbcl-clsql-postgresql-socket3
11412 (inherit sbcl-clsql)
11413 (name "sbcl-clsql-postgresql-socket3")
11415 `(("cl-postgres" ,sbcl-cl-postgres)
11416 ("clsql" ,sbcl-clsql)
11417 ("md5" ,sbcl-md5)))
11419 (substitute-keyword-arguments (package-arguments sbcl-clsql)
11420 ((#:phases phases '%standard-phases)
11421 `(modify-phases ,phases
11422 (add-after 'create-asd-file 'fix-asd-file
11423 (lambda* (#:key outputs #:allow-other-keys)
11424 (let* ((out (assoc-ref outputs "out"))
11425 (lib (string-append out "/lib/" (%lisp-type)))
11426 (asd (string-append lib "/clsql-postgresql-socket3.asd")))
11428 (("CLSQL-POSTGRESQL-SOCKET-SYSTEM::")
11431 (synopsis "PostgreSQL driver for Common Lisp SQL interface library")))
11433 (define-public sbcl-clsql-mysql
11435 (inherit sbcl-clsql)
11436 (name "sbcl-clsql-mysql")
11439 ("sbcl-clsql" ,sbcl-clsql)
11440 ("sbcl-clsql-uffi" ,sbcl-clsql-uffi)
11443 (substitute-keyword-arguments (package-arguments sbcl-clsql)
11444 ((#:phases phases '%standard-phases)
11445 `(modify-phases ,phases
11446 (add-after 'unpack 'fix-paths
11447 (lambda* (#:key inputs outputs #:allow-other-keys)
11448 (let ((lib (string-append "#p\""
11449 (assoc-ref outputs "out")
11451 (substitute* "clsql-mysql.asd"
11452 (("#p\"/usr/lib/clsql/clsql_mysql\\.so\"")
11454 (substitute* "db-mysql/mysql-loader.lisp"
11455 (("libmysqlclient" all)
11456 (string-append (assoc-ref inputs "mysql") "/lib/" all))
11457 (("clsql-mysql-system::\\*library-file-dir\\*")
11460 (add-before 'build 'build-helper-library
11461 (lambda* (#:key inputs outputs #:allow-other-keys)
11462 (let* ((mysql (assoc-ref inputs "mysql"))
11463 (inc-dir (string-append mysql "/include/mysql"))
11464 (lib-dir (string-append mysql "/lib"))
11465 (shared-lib-dir (string-append (assoc-ref outputs "out")
11467 (shared-lib (string-append shared-lib-dir
11468 "/clsql_mysql.so")))
11469 (mkdir-p shared-lib-dir)
11470 (invoke "gcc" "-fPIC" "-shared"
11472 "db-mysql/clsql_mysql.c"
11473 "-Wl,-soname=clsql_mysql"
11474 "-L" lib-dir "-lmysqlclient" "-lz"
11477 (synopsis "MySQL driver for Common Lisp SQL interface library")))
11479 (define-public sbcl-sycamore
11480 (let ((commit "fd2820fec165ad514493426dea209728f64e6d18"))
11482 (name "sbcl-sycamore")
11483 (version "0.0.20120604")
11487 (uri (git-reference
11488 (url "https://github.com/ndantam/sycamore/")
11490 (file-name (git-file-name name version))
11492 (base32 "00bv1aj89q5vldmq92zp2364jq312zjq2mbd3iyz1s2b4widzhl7"))))
11493 (build-system asdf-build-system/sbcl)
11495 `(#:asd-file "src/sycamore.asd"))
11497 `(("alexandria" ,sbcl-alexandria)
11498 ("cl-ppcre" ,sbcl-cl-ppcre)))
11499 (synopsis "Purely functional data structure library in Common Lisp")
11501 "Sycamore is a fast, purely functional data structure library in Common Lisp.
11505 @item Fast, purely functional weight-balanced binary trees.
11506 @item Leaf nodes are simple-vectors, greatly reducing tree height.
11507 @item Interfaces for tree Sets and Maps (dictionaries).
11509 @item Purely functional pairing heaps.
11510 @item Purely functional amortized queue.
11512 (home-page "http://ndantam.github.io/sycamore/")
11513 (license license:bsd-3))))
11515 (define-public cl-sycamore
11516 (sbcl-package->cl-source-package sbcl-sycamore))
11518 (define-public sbcl-trivial-package-local-nicknames
11520 (name "sbcl-trivial-package-local-nicknames")
11522 (home-page "https://github.com/phoe/trivial-package-local-nicknames")
11526 (uri (git-reference
11528 (commit "16b7ad4c2b120f50da65154191f468ea5598460e")))
11529 (file-name (git-file-name name version))
11531 (base32 "18qc27xkjzdcqrilpk3pm7djldwq5rm3ggd5h9cr8hqcd54i2fqg"))))
11532 (build-system asdf-build-system/sbcl)
11533 (synopsis "Common Lisp compatibility library for package local nicknames")
11535 "This library is a portable compatibility layer around package local nicknames (PLN).
11536 This was done so there is a portability library for the PLN API not included
11538 (license license:unlicense)))
11540 (define-public cl-trivial-package-local-nicknames
11541 (sbcl-package->cl-source-package sbcl-trivial-package-local-nicknames))
11543 (define-public sbcl-enchant
11544 (let ((commit "6af162a7bf10541cbcfcfa6513894900329713fa"))
11546 (name "sbcl-enchant")
11547 (version (git-version "0.0.0" "1" commit))
11548 (home-page "https://github.com/tlikonen/cl-enchant")
11552 (uri (git-reference
11555 (file-name (git-file-name name version))
11557 (base32 "19yh5ihirzi1d8xqy1cjqipzd6ly3245cfxa5s9xx496rryz0s01"))))
11558 (build-system asdf-build-system/sbcl)
11560 `(("enchant" ,enchant)
11561 ("cffi" ,sbcl-cffi)))
11564 (modify-phases %standard-phases
11565 (add-after 'unpack 'fix-paths
11566 (lambda* (#:key inputs #:allow-other-keys)
11567 (substitute* "load-enchant.lisp"
11570 (assoc-ref inputs "enchant") "/lib/libenchant-2"))))))))
11571 (synopsis "Common Lisp interface for the Enchant spell-checker library")
11573 "Enchant is a Common Lisp interface for the Enchant spell-checker
11574 library. The Enchant library is a generic spell-checker library which uses
11575 other spell-checkers transparently as back-end. The library supports the
11576 multiple checkers, including Aspell and Hunspell.")
11577 (license license:public-domain))))
11579 (define-public cl-enchant
11580 (sbcl-package->cl-source-package sbcl-enchant))
11582 (define-public sbcl-cl-change-case
11583 (let ((commit "5ceff2a5f8bd845b6cb510c6364176b27a238fd3"))
11585 (name "sbcl-cl-change-case")
11586 (version (git-version "0.1.0" "1" commit))
11587 (home-page "https://github.com/rudolfochrist/cl-change-case")
11591 (uri (git-reference
11594 (file-name (git-file-name name version))
11596 (base32 "1afyglglk9z3yg8gylcl301bl2r8vq3sllyznzj9s5xi5gs6qyf2"))))
11597 (build-system asdf-build-system/sbcl)
11599 `(("cl-ppcre" ,sbcl-cl-ppcre)
11600 ("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)))
11602 `(("fiveam" ,sbcl-fiveam)))
11604 '(;; FIXME: Test pass but phase fails with 'Component
11605 ;; "cl-change-case-test" not found, required by'.
11607 #:test-asd-file "cl-change-case-test.asd"))
11608 (synopsis "Convert Common Lisp strings between camelCase, PascalCase and more")
11610 "@code{cl-change-case} is library to convert strings between camelCase,
11611 PascalCase, snake_case, param-case, CONSTANT_CASE and more.")
11612 (license license:llgpl))))
11614 (define-public cl-change-case
11615 (sbcl-package->cl-source-package sbcl-cl-change-case))
11617 (define-public sbcl-moptilities
11618 (let ((commit "a436f16b357c96b82397ec018ea469574c10dd41"))
11620 (name "sbcl-moptilities")
11621 (version (git-version "0.3.13" "1" commit))
11622 (home-page "https://github.com/gwkkwg/moptilities/")
11626 (uri (git-reference
11629 (file-name (git-file-name name version))
11631 (base32 "1q12bqjbj47lx98yim1kfnnhgfhkl80102fkgp9pdqxg0fp6g5fc"))))
11632 (build-system asdf-build-system/sbcl)
11634 `(("closer-mop" ,sbcl-closer-mop)))
11636 `(("lift" ,sbcl-lift)))
11637 (synopsis "Compatibility layer for Common Lisp MOP implementation differences")
11639 "MOP utilities provide a common interface between Lisps and make the
11640 MOP easier to use.")
11641 (license license:expat))))
11643 (define-public cl-moptilities
11644 (sbcl-package->cl-source-package sbcl-moptilities))
11646 (define-public sbcl-osicat
11647 (let ((commit "de0c18a367eedc857e1902a7319828af072a0d97"))
11649 (name "sbcl-osicat")
11650 (version (git-version "0.7.0" "1" commit))
11651 (home-page "http://www.common-lisp.net/project/osicat/")
11655 (uri (git-reference
11656 (url "https://github.com/osicat/osicat")
11658 (file-name (git-file-name name version))
11660 (base32 "15viw5pi5sa7qq9b4n2rr3dj2jkqr180rh9z1lh8w3rgl42i2adc"))))
11661 (build-system asdf-build-system/sbcl)
11664 (modify-phases %standard-phases
11665 ;; The cleanup phase moves files around but we need to keep the
11666 ;; directory structure for the grovel-generated library.
11668 (lambda* (#:key outputs #:allow-other-keys)
11669 (let* ((out (assoc-ref outputs "out"))
11670 (lib (string-append out "/lib/sbcl/")))
11671 (delete-file-recursively (string-append lib "src"))
11672 (delete-file-recursively (string-append lib "tests"))
11673 (for-each delete-file
11674 (filter (lambda (file)
11675 (not (member (basename file) '("libosicat.so"))))
11676 (find-files (string-append lib "posix") ".*"))))
11679 `(("alexandria" ,sbcl-alexandria)
11680 ("cffi" ,sbcl-cffi)
11681 ("trivial-features" ,sbcl-trivial-features)))
11683 `(("cffi-grovel" ,sbcl-cffi-grovel)
11685 (synopsis "Operating system interface for Common Lisp")
11687 "Osicat is a lightweight operating system interface for Common Lisp on
11688 Unix-platforms. It is not a POSIX-style API, but rather a simple lispy
11689 accompaniment to the standard ANSI facilities.")
11690 (license license:expat))))
11692 (define-public cl-osicat
11693 (sbcl-package->cl-source-package sbcl-osicat))
11695 (define-public sbcl-clx-xembed
11696 (let ((commit "a5c4b844d31ee68ffa58c933cc1cdddde6990743")
11699 (name "sbcl-clx-xembed")
11700 (version (git-version "0.1" revision commit))
11701 (home-page "https://github.com/laynor/clx-xembed")
11705 (uri (git-reference
11706 (url "https://github.com/laynor/clx-xembed")
11708 (file-name (git-file-name name version))
11710 (base32 "1abx4v36ycmfjdwpjk4hh8058ya8whwia7ds9vd96q2qsrs57f12"))))
11711 (build-system asdf-build-system/sbcl)
11713 `(#:asd-system-name "xembed"))
11715 `(("sbcl-clx" ,sbcl-clx)))
11716 (synopsis "CL(x) xembed protocol implementation ")
11717 (description "CL(x) xembed protocol implementation")
11719 (license license:expat))))
11721 (define-public cl-clx-xembed
11722 (sbcl-package->cl-source-package sbcl-clx-xembed))
11724 (define-public ecl-clx-xembed
11725 (sbcl-package->ecl-package sbcl-clx-xembed))
11727 (define-public sbcl-quantile-estimator
11729 (name "sbcl-quantile-estimator")
11734 (uri (git-reference
11735 (url "https://github.com/deadtrickster/quantile-estimator.cl")
11736 (commit "84d0ea405d793f5e808c68c4ddaf25417b0ff8e5")))
11737 (file-name (git-file-name name version))
11740 "0rlswkf0siaabsvvch3dgxmg45fw5w8pd9b7ri2w7a298aya52z9"))))
11741 (build-system asdf-build-system/sbcl)
11743 '(#:asd-system-name "quantile-estimator"))
11745 `(("alexandria" ,sbcl-alexandria)))
11746 (home-page "https://github.com/deadtrickster/quantile-estimator.cl")
11748 "Effective computation of biased quantiles over data streams")
11750 "Common Lisp implementation of Graham Cormode and S.
11751 Muthukrishnan's Effective Computation of Biased Quantiles over Data
11752 Streams in ICDE’05.")
11753 (license license:expat)))
11755 (define-public cl-quantile-estimator
11756 (sbcl-package->cl-source-package sbcl-quantile-estimator))
11758 (define-public ecl-quantile-estimator
11759 (sbcl-package->ecl-package sbcl-quantile-estimator))
11761 (define-public sbcl-prometheus
11763 (name "sbcl-prometheus")
11768 (uri (git-reference
11769 (url "https://github.com/deadtrickster/prometheus.cl")
11770 (commit "7352b92296996ff383503e19bdd3bcea30409a15")))
11771 (file-name (git-file-name name version))
11774 "0fzczls2kfgdx18pja4lqxjrz72i583185d8nq0pb3s331hhzh0z"))))
11775 (build-system asdf-build-system/sbcl)
11777 `(("alexandria" ,sbcl-alexandria)
11778 ("bordeaux-threads" ,sbcl-bordeaux-threads)
11779 ("cl-ppcre" ,sbcl-cl-ppcre)
11780 ("local-time" ,sbcl-local-time)
11781 ("quantile-estimator" ,sbcl-quantile-estimator)))
11782 (home-page "https://github.com/deadtrickster/prometheus.cl")
11783 (synopsis "Prometheus.io Common Lisp client")
11784 (description "Prometheus.io Common Lisp client.")
11785 (license license:expat)))
11787 (define-public cl-prometheus
11788 (sbcl-package->cl-source-package sbcl-prometheus))
11790 (define-public ecl-prometheus
11791 (sbcl-package->ecl-package sbcl-prometheus))
11793 (define-public sbcl-prometheus.collectors.sbcl
11795 (inherit sbcl-prometheus)
11796 (name "sbcl-prometheus.collectors.sbcl")
11797 (inputs `(("prometheus" ,sbcl-prometheus)))
11798 (synopsis "Prometheus collector for SBCL metrics")
11799 (description "Prometheus collector for SBCL metrics.")))
11801 (define-public cl-prometheus.collectors.sbcl
11802 (sbcl-package->cl-source-package sbcl-prometheus.collectors.sbcl))
11804 (define-public sbcl-prometheus.collectors.process
11806 (inherit sbcl-prometheus)
11807 (name "sbcl-prometheus.collectors.process")
11809 `(("cffi" ,sbcl-cffi)
11810 ("cffi-grovel" ,sbcl-cffi-grovel)
11811 ("cl-fad" ,sbcl-cl-fad)
11812 ("prometheus" ,sbcl-prometheus)
11813 ("split-sequence" ,sbcl-split-sequence)))
11814 (synopsis "Prometheus collector for process metrics")
11815 (description "Prometheus collector for process metrics.")))
11817 (define-public cl-prometheus.collectors.process
11818 (sbcl-package->cl-source-package sbcl-prometheus.collectors.process))
11820 (define-public ecl-prometheus.collectors.process
11821 (sbcl-package->ecl-package sbcl-prometheus.collectors.process))
11823 (define-public sbcl-prometheus.formats.text
11825 (inherit sbcl-prometheus)
11826 (name "sbcl-prometheus.formats.text")
11828 `(("alexandria" ,sbcl-alexandria)
11829 ("prometheus" ,sbcl-prometheus)))
11830 (synopsis "Prometheus client text format")
11831 (description "Prometheus client text format.")))
11833 (define-public cl-prometheus.formats.text
11834 (sbcl-package->cl-source-package sbcl-prometheus.formats.text))
11836 (define-public ecl-prometheus.formats.text
11837 (sbcl-package->ecl-package sbcl-prometheus.formats.text))
11839 (define-public sbcl-prometheus.exposers.hunchentoot
11841 (inherit sbcl-prometheus)
11842 (name "sbcl-prometheus.exposers.hunchentoot")
11844 `(("hunchentoot" ,sbcl-hunchentoot)
11845 ("prometheus" ,sbcl-prometheus)
11846 ("prometheus.formats.text" ,sbcl-prometheus.formats.text)
11847 ("salza2" ,sbcl-salza2)
11848 ("trivial-utf-8" ,sbcl-trivial-utf-8)))
11849 (synopsis "Prometheus collector for Hunchentoot metrics")
11850 (description "Prometheus collector for Hunchentoot metrics")))
11852 (define-public cl-prometheus.exposers.hunchentoot
11853 (sbcl-package->cl-source-package sbcl-prometheus.exposers.hunchentoot))
11855 (define-public sbcl-prometheus.pushgateway
11857 (inherit sbcl-prometheus)
11858 (name "sbcl-prometheus.pushgateway")
11860 `(("drakma" ,sbcl-drakma)
11861 ("prometheus" ,sbcl-prometheus)
11862 ("prometheus.formats.text" ,sbcl-prometheus.formats.text)))
11863 (synopsis "Prometheus Pushgateway client")
11864 (description "Prometheus Pushgateway client.")))
11866 (define-public cl-prometheus.pushgateway
11867 (sbcl-package->cl-source-package sbcl-prometheus.pushgateway))
11869 (define-public ecl-prometheus.pushgateway
11870 (sbcl-package->ecl-package sbcl-prometheus.pushgateway))
11872 (define-public sbcl-uuid
11873 (let ((commit "e7d6680c3138385c0708f7aaf0c96622eeb140e8"))
11876 (version (git-version "2012.12.26" "1" commit))
11880 (uri (git-reference
11881 (url "https://github.com/dardoria/uuid")
11883 (file-name (git-file-name name version))
11886 "0jnyp2kibcf5cwi60l6grjrj8wws9chasjvsw7xzwyym2lyid46f"))))
11887 (build-system asdf-build-system/sbcl)
11889 `(("ironclad" ,sbcl-ironclad)
11890 ("trivial-utf-8" ,sbcl-trivial-utf-8)))
11891 (home-page "https://github.com/dardoria/uuid")
11893 "Common Lisp implementation of UUIDs according to RFC4122")
11895 "Common Lisp implementation of UUIDs according to RFC4122.")
11896 (license license:llgpl))))
11898 (define-public cl-uuid
11899 (sbcl-package->cl-source-package sbcl-uuid))
11901 (define-public ecl-uuid
11902 (sbcl-package->ecl-package sbcl-uuid))
11904 (define-public sbcl-dissect
11905 (let ((commit "cffd38479f0e64e805f167bbdb240b783ecc8d45"))
11907 (name "sbcl-dissect")
11908 (version (git-version "1.0.0" "1" commit))
11912 (uri (git-reference
11913 (url "https://github.com/Shinmera/dissect")
11915 (file-name (git-file-name name version))
11918 "0rmsjkgjl90gl6ssvgd60hb0d5diyhsiyypvw9hbc0ripvbmk5r5"))))
11919 (build-system asdf-build-system/sbcl)
11921 `(("cl-ppcre" ,sbcl-cl-ppcre)))
11922 (home-page "https://shinmera.github.io/dissect/")
11924 "Introspection library for the call stack and restarts")
11926 "Dissect is a small Common Lisp library for introspecting the call stack
11927 and active restarts.")
11928 (license license:zlib))))
11930 (define-public cl-dissect
11931 (sbcl-package->cl-source-package sbcl-dissect))
11933 (define-public ecl-dissect
11934 (sbcl-package->ecl-package sbcl-dissect))
11936 ;; TODO: Uses ASDF's package-inferred-system which is not supported by
11937 ;; asdf-build-system/sbcl as of 2020-05-21. We should fix
11938 ;; asdf-build-system/sbcl.
11939 (define-public sbcl-rove
11946 (uri (git-reference
11947 (url "https://github.com/fukamachi/rove")
11948 (commit "f3695db08203bf26f3b861dc22ac0f4257d3ec21")))
11949 (file-name (git-file-name name version))
11952 "07ala4l2fncxf540fzxj3h5mhi9i4wqllhj0rqk8m2ljl5zbz89q"))))
11953 (build-system asdf-build-system/sbcl)
11955 `(("bordeaux-threads" ,sbcl-bordeaux-threads)
11956 ("dissect" ,sbcl-dissect)
11957 ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
11958 (home-page "https://github.com/fukamachi/rove")
11960 "Yet another common lisp testing library")
11962 "Rove is a unit testing framework for Common Lisp applications.
11963 This is intended to be a successor of Prove.")
11964 (license license:bsd-3)))
11966 (define-public cl-rove
11967 (sbcl-package->cl-source-package sbcl-rove))
11969 (define-public ecl-rove
11970 (sbcl-package->ecl-package sbcl-rove))
11972 (define-public sbcl-exponential-backoff
11973 (let ((commit "8d9e8444d8b3184a524c12ce3449f91613ab714f"))
11975 (name "sbcl-exponential-backoff")
11976 (version (git-version "0" "1" commit))
11980 (uri (git-reference
11981 (url "https://github.com/death/exponential-backoff")
11983 (file-name (git-file-name name version))
11986 "1389hm9hxv85s0125ja4js1bvh8ay4dsy9q1gaynjv27ynik6gmv"))))
11987 (build-system asdf-build-system/sbcl)
11988 (home-page "https://github.com/death/exponential-backoff")
11989 (synopsis "Exponential backoff algorithm in Common Lisp")
11991 "An implementation of the exponential backoff algorithm in Common Lisp.
11992 Inspired by the implementation found in Chromium. Read the header file to
11993 learn about each of the parameters.")
11994 (license license:expat))))
11996 (define-public cl-exponential-backoff
11997 (sbcl-package->cl-source-package sbcl-exponential-backoff))
11999 (define-public ecl-exponential-backoff
12000 (sbcl-package->ecl-package sbcl-exponential-backoff))
12002 (define-public sbcl-sxql
12003 (let ((commit "5aa8b739492c5829e8623432b5d46482263990e8"))
12006 (version (git-version "0.1.0" "1" commit))
12010 (uri (git-reference
12011 (url "https://github.com/fukamachi/sxql")
12013 (file-name (git-file-name name version))
12016 "0k25p6w2ld9cn8q8s20lda6yjfyp4q89219sviayfgixnj27avnj"))))
12017 (build-system asdf-build-system/sbcl)
12019 `(#:test-asd-file "sxql-test.asd"))
12021 `(("alexandria" ,sbcl-alexandria)
12022 ("cl-syntax-annot" ,sbcl-cl-syntax-annot)
12023 ("iterate" ,sbcl-iterate)
12024 ("optima" ,sbcl-optima)
12025 ("split-sequence" ,sbcl-split-sequence)
12026 ("trivial-types" ,sbcl-trivial-types)))
12028 `(("prove" ,sbcl-prove)
12029 ("prove-asdf" ,sbcl-prove-asdf)))
12030 (home-page "https://github.com/fukamachi/sxql")
12031 (synopsis "SQL generator for Common Lisp")
12032 (description "SQL generator for Common Lisp.")
12033 (license license:bsd-3))))
12035 (define-public cl-sxql
12036 (sbcl-package->cl-source-package sbcl-sxql))
12038 (define-public ecl-sxql
12039 (sbcl-package->ecl-package sbcl-sxql))
12041 (define-public sbcl-1am
12042 (let ((commit "8b1da94eca4613fd8a20bdf63f0e609e379b0ba5"))
12045 (version (git-version "0.0" "1" commit))
12049 (uri (git-reference
12050 (url "https://github.com/lmj/1am")
12052 (file-name (git-file-name name version))
12055 "05ss4nz1jb9kb796295482b62w5cj29msfj8zis33sp2rw2vmv2g"))))
12056 (build-system asdf-build-system/sbcl)
12058 `(#:asd-system-name "1am"))
12059 (home-page "https://github.com/lmj/1am")
12060 (synopsis "Minimal testing framework for Common Lisp")
12061 (description "A minimal testing framework for Common Lisp.")
12062 (license license:expat))))
12064 (define-public cl-1am
12065 (sbcl-package->cl-source-package sbcl-1am))
12067 (define-public ecl-1am
12068 (sbcl-package->ecl-package sbcl-1am))
12070 (define-public sbcl-cl-ascii-table
12071 (let ((commit "d9f5e774a56fad1b416e4dadb8f8a5b0e84094e2")
12074 (name "sbcl-cl-ascii-table")
12075 (version (git-version "0.0.0" revision commit))
12079 (uri (git-reference
12080 (url "https://github.com/telephil/cl-ascii-table")
12082 (file-name (git-file-name name version))
12084 (base32 "125fdif9sgl7k0ngjhxv0wjas2q27d075025hvj2rx1b1x948z4s"))))
12085 (build-system asdf-build-system/sbcl)
12086 (synopsis "Library to make ascii-art tables")
12088 "This is a Common Lisp library to present tabular data in ascii-art
12090 (home-page "https://github.com/telephil/cl-ascii-table")
12091 (license license:expat))))
12093 (define-public cl-ascii-table
12094 (sbcl-package->cl-source-package sbcl-cl-ascii-table))
12096 (define-public ecl-cl-ascii-table
12097 (sbcl-package->ecl-package sbcl-cl-ascii-table))
12099 (define-public sbcl-cl-rdkafka
12101 (name "sbcl-cl-rdkafka")
12106 (uri (git-reference
12107 (url "https://github.com/SahilKang/cl-rdkafka")
12108 (commit (string-append "v" version))))
12109 (file-name (git-file-name name version))
12112 "1qcgfd4h7syilzmrmd4z2vknbvawda3q3ykw7xm8n381syry4g82"))))
12113 (build-system asdf-build-system/sbcl)
12115 `(#:tests? #f ; Attempts to connect to locally running Kafka
12117 (modify-phases %standard-phases
12118 (add-after 'unpack 'fix-paths
12119 (lambda* (#:key inputs #:allow-other-keys)
12120 (substitute* "src/low-level/librdkafka-bindings.lisp"
12121 (("librdkafka" all)
12122 (string-append (assoc-ref inputs "librdkafka") "/lib/"
12124 (add-before 'cleanup 'move-bundle
12125 (lambda* (#:key outputs #:allow-other-keys)
12126 (let* ((out (assoc-ref outputs "out"))
12127 (actual (string-append out "/lib/sbcl/src/cl-rdkafka.fasl"))
12128 (expected (string-append
12129 out "/lib/sbcl/cl-rdkafka--system.fasl")))
12130 (copy-file actual expected)
12133 `(("bordeaux-threads" ,sbcl-bordeaux-threads)
12134 ("cffi" ,sbcl-cffi)
12135 ("cffi-grovel" ,sbcl-cffi-grovel)
12136 ("librdkafka" ,librdkafka)
12137 ("lparallel" ,sbcl-lparallel)
12138 ("trivial-garbage" ,sbcl-trivial-garbage)))
12139 (home-page "https://github.com/SahilKang/cl-rdkafka")
12140 (synopsis "Common Lisp client library for Apache Kafka")
12141 (description "A Common Lisp client library for Apache Kafka.")
12142 (license license:gpl3)))
12144 (define-public cl-rdkafka
12145 (sbcl-package->cl-source-package sbcl-cl-rdkafka))
12147 (define-public sbcl-acclimation
12148 (let ((commit "4d51150902568fcd59335f4cc4cfa022df6116a5"))
12150 (name "sbcl-acclimation")
12151 (version (git-version "0.0.0" "1" commit))
12155 (uri (git-reference
12156 (url "https://github.com/robert-strandh/Acclimation")
12158 (file-name (git-file-name name version))
12161 "1aw7rarjl8ai57h0jxnp9hr3dka7qrs55mmbl1p6rhd6xj8mp9wq"))))
12162 (build-system asdf-build-system/sbcl)
12163 (home-page "https://github.com/robert-strandh/Acclimation")
12164 (synopsis "Internationalization library for Common Lisp")
12165 (description "This project is meant to provide tools for
12166 internationalizing Common Lisp programs.
12168 One important aspect of internationalization is of course the language used in
12169 error messages, documentation strings, etc. But with this project we provide
12170 tools for all other aspects of internationalization as well, including dates,
12171 weight, temperature, names of physical quantitites, etc.")
12172 (license license:bsd-2))))
12174 (define-public cl-acclimation
12175 (sbcl-package->cl-source-package sbcl-acclimation))
12177 (define-public sbcl-clump-2-3-tree
12178 (let ((commit "1ea4dbac1cb86713acff9ae58727dd187d21048a"))
12180 (name "sbcl-clump-2-3-tree")
12181 (version (git-version "0.0.0" "1" commit))
12185 (uri (git-reference
12186 (url "https://github.com/robert-strandh/Clump")
12188 (file-name (git-file-name name version))
12191 "1639msyagsswj85gc0wd90jgh8588j3qg5q70by9s2brf2q6w4lh"))))
12193 '(#:asd-file "2-3-tree/clump-2-3-tree.asd"
12194 #:asd-system-name "clump-2-3-tree"))
12196 `(("acclimation" ,sbcl-acclimation)))
12197 (build-system asdf-build-system/sbcl)
12198 (home-page "https://github.com/robert-strandh/Clump")
12199 (synopsis "Implementation of 2-3 trees for Common Lisp")
12200 (description "The purpose of this library is to provide a collection of
12201 implementations of trees.
12203 In contrast to existing libraries such as cl-containers, it does not impose a
12204 particular use for the trees. Instead, it aims for a stratified design,
12205 allowing client code to choose between different levels of abstraction.
12207 As a consequence of this policy, low-level interfaces are provided where
12208 the concrete representation is exposed, but also high level interfaces
12209 where the trees can be used as search trees or as trees that represent
12210 sequences of objects.")
12211 (license license:bsd-2))))
12213 (define-public sbcl-clump-binary-tree
12215 (inherit sbcl-clump-2-3-tree)
12216 (name "sbcl-clump-binary-tree")
12218 '(#:asd-file "Binary-tree/clump-binary-tree.asd"
12219 #:asd-system-name "clump-binary-tree"))
12220 (synopsis "Implementation of binary trees for Common Lisp")))
12222 (define-public sbcl-clump
12224 (inherit sbcl-clump-2-3-tree)
12225 (name "sbcl-clump")
12227 '(#:asd-file "clump.asd"
12228 #:asd-system-name "clump"))
12230 `(("clump-2-3-tree" ,sbcl-clump-2-3-tree)
12231 ("clump-binary-tree" ,sbcl-clump-binary-tree)))
12232 (synopsis "Collection of tree implementations for Common Lisp")))
12234 (define-public cl-clump
12235 (sbcl-package->cl-source-package sbcl-clump))
12237 (define-public sbcl-cluffer-base
12238 (let ((commit "4aad29c276a58a593064e79972ee4d77cae0af4a"))
12240 (name "sbcl-cluffer-base")
12241 (version (git-version "0.0.0" "1" commit))
12245 (uri (git-reference
12246 (url "https://github.com/robert-strandh/cluffer")
12248 (file-name (git-file-name name version))
12251 "1bcg13g7qb3dr8z50aihdjqa6miz5ivlc9wsj2csgv1km1mak2kj"))))
12253 '(#:asd-file "Base/cluffer-base.asd"
12254 #:asd-system-name "cluffer-base"))
12256 `(("acclimation" ,sbcl-acclimation)))
12257 (build-system asdf-build-system/sbcl)
12258 (home-page "https://github.com/robert-strandh/cluffer")
12259 (synopsis "Common Lisp library providing a protocol for text-editor buffers")
12260 (description "Cluffer is a library for representing the buffer of a text
12261 editor. As such, it defines a set of CLOS protocols for client code to
12262 interact with the buffer contents in various ways, and it supplies different
12263 implementations of those protocols for different purposes.")
12264 (license license:bsd-2))))
12266 (define-public sbcl-cluffer-standard-line
12268 (inherit sbcl-cluffer-base)
12269 (name "sbcl-cluffer-standard-line")
12271 '(#:asd-file "Standard-line/cluffer-standard-line.asd"
12272 #:asd-system-name "cluffer-standard-line"))
12274 `(("cluffer-base" ,sbcl-cluffer-base)))))
12276 (define-public sbcl-cluffer-standard-buffer
12278 (inherit sbcl-cluffer-base)
12279 (name "sbcl-cluffer-standard-buffer")
12281 '(#:asd-file "Standard-buffer/cluffer-standard-buffer.asd"
12282 #:asd-system-name "cluffer-standard-buffer"))
12284 `(("cluffer-base" ,sbcl-cluffer-base)
12285 ("clump" ,sbcl-clump)))))
12287 (define-public sbcl-cluffer-simple-line
12289 (inherit sbcl-cluffer-base)
12290 (name "sbcl-cluffer-simple-line")
12292 '(#:asd-file "Simple-line/cluffer-simple-line.asd"
12293 #:asd-system-name "cluffer-simple-line"))
12295 `(("cluffer-base" ,sbcl-cluffer-base)))))
12297 (define-public sbcl-cluffer-simple-buffer
12299 (inherit sbcl-cluffer-base)
12300 (name "sbcl-cluffer-simple-buffer")
12302 '(#:asd-file "Simple-buffer/cluffer-simple-buffer.asd"
12303 #:asd-system-name "cluffer-simple-buffer"))
12305 `(("cluffer-base" ,sbcl-cluffer-base)))))
12307 (define-public sbcl-cluffer
12309 (inherit sbcl-cluffer-base)
12310 (name "sbcl-cluffer")
12312 '(#:asd-file "cluffer.asd"
12313 #:asd-system-name "cluffer"))
12315 `(("cluffer-base" ,sbcl-cluffer-base)
12316 ("cluffer-standard-line" ,sbcl-cluffer-standard-line)
12317 ("cluffer-standard-buffer" ,sbcl-cluffer-standard-buffer)
12318 ("cluffer-simple-line" ,sbcl-cluffer-simple-line)
12319 ("cluffer-simple-buffer" ,sbcl-cluffer-simple-buffer)))))
12321 (define-public cl-cluffer
12322 (sbcl-package->cl-source-package sbcl-cluffer))
12324 (define-public sbcl-cl-libsvm-format
12325 (let ((commit "3300f84fd8d9f5beafc114f543f9d83417c742fb")
12328 (name "sbcl-cl-libsvm-format")
12329 (version (git-version "0.1.0" revision commit))
12333 (uri (git-reference
12334 (url "https://github.com/masatoi/cl-libsvm-format")
12336 (file-name (git-file-name name version))
12339 "0284aj84xszhkhlivaigf9qj855fxad3mzmv3zfr0qzb5k0nzwrg"))))
12340 (build-system asdf-build-system/sbcl)
12342 `(("prove" ,sbcl-prove)
12343 ("prove-asdf" ,sbcl-prove-asdf)))
12345 `(("alexandria" ,sbcl-alexandria)))
12346 (synopsis "LibSVM data format reader for Common Lisp")
12348 "This Common Lisp library provides a fast reader for data in LibSVM
12350 (home-page "https://github.com/masatoi/cl-libsvm-format")
12351 (license license:expat))))
12353 (define-public cl-libsvm-format
12354 (sbcl-package->cl-source-package sbcl-cl-libsvm-format))
12356 (define-public ecl-cl-libsvm-format
12357 (sbcl-package->ecl-package sbcl-cl-libsvm-format))
12359 (define-public sbcl-cl-online-learning
12360 (let ((commit "fc7a34f4f161cd1c7dd747d2ed8f698947781423")
12363 (name "sbcl-cl-online-learning")
12364 (version (git-version "0.5" revision commit))
12368 (uri (git-reference
12369 (url "https://github.com/masatoi/cl-online-learning")
12371 (file-name (git-file-name name version))
12374 "14x95rlg80ay5hv645ki57pqvy12v28hz4k1w0f6bsfi2rmpxchq"))))
12375 (build-system asdf-build-system/sbcl)
12377 `(("prove" ,sbcl-prove)
12378 ("prove-asdf" ,sbcl-prove-asdf)))
12380 `(("cl-libsvm-format" ,sbcl-cl-libsvm-format)
12381 ("cl-store" ,sbcl-cl-store)))
12383 `(;; FIXME: Tests pass but then the check phase crashes
12385 (synopsis "Online Machine Learning for Common Lisp")
12387 "This library contains a collection of machine learning algorithms for
12388 online linear classification written in Common Lisp.")
12389 (home-page "https://github.com/masatoi/cl-online-learning")
12390 (license license:expat))))
12392 (define-public cl-online-learning
12393 (sbcl-package->cl-source-package sbcl-cl-online-learning))
12395 (define-public ecl-cl-online-learning
12396 (sbcl-package->ecl-package sbcl-cl-online-learning))
12398 (define-public sbcl-cl-random-forest
12399 (let ((commit "fedb36ce99bb6f4d7e3a7dd6d8b058f331308f91")
12402 (name "sbcl-cl-random-forest")
12403 (version (git-version "0.1" revision commit))
12407 (uri (git-reference
12408 (url "https://github.com/masatoi/cl-random-forest")
12410 (file-name (git-file-name name version))
12413 "0wqh4dxy5hrvm14jgyfypwhdw35f24rsksid4blz5a6l2z16rlmq"))))
12414 (build-system asdf-build-system/sbcl)
12416 `(("prove" ,sbcl-prove)
12417 ("prove-asdf" ,sbcl-prove-asdf)
12418 ("trivial-garbage" ,sbcl-trivial-garbage)))
12420 `(("alexandria" ,sbcl-alexandria)
12421 ("cl-libsvm-format" ,sbcl-cl-libsvm-format)
12422 ("cl-online-learning" ,sbcl-cl-online-learning)
12423 ("lparallel" ,sbcl-lparallel)))
12425 `(#:tests? #f)) ; The tests download data from the Internet
12426 (synopsis "Random Forest and Global Refinement for Common Lisp")
12428 "CL-random-forest is an implementation of Random Forest for multiclass
12429 classification and univariate regression written in Common Lisp. It also
12430 includes an implementation of Global Refinement of Random Forest.")
12431 (home-page "https://github.com/masatoi/cl-random-forest")
12432 (license license:expat))))
12434 (define-public cl-random-forest
12435 (sbcl-package->cl-source-package sbcl-cl-random-forest))
12437 (define-public ecl-cl-random-forest
12438 (sbcl-package->ecl-package sbcl-cl-random-forest))
12440 (define-public sbcl-bordeaux-fft
12441 (let ((commit "4a1f5600cae59bdabcb32de4ee2d7d73a9450d6e")
12444 (name "sbcl-bordeaux-fft")
12445 (version (git-version "1.0.1" revision commit))
12449 (uri (git-reference
12450 (url "https://github.com/ahefner/bordeaux-fft")
12452 (file-name (git-file-name name version))
12454 (base32 "0j584w6kq2k6r8lp2i14f9605rxhp3r15s33xs08iz1pndn6iwqf"))))
12455 (build-system asdf-build-system/sbcl)
12456 (home-page "http://vintage-digital.com/hefner/software/bordeaux-fft/")
12457 (synopsis "Fast Fourier Transform for Common Lisp")
12459 "The Bordeaux-FFT library provides a reasonably efficient implementation
12460 of the Fast Fourier Transform and its inverse for complex-valued inputs, in
12461 portable Common Lisp.")
12462 (license license:gpl2+))))
12464 (define-public cl-bordeaux-fft
12465 (sbcl-package->cl-source-package sbcl-bordeaux-fft))
12467 (define-public ecl-bordeaux-fft
12468 (sbcl-package->ecl-package sbcl-bordeaux-fft))
12470 (define-public sbcl-napa-fft3
12471 (let ((commit "f2d9614c7167da327c9ceebefb04ff6eae2d2236")
12474 (name "sbcl-napa-fft3")
12475 (version (git-version "0.0.1" revision commit))
12479 (uri (git-reference
12480 (url "https://github.com/pkhuong/Napa-FFT3")
12482 (file-name (git-file-name name version))
12484 (base32 "1hxjf599xgwm28gbryy7q96j9ys6hfszmv0qxpr5698hxnhknscp"))))
12485 (build-system asdf-build-system/sbcl)
12486 (home-page "https://github.com/pkhuong/Napa-FFT3")
12487 (synopsis "Fast Fourier Transform routines in Common Lisp")
12489 "Napa-FFT3 provides Discrete Fourier Transform (DFT) routines, but also
12490 buildings blocks to express common operations that involve DFTs: filtering,
12491 convolutions, etc.")
12492 (license license:bsd-3))))
12494 (define-public cl-napa-fft3
12495 (sbcl-package->cl-source-package sbcl-napa-fft3))
12497 (define-public sbcl-cl-tga
12498 (let ((commit "4dc2f7b8a259b9360862306640a07a23d4afaacc")
12501 (name "sbcl-cl-tga")
12502 (version (git-version "0.0.0" revision commit))
12506 (uri (git-reference
12507 (url "https://github.com/fisxoj/cl-tga")
12509 (file-name (git-file-name name version))
12511 (base32 "03k3npmn0xd3fd2m7vwxph82av2xrfb150imqrinlzqmzvz1v1br"))))
12512 (build-system asdf-build-system/sbcl)
12513 (home-page "https://github.com/fisxoj/cl-tga")
12514 (synopsis "TGA file loader for Common Lisp")
12516 "Cl-tga was written to facilitate loading @emph{.tga} files into OpenGL
12517 programs. It's a very simple library, and, at the moment, only supports
12518 non-RLE encoded forms of the files.")
12519 (license license:expat))))
12521 (define-public cl-tga
12522 (sbcl-package->cl-source-package sbcl-cl-tga))
12524 (define-public ecl-cl-tga
12525 (sbcl-package->ecl-package sbcl-cl-tga))
12527 (define-public sbcl-com.gigamonkeys.binary-data
12528 (let ((commit "22e908976d7f3e2318b7168909f911b4a00963ee")
12531 (name "sbcl-com.gigamonkeys.binary-data")
12532 (version (git-version "0.0.0" revision commit))
12536 (uri (git-reference
12537 (url "https://github.com/gigamonkey/monkeylib-binary-data")
12539 (file-name (git-file-name name version))
12541 (base32 "072v417vmcnvmyh8ddq9vmwwrizm7zwz9dpzi14qy9nsw8q649zw"))))
12542 (build-system asdf-build-system/sbcl)
12544 `(("alexandria" ,sbcl-alexandria)))
12545 (home-page "https://github.com/gigamonkey/monkeylib-binary-data")
12546 (synopsis "Common Lisp library for reading and writing binary data")
12548 "This a Common Lisp library for reading and writing binary data. It is
12549 based on code from chapter 24 of the book @emph{Practical Common Lisp}.")
12550 (license license:bsd-3))))
12552 (define-public cl-com.gigamonkeys.binary-data
12553 (sbcl-package->cl-source-package sbcl-com.gigamonkeys.binary-data))
12555 (define-public ecl-com.gigamonkeys.binary-data
12556 (sbcl-package->ecl-package sbcl-com.gigamonkeys.binary-data))
12558 (define-public sbcl-deflate
12560 (name "sbcl-deflate")
12565 (uri (git-reference
12566 (url "https://github.com/pmai/Deflate")
12567 (commit (string-append "release-" version))))
12568 (file-name (git-file-name name version))
12570 (base32 "1jpdjnxh6cw2d8hk70r2sxn92is52s9b855irvwkdd777fdciids"))))
12571 (build-system asdf-build-system/sbcl)
12572 (home-page "https://github.com/pmai/Deflate")
12573 (synopsis "Native deflate decompression for Common Lisp")
12575 "This library is an implementation of Deflate (RFC 1951) decompression,
12576 with optional support for ZLIB-style (RFC 1950) and gzip-style (RFC 1952)
12577 wrappers of deflate streams. It currently does not handle compression.")
12578 (license license:expat)))
12580 (define-public cl-deflate
12581 (sbcl-package->cl-source-package sbcl-deflate))
12583 (define-public ecl-deflate
12584 (sbcl-package->ecl-package sbcl-deflate))
12586 (define-public sbcl-skippy
12587 (let ((commit "e456210202ca702c792292c5060a264d45e47090")
12590 (name "sbcl-skippy")
12591 (version (git-version "1.3.12" revision commit))
12595 (uri (git-reference
12596 (url "https://github.com/xach/skippy")
12598 (file-name (git-file-name name version))
12600 (base32 "1sxbn5nh24qpx9w64x8mhp259cxcl1x8p126wk3b91ijjsj7l5vj"))))
12601 (build-system asdf-build-system/sbcl)
12602 (home-page "https://xach.com/lisp/skippy/")
12603 (synopsis "Common Lisp library for GIF images")
12605 "Skippy is a Common Lisp library to read and write GIF image files.")
12606 (license license:bsd-2))))
12608 (define-public cl-skippy
12609 (sbcl-package->cl-source-package sbcl-skippy))
12611 (define-public ecl-skippy
12612 (sbcl-package->ecl-package sbcl-skippy))
12614 (define-public sbcl-cl-freetype2
12615 (let ((commit "96058da730b4812df916c1f4ee18c99b3b15a3de")
12618 (name "sbcl-cl-freetype2")
12619 (version (git-version "1.1" revision commit))
12623 (uri (git-reference
12624 (url "https://github.com/rpav/cl-freetype2")
12626 (file-name (git-file-name name version))
12628 (base32 "0f8darhairgxnb5bzqcny7nh7ss3471bdzix5rzcyiwdbr5kymjl"))))
12629 (build-system asdf-build-system/sbcl)
12631 `(("fiveam" ,sbcl-fiveam)))
12633 `(("alexandria" ,sbcl-alexandria)
12634 ("cffi" ,sbcl-cffi)
12635 ("cffi-grovel" ,sbcl-cffi-grovel)
12636 ("freetype" ,freetype)
12637 ("trivial-garbage" ,sbcl-trivial-garbage)))
12640 (modify-phases %standard-phases
12641 (add-after 'unpack 'fix-paths
12642 (lambda* (#:key inputs #:allow-other-keys)
12643 (substitute* "src/ffi/ft2-lib.lisp"
12644 (("\"libfreetype\"")
12645 (string-append "\"" (assoc-ref inputs "freetype")
12646 "/lib/libfreetype\"")))
12647 (substitute* "src/ffi/grovel/grovel-freetype2.lisp"
12648 (("-I/usr/include/freetype")
12649 (string-append "-I" (assoc-ref inputs "freetype")
12650 "/include/freetype")))
12652 (home-page "https://github.com/rpav/cl-freetype2")
12653 (synopsis "Common Lisp bindings for Freetype 2")
12655 "This is a general Freetype 2 wrapper for Common Lisp using CFFI. It's
12656 geared toward both using Freetype directly by providing a simplified API, as
12657 well as providing access to the underlying C structures and functions for use
12658 with other libraries which may also use Freetype.")
12659 (license license:bsd-3))))
12661 (define-public cl-freetype2
12662 (sbcl-package->cl-source-package sbcl-cl-freetype2))
12664 (define-public ecl-cl-freetype2
12665 (sbcl-package->ecl-package sbcl-cl-freetype2))
12667 (define-public sbcl-opticl-core
12668 (let ((commit "b7cd13d26df6b824b216fbc360dc27bfadf04999")
12671 (name "sbcl-opticl-core")
12672 (version (git-version "0.0.0" revision commit))
12676 (uri (git-reference
12677 (url "https://github.com/slyrus/opticl-core")
12679 (file-name (git-file-name name version))
12681 (base32 "0458bllabcdjghfrqx6aki49c9qmvfmkk8jl75cfpi7q0i12kh95"))))
12682 (build-system asdf-build-system/sbcl)
12684 `(("alexandria" ,sbcl-alexandria)))
12685 (home-page "https://github.com/slyrus/opticl-core")
12686 (synopsis "Core classes and pixel access macros for Opticl")
12688 "This Common Lisp library contains the core classes and pixel access
12689 macros for the Opticl image processing library.")
12690 (license license:bsd-2))))
12692 (define-public cl-opticl-core
12693 (sbcl-package->cl-source-package sbcl-opticl-core))
12695 (define-public ecl-opticl-core
12696 (sbcl-package->ecl-package sbcl-opticl-core))
12698 (define-public sbcl-retrospectiff
12699 (let ((commit "c2a69d77d5010f8cdd9045b3e36a08a73da5d321")
12702 (name "sbcl-retrospectiff")
12703 (version (git-version "0.2" revision commit))
12707 (uri (git-reference
12708 (url "https://github.com/slyrus/retrospectiff")
12710 (file-name (git-file-name name version))
12712 (base32 "0qsn9hpd8j2kp43dk05j8dczz9zppdff5rrclbp45n3ksk9inw8i"))))
12713 (build-system asdf-build-system/sbcl)
12715 `(("fiveam" ,sbcl-fiveam)))
12717 `(("cl-jpeg" ,sbcl-cl-jpeg)
12718 ("com.gigamonkeys.binary-data" ,sbcl-com.gigamonkeys.binary-data)
12719 ("deflate" ,sbcl-deflate)
12720 ("flexi-streams" ,sbcl-flexi-streams)
12721 ("ieee-floats" ,sbcl-ieee-floats)
12722 ("opticl-core" ,sbcl-opticl-core)))
12723 (home-page "https://github.com/slyrus/retrospectiff")
12724 (synopsis "Common Lisp library for TIFF images")
12726 "Retrospectiff is a common lisp library for reading and writing images
12727 in the TIFF (Tagged Image File Format) format.")
12728 (license license:bsd-2))))
12730 (define-public cl-retrospectif
12731 (sbcl-package->cl-source-package sbcl-retrospectiff))
12733 (define-public ecl-retrospectiff
12734 (sbcl-package->ecl-package sbcl-retrospectiff))
12736 (define-public sbcl-mmap
12737 (let ((commit "ba2e98c67e25f0fb8ff838238561120a23903ce7")
12741 (version (git-version "1.0.0" revision commit))
12745 (uri (git-reference
12746 (url "https://github.com/Shinmera/mmap")
12748 (file-name (git-file-name name version))
12750 (base32 "0qd0xp20i1pcfn12kkapv9pirb6hd4ns7kz4zf1mmjwykpsln96q"))))
12751 (build-system asdf-build-system/sbcl)
12753 `(("alexandria" ,sbcl-alexandria)
12754 ("cffi" ,sbcl-cffi)
12755 ("parachute" ,sbcl-parachute)
12756 ("trivial-features" ,sbcl-trivial-features)))
12758 `(("cffi" ,sbcl-cffi)
12759 ("documentation-utils" ,sbcl-documentation-utils)))
12760 (home-page "https://shinmera.github.io/mmap/")
12761 (synopsis "File memory mapping for Common Lisp")
12763 "This is a utility library providing access to the @emph{mmap} family of
12764 functions in a portable way. It allows you to directly map a file into the
12765 address space of your process without having to manually read it into memory
12766 sequentially. Typically this is much more efficient for files that are larger
12768 (license license:zlib))))
12770 (define-public cl-mmap
12771 (sbcl-package->cl-source-package sbcl-mmap))
12773 (define-public ecl-mmap
12774 (sbcl-package->ecl-package sbcl-mmap))
12776 (define-public sbcl-3bz
12777 (let ((commit "d6119083b5e0b0a6dd3abc2877936c51f3f3deed")
12781 (version (git-version "0.0.0" revision commit))
12785 (uri (git-reference
12786 (url "https://github.com/3b/3bz")
12788 (file-name (git-file-name name version))
12790 (base32 "0fyxzyf2b6sc0w8d9g4nlva861565z6f3xszj0lw29x526dd9rhj"))))
12791 (build-system asdf-build-system/sbcl)
12793 `(("alexandria" ,sbcl-alexandria)
12794 ("babel" ,sbcl-babel)
12795 ("cffi" ,sbcl-cffi)
12796 ("mmap" ,sbcl-mmap)
12797 ("nibbles" ,sbcl-nibbles)
12798 ("trivial-features" ,sbcl-trivial-features)))
12800 ;; FIXME: Without the following line, the build fails (see issue 41437).
12801 `(#:asd-system-name "3bz"))
12802 (home-page "https://github.com/3b/3bz")
12803 (synopsis "Deflate decompression for Common Lisp")
12805 "3bz is an implementation of Deflate decompression (RFC 1951) optionally
12806 with zlib (RFC 1950) or gzip (RFC 1952) wrappers, with support for reading from
12807 foreign pointers (for use with mmap and similar, etc), and from CL octet
12808 vectors and streams.")
12809 (license license:expat))))
12811 (define-public cl-3bz
12812 (sbcl-package->cl-source-package sbcl-3bz))
12814 (define-public ecl-3bz
12815 (sbcl-package->ecl-package sbcl-3bz))
12817 (define-public sbcl-zpb-exif
12819 (name "sbcl-zpb-exif")
12824 (uri (git-reference
12825 (url "https://github.com/xach/zpb-exif")
12826 (commit (string-append "release-" version))))
12827 (file-name (git-file-name name version))
12829 (base32 "15s227jhby55cisz14xafb0p1ws2jmrg2rrbbd00lrb97im84hy6"))))
12830 (build-system asdf-build-system/sbcl)
12831 (home-page "https://xach.com/lisp/zpb-exif/")
12832 (synopsis "EXIF information extractor for Common Lisp")
12834 "This is a Common Lisp library to extract EXIF information from image
12836 (license license:bsd-2)))
12838 (define-public cl-zpb-exif
12839 (sbcl-package->cl-source-package sbcl-zpb-exif))
12841 (define-public ecl-zpb-exif
12842 (sbcl-package->ecl-package sbcl-zpb-exif))
12844 (define-public sbcl-pngload
12846 (name "sbcl-pngload")
12851 (uri (git-reference
12852 (url "https://github.com/bufferswap/pngload")
12854 (file-name (git-file-name name version))
12856 (base32 "1ix8dd0fxlf8xm0bszh1s7sx83hn0vqq8b8c9gkrd5m310w8mpvh"))))
12857 (build-system asdf-build-system/sbcl)
12859 `(("3bz" ,sbcl-3bz)
12860 ("alexandria" ,sbcl-alexandria)
12861 ("cffi" ,sbcl-cffi)
12862 ("mmap" ,sbcl-mmap)
12863 ("parse-float" ,sbcl-parse-float)
12864 ("static-vectors" ,sbcl-static-vectors)
12865 ("swap-bytes" ,sbcl-swap-bytes)
12866 ("zpb-exif" ,sbcl-zpb-exif)))
12868 ;; Test suite disabled because of a dependency cycle.
12869 ;; pngload tests depend on opticl which depends on pngload.
12871 (home-page "https://github.com/bufferswap/pngload")
12872 (synopsis "PNG image decoder for Common Lisp")
12874 "This is a Common Lisp library to load images in the PNG image format,
12875 both from files on disk, or streams in memory.")
12876 (license license:expat)))
12878 (define-public cl-pngload
12879 (sbcl-package->cl-source-package sbcl-pngload))
12881 (define-public ecl-pngload
12882 (sbcl-package->ecl-package sbcl-pngload))
12884 (define-public sbcl-opticl
12885 (let ((commit "e8684416eca2e78e82a7b436d436ef2ea24c019d")
12888 (name "sbcl-opticl")
12889 (version (git-version "0.0.0" revision commit))
12893 (uri (git-reference
12894 (url "https://github.com/slyrus/opticl")
12896 (file-name (git-file-name name version))
12898 (base32 "03rirnnhhisjbimlmpi725h1d3x0cfv00r57988am873dyzawmm1"))))
12899 (build-system asdf-build-system/sbcl)
12901 `(("fiveam" ,sbcl-fiveam)))
12903 `(("alexandria" ,sbcl-alexandria)
12904 ("cl-jpeg" ,sbcl-cl-jpeg)
12905 ("cl-tga" ,sbcl-cl-tga)
12906 ("png-read" ,sbcl-png-read)
12907 ("pngload" ,sbcl-pngload)
12908 ("retrospectiff" ,sbcl-retrospectiff)
12909 ("skippy" ,sbcl-skippy)
12910 ("zpng" ,sbcl-zpng)))
12911 (home-page "https://github.com/slyrus/opticl")
12912 (synopsis "Image processing library for Common Lisp")
12914 "Opticl is a Common Lisp library for representing, processing, loading,
12915 and saving 2-dimensional pixel-based images.")
12916 (license license:bsd-2))))
12918 (define-public cl-opticl
12919 (sbcl-package->cl-source-package sbcl-opticl))
12921 (define-public sbcl-clim-lisp
12922 (let ((commit "27b4d7a667c9b3faa74cabcb57706b888314fff7")
12925 (name "sbcl-clim-lisp")
12926 (version (git-version "0.9.7" revision commit))
12930 (uri (git-reference
12931 (url "https://github.com/mcclim/mcclim")
12933 (file-name (git-file-name name version))
12935 (base32 "0jijfgkwas6xnpp5wiii6slcx9pgsalngacb8zm29x6pamx2193h"))))
12936 (build-system asdf-build-system/sbcl)
12938 `(("alexandria" ,sbcl-alexandria)
12939 ("closer-mop" ,sbcl-closer-mop)
12940 ("log4cl" ,sbcl-log4cl)
12941 ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
12942 (home-page "https://common-lisp.net/project/mcclim/")
12943 (synopsis "Common Lisp GUI toolkit")
12945 "McCLIM is an implementation of the @emph{Common Lisp Interface Manager
12946 specification}, a toolkit for writing GUIs in Common Lisp.")
12947 (license license:lgpl2.1+))))
12949 (define-public sbcl-clim-basic
12951 (inherit sbcl-clim-lisp)
12952 (name "sbcl-clim-basic")
12954 `(("alexandria" ,sbcl-alexandria)
12955 ("babel" ,sbcl-babel)
12956 ("bordeaux-threads" ,sbcl-bordeaux-threads)
12957 ("clim-lisp" ,sbcl-clim-lisp)
12958 ("flexichain" ,sbcl-flexichain)
12959 ("spatial-trees" ,sbcl-spatial-trees)
12960 ("trivial-features" ,sbcl-trivial-features)
12961 ("trivial-garbage" ,sbcl-trivial-garbage)))
12963 '(#:asd-file "Core/clim-basic/clim-basic.asd"))))
12965 (define-public sbcl-clim-core
12967 (inherit sbcl-clim-lisp)
12968 (name "sbcl-clim-core")
12970 `(("clim-basic" ,sbcl-clim-basic)))
12972 '(#:asd-file "Core/clim-core/clim-core.asd"))))
12974 (define-public sbcl-esa-mcclim
12976 (inherit sbcl-clim-lisp)
12977 (name "sbcl-esa-mcclim")
12979 `(("alexandria" ,sbcl-alexandria)
12980 ("clim-core" ,sbcl-clim-core)))
12982 '(#:asd-file "Libraries/ESA/esa-mcclim.asd"))))
12984 (define-public sbcl-mcclim-fonts
12986 (inherit sbcl-clim-lisp)
12987 (name "sbcl-mcclim-fonts")
12989 `(("clim-basic" ,sbcl-clim-basic)))
12991 '(#:asd-file "Extensions/fonts/mcclim-fonts.asd"))))
12993 (define-public sbcl-automaton
12995 (inherit sbcl-clim-lisp)
12996 (name "sbcl-automaton")
13000 '(#:asd-file "Libraries/Drei/cl-automaton/automaton.asd"))))
13002 (define-public sbcl-persistent
13004 (inherit sbcl-clim-lisp)
13005 (name "sbcl-persistent")
13009 '(#:asd-file "Libraries/Drei/Persistent/persistent.asd"))))
13011 (define-public sbcl-drei-mcclim
13013 (inherit sbcl-clim-lisp)
13014 (name "sbcl-drei-mcclim")
13016 `(("fiveam" ,sbcl-fiveam)))
13018 `(("automaton" ,sbcl-automaton)
13019 ("clim-core" ,sbcl-clim-core)
13020 ("esa-mcclim" ,sbcl-esa-mcclim)
13021 ("flexichain" ,sbcl-flexichain)
13022 ("mcclim-fonts" ,sbcl-mcclim-fonts)
13023 ("persistent" ,sbcl-persistent)
13024 ("swank" ,cl-slime-swank)))
13026 '(#:asd-file "Libraries/Drei/drei-mcclim.asd"))))
13028 (define-public sbcl-clim
13030 (inherit sbcl-clim-lisp)
13033 `(("clim-core" ,sbcl-clim-core)
13034 ("drei-mcclim" ,sbcl-drei-mcclim)
13035 ("swank" ,cl-slime-swank))) ; For drei-mcclim
13037 '(#:asd-file "Core/clim/clim.asd"))))
13039 (define-public sbcl-mcclim-backend-common
13041 (inherit sbcl-clim-lisp)
13042 (name "sbcl-mcclim-backend-common")
13044 `(("fiveam" ,sbcl-fiveam)))
13046 `(("clim" ,sbcl-clim)
13047 ("swank" ,cl-slime-swank))) ; For drei-mcclim
13049 '(#:asd-file "Backends/common/mcclim-backend-common.asd"))))
13051 (define-public sbcl-mcclim-clx
13053 (inherit sbcl-clim-lisp)
13054 (name "sbcl-mcclim-clx")
13056 `(("alexandria" ,sbcl-alexandria)
13057 ("cl-unicode" ,sbcl-cl-unicode)
13059 ("mcclim-backend-common" ,sbcl-mcclim-backend-common)
13060 ("mcclim-fonts" ,sbcl-mcclim-fonts)
13061 ("swank" ,cl-slime-swank))) ; For drei-mcclim
13063 '(#:asd-file "Backends/CLX/mcclim-clx.asd"))))
13065 (define-public sbcl-mcclim-fonts-truetype
13067 (inherit sbcl-clim-lisp)
13068 (name "sbcl-mcclim-fonts-truetype")
13070 `(("alexandria" ,sbcl-alexandria)
13071 ("cl-aa" ,sbcl-cl-aa)
13072 ("cl-paths-ttf" ,sbcl-cl-paths-ttf)
13073 ("cl-vectors" ,sbcl-cl-vectors)
13074 ("clim-basic" ,sbcl-clim-basic)
13075 ("font-dejavu" ,font-dejavu)
13076 ("zpb-ttf" ,sbcl-zpb-ttf)))
13078 '(#:asd-file "Extensions/fonts/mcclim-fonts.asd"
13079 #:asd-system-name "mcclim-fonts/truetype"
13081 (modify-phases %standard-phases
13082 (add-after 'unpack 'fix-paths
13083 (lambda* (#:key inputs #:allow-other-keys)
13084 ;; mcclim-truetype uses DejaVu as default font and
13085 ;; sets the path at build time.
13086 (substitute* "Extensions/fonts/fontconfig.lisp"
13087 (("/usr/share/fonts/truetype/dejavu/")
13088 (string-append (assoc-ref inputs "font-dejavu")
13089 "/share/fonts/truetype/")))
13092 (define-public sbcl-mcclim-fonts-clx-truetype
13094 (inherit sbcl-clim-lisp)
13095 (name "sbcl-mcclim-fonts-clx-truetype")
13097 `(("mcclim-clx" ,sbcl-mcclim-clx)
13098 ("mcclim-fonts-truetype" ,sbcl-mcclim-fonts-truetype)
13099 ("swank" ,cl-slime-swank))) ; For drei-mcclim
13101 '(#:asd-file "./Extensions/fonts/mcclim-fonts.asd"
13102 #:asd-system-name "mcclim-fonts/clx-truetype"
13104 (modify-phases %standard-phases
13105 (add-after 'unpack 'fix-asd-system-names
13107 (substitute* "Extensions/fonts/mcclim-fonts.asd"
13108 ((":depends-on \\(#:mcclim-fonts/truetype")
13109 ":depends-on (#:mcclim-fonts-truetype"))
13112 (define-public sbcl-mcclim-clx-truetype
13114 (inherit sbcl-clim-lisp)
13115 (name "sbcl-mcclim-clx-truetype")
13117 `(("mcclim-clx" ,sbcl-mcclim-clx)
13118 ("mcclim-fonts-clx-truetype" ,sbcl-mcclim-fonts-clx-truetype)
13119 ("swank" ,cl-slime-swank))) ; For drei-mcclim
13121 '(#:asd-file "Backends/CLX/mcclim-clx.asd"
13122 #:asd-system-name "mcclim-clx/truetype"
13124 (modify-phases %standard-phases
13125 (add-after 'unpack 'fix-asd-system-names
13127 (substitute* "Backends/CLX/mcclim-clx.asd"
13128 (("mcclim-fonts/clx-truetype")
13129 "mcclim-fonts-clx-truetype"))
13132 (define-public sbcl-mcclim-fontconfig
13134 (inherit sbcl-clim-lisp)
13135 (name "sbcl-mcclim-fontconfig")
13137 `(("pkg-config" ,pkg-config)))
13139 `(("alexandria" ,sbcl-alexandria)
13140 ("cffi" ,sbcl-cffi)
13141 ("cffi-grovel" ,sbcl-cffi-grovel)
13142 ("fontconfig" ,fontconfig)))
13144 '(#:asd-file "Extensions/fontconfig/mcclim-fontconfig.asd"
13146 (modify-phases %standard-phases
13147 (add-after 'unpack 'fix-paths
13148 (lambda* (#:key inputs #:allow-other-keys)
13149 (substitute* "Extensions/fontconfig/src/functions.lisp"
13150 (("libfontconfig\\.so")
13151 (string-append (assoc-ref inputs "fontconfig")
13152 "/lib/libfontconfig.so")))
13154 (add-after 'unpack 'fix-build
13156 ;; The cffi-grovel system does not get loaded automatically,
13157 ;; so we load it explicitly.
13158 (substitute* "Extensions/fontconfig/mcclim-fontconfig.asd"
13159 (("\\(asdf:defsystem #:mcclim-fontconfig" all)
13160 (string-append "(asdf:load-system :cffi-grovel)\n" all)))
13163 (define-public sbcl-mcclim-harfbuzz
13165 (inherit sbcl-clim-lisp)
13166 (name "sbcl-mcclim-harfbuzz")
13168 `(("pkg-config" ,pkg-config)))
13170 `(("alexandria" ,sbcl-alexandria)
13171 ("cffi" ,sbcl-cffi)
13172 ("cffi-grovel" ,sbcl-cffi-grovel)
13173 ("freetype" ,freetype)
13174 ("harfbuzz" ,harfbuzz)
13175 ("trivial-garbage" ,sbcl-trivial-garbage)))
13177 '(#:asd-file "Extensions/harfbuzz/mcclim-harfbuzz.asd"
13179 (modify-phases %standard-phases
13180 (add-after 'unpack 'fix-paths
13181 (lambda* (#:key inputs #:allow-other-keys)
13182 (substitute* "Extensions/harfbuzz/src/functions.lisp"
13183 (("libharfbuzz\\.so")
13184 (string-append (assoc-ref inputs "harfbuzz")
13185 "/lib/libharfbuzz.so")))
13187 (add-after 'unpack 'fix-build
13189 ;; The cffi-grovel system does not get loaded automatically,
13190 ;; so we load it explicitly.
13191 (substitute* "Extensions/harfbuzz/mcclim-harfbuzz.asd"
13192 (("\\(asdf:defsystem #:mcclim-harfbuzz" all)
13193 (string-append "(asdf:load-system :cffi-grovel)\n" all)))
13196 (define-public sbcl-mcclim-fonts-clx-freetype
13198 (inherit sbcl-clim-lisp)
13199 (name "sbcl-mcclim-fonts-clx-freetype")
13201 `(("cl-freetype2" ,sbcl-cl-freetype2)
13202 ("mcclim-clx" ,sbcl-mcclim-clx)
13203 ("mcclim-fontconfig" ,sbcl-mcclim-fontconfig)
13204 ("mcclim-fonts" ,sbcl-mcclim-fonts)
13205 ("mcclim-harfbuzz" ,sbcl-mcclim-harfbuzz)
13206 ("swank" ,cl-slime-swank))) ; For drei-mcclim
13208 '(#:asd-file "Extensions/fonts/mcclim-fonts.asd"
13209 #:asd-system-name "mcclim-fonts/clx-freetype"))))
13211 (define-public sbcl-mcclim-clx-freetype
13213 (inherit sbcl-clim-lisp)
13214 (name "sbcl-mcclim-clx-freetype")
13216 `(("mcclim-clx" ,sbcl-mcclim-clx)
13217 ("mcclim-fonts-clx-freetype" ,sbcl-mcclim-fonts-clx-freetype)
13218 ("swank" ,cl-slime-swank))) ; For drei-mcclim
13220 '(#:asd-file "Backends/CLX/mcclim-clx.asd"
13221 #:asd-system-name "mcclim-clx/freetype"
13223 (modify-phases %standard-phases
13224 (add-after 'unpack 'fix-asd-system-names
13226 (substitute* "Backends/CLX/mcclim-clx.asd"
13227 (("mcclim-fonts/clx-freetype")
13228 "mcclim-fonts-clx-freetype"))
13231 (define-public sbcl-mcclim-render
13233 (inherit sbcl-clim-lisp)
13234 (name "sbcl-mcclim-render")
13236 `(("alexandria" ,sbcl-alexandria)
13237 ("cl-vectors" ,sbcl-cl-vectors)
13238 ("clim-basic" ,sbcl-clim-basic)
13239 ("mcclim-backend-common" ,sbcl-mcclim-backend-common)
13240 ("mcclim-fonts-truetype" ,sbcl-mcclim-fonts-truetype)
13241 ("swank" ,cl-slime-swank))) ; For drei-mcclim
13243 '(#:asd-file "Extensions/render/mcclim-render.asd"
13245 (modify-phases %standard-phases
13246 (add-after 'unpack 'fix-asd-system-names
13248 (substitute* "Extensions/render/mcclim-render.asd"
13249 (("mcclim-fonts/truetype")
13250 "mcclim-fonts-truetype"))
13253 (define-public sbcl-mcclim-clx-fb
13255 (inherit sbcl-clim-lisp)
13256 (name "sbcl-mcclim-clx-fb")
13258 `(("mcclim-backend-common" ,sbcl-mcclim-backend-common)
13259 ("mcclim-clx" ,sbcl-mcclim-clx)
13260 ("mcclim-render" ,sbcl-mcclim-render)
13261 ("swank" ,cl-slime-swank))) ; For drei-mcclim
13263 '(#:asd-file "Backends/CLX-fb/mcclim-clx-fb.asd"))))
13265 (define-public sbcl-mcclim-null
13267 (inherit sbcl-clim-lisp)
13268 (name "sbcl-mcclim-null")
13270 `(("clim" ,sbcl-clim)
13271 ("swank" ,cl-slime-swank))) ; For drei-mcclim
13273 '(#:asd-file "Backends/Null/mcclim-null.asd"))))
13275 (define-public sbcl-clim-postscript-font
13277 (inherit sbcl-clim-lisp)
13278 (name "sbcl-clim-postscript-font")
13280 `(("clim-basic" ,sbcl-clim-basic)
13281 ("mcclim-backend-common" ,sbcl-mcclim-backend-common)
13282 ("swank" ,cl-slime-swank))) ; For drei-mcclim
13284 '(#:asd-file "Backends/PostScript/clim-postscript-font.asd"))))
13286 (define-public sbcl-clim-postscript
13288 (inherit sbcl-clim-lisp)
13289 (name "sbcl-clim-postscript")
13291 `(("fiveam" ,sbcl-fiveam)))
13293 `(("clim-basic" ,sbcl-clim-basic)
13294 ("clim-postscript-font" ,sbcl-clim-postscript-font)
13295 ("swank" ,cl-slime-swank))) ; For drei-mcclim
13297 '(#:asd-file "Backends/PostScript/clim-postscript.asd"
13298 ;; Test suite disabled because of a dependency cycle.
13299 ;; The tests depend on mcclim/test-util, which depends on mcclim,
13300 ;; wich depends on mcclim/extensions, which depends on clim-postscript.
13303 (define-public sbcl-clim-pdf
13305 (inherit sbcl-clim-lisp)
13306 (name "sbcl-clim-pdf")
13308 `(("fiveam" ,sbcl-fiveam)))
13310 `(("cl-pdf" ,sbcl-cl-pdf)
13311 ("clim-basic" ,sbcl-clim-basic)
13312 ("clim-postscript-font" ,sbcl-clim-postscript-font)
13313 ("flexi-streams" ,sbcl-flexi-streams)
13314 ("swank" ,cl-slime-swank))) ; For drei-mcclim
13316 '(#:asd-file "Backends/PDF/clim-pdf.asd"
13317 ;; Test suite disabled because of a dependency cycle.
13318 ;; The tests depend on mcclim/test-util, which depends on mcclim,
13319 ;; wich depends on mcclim/extensions, which depends on clim-pdf.
13322 (define-public sbcl-mcclim-looks
13324 (inherit sbcl-clim-lisp)
13325 (name "sbcl-mcclim-looks")
13327 `(("clim" ,sbcl-clim)
13328 ("mcclim-clx" ,sbcl-mcclim-clx)
13329 ("mcclim-clx-fb" ,sbcl-mcclim-clx-fb)
13330 ("mcclim-clx-freetype" ,sbcl-mcclim-clx-freetype)
13331 ("mcclim-clx-truetype" ,sbcl-mcclim-clx-truetype)
13332 ("mcclim-null" ,sbcl-mcclim-null)
13333 ("swank" ,cl-slime-swank))) ; For drei-mcclim
13335 '(#:asd-file "mcclim.asd"
13336 #:asd-system-name "mcclim/looks"
13338 (modify-phases %standard-phases
13339 (add-after 'unpack 'fix-asd-system-names
13341 (substitute* "mcclim.asd"
13342 (("mcclim-clx/truetype")
13343 "mcclim-clx-truetype")
13344 (("mcclim-clx/freetype")
13345 "mcclim-clx-freetype"))
13348 (define-public sbcl-mcclim-franz
13350 (inherit sbcl-clim-lisp)
13351 (name "sbcl-mcclim-franz")
13353 `(("clim" ,sbcl-clim)
13354 ("swank" ,cl-slime-swank))) ; For drei-mcclim
13356 '(#:asd-file "Extensions/Franz/mcclim-franz.asd"))))
13358 (define-public sbcl-mcclim-bezier-core
13360 (inherit sbcl-clim-lisp)
13361 (name "sbcl-mcclim-bezier-core")
13363 `(("clim" ,sbcl-clim)
13364 ("clim-pdf" ,sbcl-clim-pdf)
13365 ("clim-postscript" ,sbcl-clim-postscript)
13366 ("mcclim-null" ,sbcl-mcclim-null)
13367 ("mcclim-render" ,sbcl-mcclim-render)
13368 ("swank" ,cl-slime-swank))) ; For drei-mcclim
13370 '(#:asd-file "Extensions/bezier/mcclim-bezier.asd"
13371 #:asd-system-name "mcclim-bezier/core"))))
13373 (define-public sbcl-mcclim-bezier-clx
13375 (inherit sbcl-clim-lisp)
13376 (name "sbcl-mcclim-bezier-clx")
13378 `(("clim" ,sbcl-clim)
13379 ("mcclim-bezier/core" ,sbcl-mcclim-bezier-core)
13380 ("mcclim-clx" ,sbcl-mcclim-clx)
13381 ("swank" ,cl-slime-swank))) ; For drei-mcclim
13383 '(#:asd-file "Extensions/bezier/mcclim-bezier.asd"
13384 #:asd-system-name "mcclim-bezier/clx"
13386 (modify-phases %standard-phases
13387 (add-after 'unpack 'fix-asd-system-names
13389 (substitute* "Extensions/bezier/mcclim-bezier.asd"
13390 (("mcclim-bezier/core\\)")
13391 "mcclim-bezier-core)"))
13394 (define-public sbcl-mcclim-bezier
13396 (inherit sbcl-clim-lisp)
13397 (name "sbcl-mcclim-bezier")
13399 `(("mcclim-bezier/clx" ,sbcl-mcclim-bezier-clx)
13400 ("mcclim-bezier/core" ,sbcl-mcclim-bezier-core)
13401 ("swank" ,cl-slime-swank))) ; For drei-mcclim
13403 '(#:asd-file "Extensions/bezier/mcclim-bezier.asd"
13405 (modify-phases %standard-phases
13406 (add-after 'unpack 'fix-asd-system-names
13408 (substitute* "Extensions/bezier/mcclim-bezier.asd"
13409 (("\\(#:mcclim-bezier/core")
13410 "(#:mcclim-bezier-core")
13411 (("#:mcclim-bezier/clx\\)\\)")
13412 "#:mcclim-bezier-clx))"))
13415 (define-public sbcl-mcclim-bitmaps
13417 (inherit sbcl-clim-lisp)
13418 (name "sbcl-mcclim-bitmaps")
13420 `(("clim-basic" ,sbcl-clim-basic)
13421 ("opticl" ,sbcl-opticl)))
13423 '(#:asd-file "Extensions/bitmap-formats/mcclim-bitmaps.asd"))))
13425 (define-public sbcl-conditional-commands
13427 (inherit sbcl-clim-lisp)
13428 (name "sbcl-conditional-commands")
13430 `(("clim-basic" ,sbcl-clim-basic)))
13432 '(#:asd-file "Extensions/conditional-commands/conditional-commands.asd"))))
13434 (define-public sbcl-mcclim-layouts-tab
13436 (inherit sbcl-clim-lisp)
13437 (name "sbcl-mcclim-layouts-tab")
13439 `(("clim" ,sbcl-clim)
13440 ("swank" ,cl-slime-swank))) ; For drei-mcclim
13442 '(#:asd-file "Extensions/layouts/mcclim-layouts.asd"
13443 #:asd-system-name "mcclim-layouts/tab"))))
13445 (define-public sbcl-mcclim-extensions
13447 (inherit sbcl-clim-lisp)
13448 (name "sbcl-mcclim-extensions")
13450 `(("clim-pdf" ,sbcl-clim-pdf)
13451 ("clim-postscript" ,sbcl-clim-postscript)
13452 ("conditional-commands" ,sbcl-conditional-commands)
13453 ("mcclim-bezier" ,sbcl-mcclim-bezier)
13454 ("mcclim-bitmaps" ,sbcl-mcclim-bitmaps)
13455 ("mcclim-franz" ,sbcl-mcclim-franz)
13456 ("mcclim-layouts-tab" ,sbcl-mcclim-layouts-tab)
13457 ("swank" ,cl-slime-swank))) ; For drei-mcclim
13459 '(#:asd-file "mcclim.asd"
13460 #:asd-system-name "mcclim/extensions"
13462 (modify-phases %standard-phases
13463 (add-after 'unpack 'fix-asd-system-names
13465 (substitute* "mcclim.asd"
13466 (("mcclim-layouts/tab")
13467 "mcclim-layouts-tab"))
13470 (define-public sbcl-mcclim
13472 (inherit sbcl-clim-lisp)
13473 (name "sbcl-mcclim")
13475 `(("fiveam" ,sbcl-fiveam)))
13477 `(("mcclim-looks" ,sbcl-mcclim-looks)
13478 ("mcclim-extensions" ,sbcl-mcclim-extensions)
13479 ("swank" ,cl-slime-swank))) ; For drei-mcclim
13482 (modify-phases %standard-phases
13483 (add-after 'unpack 'fix-asd-system-names
13485 (substitute* "mcclim.asd"
13486 ((":depends-on \\(\"mcclim/looks\" \"mcclim/extensions\"\\)")
13487 ":depends-on (\"mcclim-looks\" \"mcclim-extensions\")"))
13489 ;; Test suite disabled because of a dependency cycle.
13490 ;; The tests depend on mcclim/test-util, which depends on mcclim.
13493 (define-public cl-mcclim
13494 (let ((base (sbcl-package->cl-source-package sbcl-clim-lisp)))
13499 `(("fiveam" ,cl-fiveam)
13500 ("pkg-config" ,pkg-config)))
13502 `(("alexandria" ,cl-alexandria)
13503 ("babel" ,cl-babel)
13504 ("bordeaux-threads" ,cl-bordeaux-threads)
13507 ("cl-freetype2" ,cl-freetype2)
13508 ("cl-paths-ttf" ,cl-paths-ttf)
13510 ("cl-unicode" ,cl-unicode)
13511 ("cl-vectors" ,cl-vectors)
13512 ("closer-mop" ,cl-closer-mop)
13514 ("flexi-streams" ,cl-flexi-streams)
13515 ("flexichain" ,cl-flexichain)
13516 ("fontconfig" ,fontconfig)
13517 ("freetype" ,freetype)
13518 ("harfbuzz" ,harfbuzz)
13519 ("log4cl" ,cl-log4cl)
13520 ("opticl" ,cl-opticl)
13521 ("spatial-trees" ,cl-spatial-trees)
13522 ("trivial-features" ,cl-trivial-features)
13523 ("trivial-garbage" ,cl-trivial-garbage)
13524 ("trivial-gray-streams" ,cl-trivial-gray-streams)
13525 ("swank" ,cl-slime-swank)
13526 ("zpb-ttf" ,cl-zpb-ttf))))))
13528 (define-public sbcl-mcclim-test-util
13530 (inherit sbcl-clim-lisp)
13531 (name "sbcl-mcclim-test-util")
13533 `(("fiveam" ,sbcl-fiveam)
13534 ("mcclim" ,sbcl-mcclim)
13535 ("swank" ,cl-slime-swank))) ; For drei-mcclim
13537 '(#:asd-file "mcclim.asd"
13538 #:asd-system-name "mcclim/test-util"))))
13540 (define-public sbcl-mcclim-raster-image
13542 (inherit sbcl-clim-lisp)
13543 (name "sbcl-mcclim-raster-image")
13545 `(("fiveam" ,sbcl-fiveam)
13546 ("mcclim-test-util" ,sbcl-mcclim-test-util)))
13548 `(("clim-basic" ,sbcl-clim-basic)
13549 ("mcclim-backend-common" ,sbcl-mcclim-backend-common)
13550 ("mcclim-render" ,sbcl-mcclim-render)
13551 ("swank" ,cl-slime-swank))) ; For drei-mcclim
13553 '(#:asd-file "Backends/RasterImage/mcclim-raster-image.asd"
13555 (modify-phases %standard-phases
13556 (add-after 'unpack 'fix-asd-system-names
13558 (substitute* "Backends/RasterImage/mcclim-raster-image.asd"
13559 (("mcclim/test-util")
13560 "mcclim-test-util"))
13563 (define-public sbcl-clim-examples
13565 (inherit sbcl-clim-lisp)
13566 (name "sbcl-clim-examples")
13568 `(("alexandria" ,sbcl-alexandria)
13569 ("closer-mop" ,sbcl-closer-mop)
13570 ("mcclim" ,sbcl-mcclim)
13571 ("mcclim-bezier" ,sbcl-mcclim-bezier)
13572 ("mcclim-layouts-tab" ,sbcl-mcclim-layouts-tab)
13573 ("mcclim-raster-image" ,sbcl-mcclim-raster-image)
13574 ("swank" ,cl-slime-swank))) ; For drei-mcclim
13576 '(#:asd-file "Examples/clim-examples.asd"
13578 (modify-phases %standard-phases
13579 (add-after 'unpack 'fix-asd-system-names
13581 (substitute* "Examples/clim-examples.asd"
13582 (("mcclim-layouts/tab")
13583 "mcclim-layouts-tab"))
13586 (define-public sbcl-cl-inflector
13587 (let ((commit "f1ab16919ccce3bd82a0042677d9616dde2034fe")
13590 (name "sbcl-cl-inflector")
13591 (version (git-version "0.2" revision commit))
13595 (uri (git-reference
13596 (url "https://github.com/AccelerationNet/cl-inflector")
13598 (file-name (git-file-name name version))
13600 (base32 "1xwwlhik1la4fp984qnx2dqq24v012qv4x0y49sngfpwg7n0ya7y"))))
13601 (build-system asdf-build-system/sbcl)
13603 `(("lisp-unit2" ,sbcl-lisp-unit2)))
13605 `(("alexandria" ,sbcl-alexandria)
13606 ("cl-ppcre" ,sbcl-cl-ppcre)))
13607 (home-page "https://github.com/AccelerationNet/cl-inflector")
13608 (synopsis "Library to pluralize/singularize English and Portuguese words")
13610 "This is a common lisp library to easily pluralize and singularize
13611 English and Portuguese words. This is a port of the ruby ActiveSupport
13612 Inflector module.")
13613 (license license:expat))))
13615 (define-public cl-inflector
13616 (sbcl-package->cl-source-package sbcl-cl-inflector))
13618 (define-public ecl-cl-inflector
13619 (sbcl-package->ecl-package sbcl-cl-inflector))
13621 (define-public sbcl-qbase64
13623 (name "sbcl-qbase64")
13628 (uri (git-reference
13629 (url "https://github.com/chaitanyagupta/qbase64")
13631 (file-name (git-file-name name version))
13633 (base32 "1dir0s70ca3hagxv9x15zq4p4ajgl7jrcgqsza2n2y7iqbxh0dwi"))))
13634 (build-system asdf-build-system/sbcl)
13636 `(("metabang-bind" ,sbcl-metabang-bind)
13637 ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
13639 `(("fiveam" ,sbcl-fiveam)))
13640 (home-page "https://github.com/chaitanyagupta/qbase64")
13641 (synopsis "Base64 encoder and decoder for Common Lisp")
13642 (description "@code{qbase64} provides a fast and flexible base64 encoder
13643 and decoder for Common Lisp.")
13644 (license license:bsd-3)))
13646 (define-public cl-qbase64
13647 (sbcl-package->cl-source-package sbcl-qbase64))
13649 (define-public ecl-qbase64
13650 (sbcl-package->ecl-package sbcl-qbase64))
13652 (define-public sbcl-lw-compat
13653 ;; No release since 2013.
13654 (let ((commit "aabfe28c6c1a4949f9d7b3cb30319367c9fd1c0d"))
13656 (name "sbcl-lw-compat")
13657 (version (git-version "1.0.0" "1" commit))
13661 (uri (git-reference
13662 (url "https://github.com/pcostanza/lw-compat/")
13664 (file-name (git-file-name name version))
13666 (base32 "131rq5k2mlv9bfhmafiv6nfsivl4cxx13d9wr06v5jrqnckh4aav"))))
13667 (build-system asdf-build-system/sbcl)
13668 (home-page "https://github.com/pcostanza/lw-compat/")
13669 (synopsis "LispWorks utilities ported to other Common Lisp implementations")
13670 (description "This package contains a few utility functions from the
13671 LispWorks library that are used in software such as ContextL.")
13672 (license license:expat))))
13674 (define-public cl-lw-compat
13675 (sbcl-package->cl-source-package sbcl-lw-compat))
13677 (define-public ecl-lw-compat
13678 (sbcl-package->ecl-package sbcl-lw-compat))
13680 (define-public sbcl-contextl
13681 ;; No release since 2013.
13682 (let ((commit "5d18a71a85824f6c25a9f35a21052f967b8b6bb9"))
13684 (name "sbcl-contextl")
13685 (version (git-version "1.0.0" "1" commit))
13689 (uri (git-reference
13690 (url "https://github.com/pcostanza/contextl/")
13692 (file-name (git-file-name name version))
13694 (base32 "0gk1izx6l6g48nypmnm9r6mzjx0jixqjj2kc6klf8a88rr5xd226"))))
13695 (build-system asdf-build-system/sbcl)
13697 `(("closer-mop" ,sbcl-closer-mop)
13698 ("lw-compat" ,sbcl-lw-compat)))
13699 (home-page "https://github.com/pcostanza/contextl")
13700 (synopsis "Context-oriented programming for Common Lisp")
13701 (description "ContextL is a CLOS extension for Context-Oriented
13704 Find overview of ContextL's features in an overview paper:
13705 @url{http://www.p-cos.net/documents/contextl-soa.pdf}. See also this general
13706 overview article about COP which also contains some ContextL examples:
13707 @url{http://www.jot.fm/issues/issue_2008_03/article4/}.")
13708 (license license:expat))))
13710 (define-public cl-contextl
13711 (sbcl-package->cl-source-package sbcl-contextl))
13713 (define-public ecl-contextl
13714 (sbcl-package->ecl-package sbcl-contextl))
13716 (define-public sbcl-hu.dwim.common-lisp
13718 (name "sbcl-hu.dwim.common-lisp")
13719 (version "2015-07-09")
13723 (uri (string-append
13724 "http://beta.quicklisp.org/archive/hu.dwim.common-lisp/"
13725 version "/hu.dwim.common-lisp-"
13726 (string-replace-substring version "-" "")
13729 (base32 "13cxrvh55rw080mvfir7s7k735l9rcfh3khxp97qfwd5rz0gadb9"))))
13730 (build-system asdf-build-system/sbcl)
13732 `(("hu.dwim.asdf" ,sbcl-hu.dwim.asdf)))
13733 (home-page "http://dwim.hu/")
13734 (synopsis "Redefine some standard Common Lisp names")
13735 (description "This library is a redefinition of the standard Common Lisp
13736 package that includes a number of renames and shadows. ")
13737 (license license:public-domain)))
13739 (define-public cl-hu.dwim.common-lisp
13740 (sbcl-package->cl-source-package sbcl-hu.dwim.common-lisp))
13742 (define-public ecl-hu.dwim.common-lisp
13743 (sbcl-package->ecl-package sbcl-hu.dwim.common-lisp))
13745 (define-public sbcl-hu.dwim.common
13747 (name "sbcl-hu.dwim.common")
13748 (version "2015-07-09")
13752 (uri (string-append
13753 "http://beta.quicklisp.org/archive/hu.dwim.common/"
13754 version "/hu.dwim.common-"
13755 (string-replace-substring version "-" "")
13758 (base32 "12l1rr6w9m99w0b5gc6hv58ainjfhbc588kz6vwshn4gqsxyzbhp"))))
13759 (build-system asdf-build-system/sbcl)
13761 `(("hu.dwim.asdf" ,sbcl-hu.dwim.asdf)))
13763 `(("alexandria" ,sbcl-alexandria)
13764 ("anaphora" ,sbcl-anaphora)
13765 ("closer-mop" ,sbcl-closer-mop)
13766 ("hu.dwim.common-lisp" ,sbcl-hu.dwim.common-lisp)
13767 ("iterate" ,sbcl-iterate)
13768 ("metabang-bind" ,sbcl-metabang-bind)))
13769 (home-page "http://dwim.hu/")
13770 (synopsis "Common Lisp library shared by other hu.dwim systems")
13771 (description "This package contains a support library for other
13773 (license license:public-domain)))
13775 (define-public cl-hu.dwim.common
13776 (sbcl-package->cl-source-package sbcl-hu.dwim.common))
13778 (define-public ecl-hu.dwim.common
13779 (sbcl-package->ecl-package sbcl-hu.dwim.common))
13781 (define-public sbcl-hu.dwim.defclass-star
13783 (name "sbcl-hu.dwim.defclass-star")
13784 (version "2015-07-09")
13788 (uri (string-append
13789 "http://beta.quicklisp.org/archive/hu.dwim.defclass-star/"
13790 version "/hu.dwim.defclass-star-"
13791 (string-replace-substring version "-" "")
13794 (base32 "032982lyp0hm0ssxlyh572whi2hr4j1nqkyqlllaj373v0dbs3vs"))))
13795 (build-system asdf-build-system/sbcl)
13797 `(;; These 2 inputs are only needed tests which are disabled, see below.
13798 ;; ("hu.dwim.common" ,sbcl-hu.dwim.common)
13799 ;; Need cl- package for the :hu.dwim.stefil+hu.dwim.def+swank system.
13800 ;; ("hu.dwim.stefil" ,cl-hu.dwim.stefil)
13801 ("hu.dwim.asdf" ,sbcl-hu.dwim.asdf)))
13803 `(#:test-asd-file "hu.dwim.defclass-star.test.asd"
13804 ;; Tests require a circular dependency: hu.dwim.stefil -> hu.dwim.def
13805 ;; -> hu.dwim.util -> hu.dwim.defclass-star.
13807 (home-page "http://dwim.hu/?_x=dfxn&_f=mRIMfonK")
13808 (synopsis "Simplify definitions with defclass* and friends in Common Lisp")
13809 (description "@code{defclass-star} provides defclass* and defcondition* to
13810 simplify class and condition declarations. Features include:
13813 @item Automatically export all or select slots at compile time.
13814 @item Define the @code{:initarg} and @code{:accessor} automatically.
13815 @item Specify a name transformer for both the @code{:initarg} and
13816 @code{:accessor}, etc.
13817 @item Specify the @code{:initform} as second slot value.
13821 @url{https://common-lisp.net/project/defclass-star/configuration.lisp.html}
13823 (license license:public-domain)))
13825 (define-public cl-hu.dwim.defclass-star
13826 (sbcl-package->cl-source-package sbcl-hu.dwim.defclass-star))
13828 (define-public ecl-hu.dwim.defclass-star
13829 (sbcl-package->ecl-package sbcl-hu.dwim.defclass-star))
13831 (define-public sbcl-livesupport
13832 (let ((commit "71e6e412df9f3759ad8378fabb203913d82e228a")
13835 (name "sbcl-livesupport")
13836 (version (git-version "0.0.0" revision commit))
13840 (uri (git-reference
13841 (url "https://github.com/cbaggers/livesupport")
13843 (file-name (git-file-name name version))
13845 (base32 "1rvnl0mncylbx63608pz5llss7y92j7z3ydambk9mcnjg2mjaapg"))))
13846 (build-system asdf-build-system/sbcl)
13847 (home-page "https://github.com/cbaggers/livesupport")
13848 (synopsis "Some helpers that make livecoding a little easier")
13849 (description "This package provides a macro commonly used in livecoding to
13850 enable continuing when errors are raised. Simply wrap around a chunk of code
13851 and it provides a restart called @code{continue} which ignores the error and
13852 carrys on from the end of the body.")
13853 (license license:bsd-2))))
13855 (define-public cl-livesupport
13856 (sbcl-package->cl-source-package sbcl-livesupport))
13858 (define-public ecl-livesupport
13859 (sbcl-package->ecl-package sbcl-livesupport))
13861 (define-public sbcl-envy
13862 (let ((commit "956321b2852d58ba71c6fe621f5c2924178e9f88")
13866 (version (git-version "0.1" revision commit))
13867 (home-page "https://github.com/fukamachi/envy")
13871 (uri (git-reference
13874 (file-name (git-file-name name version))
13876 (base32 "17iwrfxcdinjbb2h6l09qf40s7xkbhrpmnljlwpjy8l8rll8h3vg"))))
13877 (build-system asdf-build-system/sbcl)
13878 ;; (native-inputs ; Only for tests.
13879 ;; `(("prove" ,sbcl-prove)
13880 ;; ("osicat" ,sbcl-osicat)))
13883 (modify-phases %standard-phases
13884 (add-after 'unpack 'fix-tests
13886 (substitute* "envy-test.asd"
13887 (("cl-test-more") "prove"))
13890 ;; Component ENVY-ASD::ENVY-TEST not found, required by #<SYSTEM "envy">
13891 ;; like xsubseq. Why?
13893 (synopsis "Common Lisp configuration switcher inspired by Perl's Config::ENV.")
13894 (description "Envy is a configuration manager for various applications.
13895 Envy uses an environment variable to determine a configuration to use. This
13896 can separate configuration system from an implementation.")
13897 (license license:bsd-2))))
13899 (define-public cl-envy
13900 (sbcl-package->cl-source-package sbcl-envy))
13902 (define-public ecl-envy
13903 (sbcl-package->ecl-package sbcl-envy))
13905 (define sbcl-mito-core
13906 (let ((commit "d3b9e375ef364a65692da2185085a08c969ac88a")
13909 (name "sbcl-mito-core")
13910 (version (git-version "0.1" revision commit))
13911 (home-page "https://github.com/fukamachi/mito")
13915 (uri (git-reference
13918 (file-name (git-file-name name version))
13920 (base32 "08mncgzjnbbsf1a6am3l73iw4lyfvz5ldjg5g84awfaxml4p73mb"))))
13921 (build-system asdf-build-system/sbcl)
13923 `(("dbi" ,sbcl-dbi)
13924 ("sxql" ,sbcl-sxql)
13925 ("cl-ppcre" ,sbcl-cl-ppcre)
13926 ("closer-mop" ,sbcl-closer-mop)
13927 ("dissect" ,sbcl-dissect)
13928 ("optima" ,sbcl-optima)
13929 ("cl-reexport" ,sbcl-cl-reexport)
13930 ("local-time" ,sbcl-local-time)
13931 ("uuid" ,sbcl-uuid)
13932 ("alexandria" ,sbcl-alexandria)))
13933 (synopsis "ORM for Common Lisp with migrations and relationships support")
13934 (description "Mito is yet another object relational mapper, and it aims
13935 to be a successor of Integral.
13938 @item Support MySQL, PostgreSQL and SQLite3.
13939 @item Add id (serial/uuid primary key), created_at and updated_at by default
13940 like Ruby's ActiveRecord.
13942 @item Database schema versioning.
13944 (license license:llgpl))))
13946 (define sbcl-mito-migration
13948 (inherit sbcl-mito-core)
13949 (name "sbcl-mito-migration")
13951 `(("mito-core" ,sbcl-mito-core)
13953 ("sxql" ,sbcl-sxql)
13954 ("closer-mop" ,sbcl-closer-mop)
13955 ("cl-reexport" ,sbcl-cl-reexport)
13956 ("uuid" ,sbcl-uuid)
13957 ("alexandria" ,sbcl-alexandria)
13958 ("esrap" ,sbcl-esrap)))))
13960 (define sbcl-lack-middleware-mito
13962 (inherit sbcl-mito-core)
13963 (name "sbcl-lack-middleware-mito")
13965 `(("mito-core" ,sbcl-mito-core)
13966 ("dbi" ,sbcl-dbi)))
13969 (modify-phases %standard-phases
13970 (add-after 'unpack 'fix-build
13972 (substitute* "lack-middleware-mito.asd"
13973 (("cl-dbi") "dbi"))
13976 (define-public sbcl-mito
13978 (inherit sbcl-mito-core)
13981 `(("mito-core" ,sbcl-mito-core)
13982 ("mito-migration" ,sbcl-mito-migration)
13983 ("lack-middleware-mito" ,sbcl-lack-middleware-mito)
13984 ("cl-reexport" ,sbcl-cl-reexport)))
13986 `(("prove" ,sbcl-prove)
13987 ("prove-asdf" ,sbcl-prove-asdf)
13988 ("dbd-mysql" ,sbcl-dbd-mysql)
13989 ("dbd-postgres" ,sbcl-dbd-postgres)
13990 ("dbd-sqlite3" ,sbcl-dbd-sqlite3)))
13993 (modify-phases %standard-phases
13994 (add-after 'unpack 'remove-non-functional-tests
13996 (substitute* "mito-test.asd"
13997 (("\\(:test-file \"db/mysql\"\\)") "")
13998 (("\\(:test-file \"db/postgres\"\\)") "")
13999 (("\\(:test-file \"dao\"\\)") "")
14000 ;; TODO: migration/sqlite3 should work, re-enable once
14001 ;; upstream has fixed it:
14002 ;; https://github.com/fukamachi/mito/issues/70
14003 (("\\(:test-file \"migration/sqlite3\"\\)") "")
14004 (("\\(:test-file \"migration/mysql\"\\)") "")
14005 (("\\(:test-file \"migration/postgres\"\\)") "")
14006 (("\\(:test-file \"postgres-types\"\\)") "")
14007 (("\\(:test-file \"mixin\"\\)") ""))
14009 ;; TODO: While all enabled tests pass, the phase fails with:
14010 ;; Component MITO-ASD::MITO-TEST not found, required by #<SYSTEM "mito">
14013 (define-public cl-mito
14014 (sbcl-package->cl-source-package sbcl-mito))
14016 (define-public sbcl-kebab
14017 (let ((commit "e7f77644c4e46131e7b8039d191d35fe6211f31b")
14020 (name "sbcl-kebab")
14021 (version (git-version "0.1" revision commit))
14022 (home-page "https://github.com/pocket7878/kebab")
14026 (uri (git-reference
14029 (file-name (git-file-name name version))
14031 (base32 "0j5haabnvj0vz0rx9mwyfsb3qzpga9nickbjw8xs6vypkdzlqv1b"))))
14032 (build-system asdf-build-system/sbcl)
14034 `(("cl-ppcre" ,sbcl-cl-ppcre)
14035 ("alexandria" ,sbcl-alexandria)
14036 ("cl-interpol" ,sbcl-cl-interpol)
14037 ("split-sequence" ,sbcl-split-sequence)))
14039 `(("prove-asdf" ,sbcl-prove-asdf)
14040 ("prove" ,sbcl-prove)))
14042 ;; Tests passes but the phase fails with
14043 ;; Component KEBAB-ASD::KEBAB-TEST not found, required by #<SYSTEM "kebab">.
14045 (synopsis "Common Lisp case converter")
14046 (description "This Common Lisp library converts strings, symbols and
14047 keywords between any of the following typographical cases: PascalCase,
14048 camelCase, snake_case, kebab-case (lisp-case).")
14049 (license license:llgpl))))
14051 (define-public cl-kebab
14052 (sbcl-package->cl-source-package sbcl-kebab))
14054 (define-public ecl-kebab
14055 (sbcl-package->ecl-package sbcl-kebab))
14057 (define-public sbcl-datafly
14058 (let ((commit "adece27fcbc4b5ea39ad1a105048b6b7166e3b0d")
14061 (name "sbcl-datafly")
14062 (version (git-version "0.1" revision commit))
14063 (home-page "https://github.com/fukamachi/datafly")
14067 (uri (git-reference
14070 (file-name (git-file-name name version))
14072 (base32 "16b78kzmglp2a4nxlxxl7rpf5zaibsgagn0p3c56fsxvx0c4hszv"))))
14073 (build-system asdf-build-system/sbcl)
14075 `(("alexandria" ,sbcl-alexandria)
14076 ("iterate" ,sbcl-iterate)
14077 ("optima" ,sbcl-optima)
14078 ("trivial-types" ,sbcl-trivial-types)
14079 ("closer-mop" ,sbcl-closer-mop)
14080 ("cl-syntax-annot" ,sbcl-cl-syntax-annot)
14081 ("sxql" ,sbcl-sxql)
14083 ("babel" ,sbcl-babel)
14084 ("local-time" ,sbcl-local-time)
14085 ("function-cache" ,sbcl-function-cache)
14086 ("jonathan" ,sbcl-jonathan)
14087 ("kebab" ,sbcl-kebab)
14088 ("log4cl" ,sbcl-log4cl)))
14090 `(("prove-asdf" ,sbcl-prove-asdf)
14091 ("prove" ,sbcl-prove)
14092 ("dbd-sqlite3" ,sbcl-dbd-sqlite3)))
14094 ;; TODO: Tests fail with
14095 ;; While evaluating the form starting at line 22, column 0
14096 ;; of #P"/tmp/guix-build-sbcl-datafly-0.1-1.adece27.drv-0/source/t/datafly.lisp":
14097 ;; Unhandled SQLITE:SQLITE-ERROR in thread #<SB-THREAD:THREAD "main thread" RUNNING
14099 ;; Error when binding parameter 1 to value NIL.
14100 ;; Code RANGE: column index out of range.
14102 (synopsis "Lightweight database library for Common Lisp")
14103 (description "Datafly is a lightweight database library for Common Lisp.")
14104 (license license:bsd-3))))
14106 (define-public cl-datafly
14107 (sbcl-package->cl-source-package sbcl-datafly))
14109 (define-public ecl-datafly
14110 (sbcl-package->ecl-package sbcl-datafly))
14112 (define-public sbcl-do-urlencode
14113 (let ((commit "199846441dad5dfac5478b8dee4b4e20d107af6a")
14116 (name "sbcl-do-urlencode")
14117 (version (git-version "0.0.0" revision commit))
14118 (home-page "https://github.com/drdo/do-urlencode")
14122 (uri (git-reference
14125 (file-name (git-file-name name version))
14127 (base32 "0k2i3d4k9cpci235mwfm0c5a4yqfkijr716bjv7cdlpzx88lazm9"))))
14128 (build-system asdf-build-system/sbcl)
14130 `(("alexandria" ,sbcl-alexandria)
14131 ("babel" ,sbcl-babel)))
14132 (synopsis "Percent Encoding (aka URL Encoding) Common Lisp library")
14133 (description "This library provides trivial percent encoding and
14134 decoding functions for URLs.")
14135 (license license:isc))))
14137 (define-public cl-do-urlencode
14138 (sbcl-package->cl-source-package sbcl-do-urlencode))
14140 (define-public ecl-do-urlencode
14141 (sbcl-package->ecl-package sbcl-do-urlencode))
14143 (define-public sbcl-cl-emb
14144 (let ((commit "fd8652174d048d4525a81f38cdf42f4fa519f840")
14147 (name "sbcl-cl-emb")
14148 (version (git-version "0.4.3" revision commit))
14149 (home-page "https://common-lisp.net/project/cl-emb/")
14153 (uri (git-reference
14154 (url "https://github.com/38a938c2/cl-emb")
14156 (file-name (git-file-name name version))
14158 (base32 "1xcm31n7afh5316lwz8iqbjx7kn5lw0l11arg8mhdmkx42aj4gkk"))))
14159 (build-system asdf-build-system/sbcl)
14161 `(("cl-ppcre" ,sbcl-cl-ppcre)))
14162 (synopsis "Templating system for Common Lisp")
14163 (description "A mixture of features from eRuby and HTML::Template. You
14164 could name it \"Yet Another LSP\" (LispServer Pages) but it's a bit more than
14165 that and not limited to a certain server or text format.")
14166 (license license:llgpl))))
14168 (define-public cl-emb
14169 (sbcl-package->cl-source-package sbcl-cl-emb))
14171 (define-public ecl-cl-emb
14172 (sbcl-package->ecl-package sbcl-cl-emb))
14174 (define-public sbcl-cl-project
14175 (let ((commit "151107014e534fc4666222d57fec2cc8549c8814")
14178 (name "sbcl-cl-project")
14179 (version (git-version "0.3.1" revision commit))
14180 (home-page "https://github.com/fukamachi/cl-project")
14184 (uri (git-reference
14187 (file-name (git-file-name name version))
14189 (base32 "1rmh6s1ncv8s2yrr14ja9wisgg745sq6xibqwb341ikdicxdp26y"))))
14190 (build-system asdf-build-system/sbcl)
14192 `(("cl-emb" ,sbcl-cl-emb)
14193 ("cl-ppcre" ,sbcl-cl-ppcre)
14194 ("local-time" ,sbcl-local-time)
14195 ("prove" ,sbcl-prove)))
14197 ;; Tests depend on caveman, which in turns depends on cl-project.
14199 (synopsis "Generate a skeleton for modern Common Lisp projects")
14200 (description "This library provides a modern project skeleton generator.
14201 In contract with other generators, CL-Project generates one package per file
14202 and encourages unit testing by generating a system for unit testing, so you
14203 can begin writing unit tests as soon as the project is generated.")
14204 (license license:llgpl))))
14206 (define-public cl-project
14207 (sbcl-package->cl-source-package sbcl-cl-project))
14209 (define-public ecl-cl-project
14210 (sbcl-package->ecl-package sbcl-cl-project))
14212 (define-public sbcl-caveman
14213 (let ((commit "faa5f7e3b364fd7e7096af9a7bb06728b8d80441") ; No release since 2012
14216 (name "sbcl-caveman")
14217 (version (git-version "2.4.0" revision commit))
14218 (home-page "http://8arrow.org/caveman/")
14222 (uri (git-reference
14223 (url "https://github.com/fukamachi/caveman/")
14225 (file-name (git-file-name name version))
14227 (base32 "0kh0gx05pczk8f7r9qdi4zn1p3d0a2prps27k7jpgvc1dxkl8qhq"))))
14228 (build-system asdf-build-system/sbcl)
14230 `(("ningle" ,cl-ningle)
14231 ("lack-request" ,sbcl-lack-request)
14232 ("lack-response" ,sbcl-lack-response)
14233 ("cl-project" ,sbcl-cl-project)
14235 ("cl-syntax-annot" ,sbcl-cl-syntax-annot)
14236 ("myway" ,sbcl-myway)
14237 ("quri" ,sbcl-quri)))
14239 `(("usocket" ,sbcl-usocket)
14240 ("dexador" ,sbcl-dexador)))
14242 `(#:asd-file "caveman2.asd"
14243 #:asd-system-name "caveman2"
14245 (modify-phases %standard-phases
14246 (add-after 'unpack 'remove-v1
14248 (delete-file-recursively "v1")
14249 (for-each delete-file
14250 '("README.v1.markdown" "caveman.asd" "caveman-test.asd")))))
14251 ;; TODO: Tests fail with:
14252 ;; writing /gnu/store/...-sbcl-caveman-2.4.0-1.faa5f7e/share/common-lisp/sbcl-source/caveman2/v2/t/tmp/myapp573/tests/myapp573.lisp
14253 ;; While evaluating the form starting at line 38, column 0
14254 ;; of #P"/tmp/guix-build-sbcl-caveman-2.4.0-1.faa5f7e.drv-0/source/v2/t/caveman.lisp":
14255 ;; Unhandled ASDF/FIND-COMPONENT:MISSING-COMPONENT in thread #<SB-THREAD:THREAD "main thread" RUNNING
14257 ;; Component "myapp573" not found
14259 (synopsis "Lightweight web application framework in Common Lisp")
14260 (description "Caveman is intended to be a collection of common parts for
14261 web applications. Caveman2 has three design goals:
14264 @item Be extensible.
14265 @item Be practical.
14266 @item Don't force anything.
14268 (license license:llgpl))))
14270 (define-public cl-caveman
14273 (sbcl-package->cl-source-package sbcl-caveman))
14275 `(("ningle" ,cl-ningle)))))
14277 (define-public ecl-caveman
14278 (sbcl-package->ecl-package sbcl-caveman))
14280 (define-public sbcl-lambda-fiddle
14281 (let ((commit "d16bba55acf6065b412f64ab8fdff679a4a32b1e") ;; no tagged branch
14284 (name "sbcl-lambda-fiddle")
14285 (version (git-version "1.0.0" revision commit))
14289 (uri (git-reference
14290 (url "https://github.com/Shinmera/lambda-fiddle")
14292 (file-name (git-file-name name version))
14294 (base32 "1zarj1pqjqmk95kdx1axkgpwy2wq3canczk7f9z5hvaw5an6gand"))))
14295 (build-system asdf-build-system/sbcl)
14296 (home-page "https://github.com/Shinmera/lambda-fiddle")
14297 (synopsis "Collection of utilities to process lambda-lists")
14298 (description "This collection of utilities is useful in contexts where
14299 you want a macro that uses lambda-lists in some fashion but need more precise
14301 (license license:zlib))))
14303 (define-public cl-lambda-fiddle
14304 (sbcl-package->cl-source-package sbcl-lambda-fiddle))
14306 (define-public ecl-lambda-fiddle
14307 (sbcl-package->ecl-package sbcl-lambda-fiddle))
14309 (define-public sbcl-xmls
14310 (let ((commit "18546f0850b1338e03997ffd1696add1cb1800d1") ;; no tagged branch
14314 (version (git-version "3.0.2" revision commit))
14318 (uri (git-reference
14319 (url "https://github.com/rpgoldman/xmls")
14321 (file-name (git-file-name name version))
14323 (base32 "1lmvfml2ldbb1wkhm25jqqk2bhwsz52hhcgljbnzj1xr8xhc3anp"))))
14325 `(("fiveam" ,sbcl-fiveam)))
14326 (build-system asdf-build-system/sbcl)
14327 (home-page "https://github.com/rpgoldman/xmls")
14328 (synopsis "Non-validating XML parser for Common Lisp")
14329 (description "Xmls is a self-contained, easily embedded parser that
14330 recognizes a useful subset of the XML spec. It provides a simple mapping from
14331 XML to Lisp structures or s-expressions and back.")
14332 (license license:bsd-2))))
14334 (define-public cl-xmls
14335 (sbcl-package->cl-source-package sbcl-xmls))
14337 (define-public ecl-xmls
14338 (sbcl-package->ecl-package sbcl-xmls))
14340 (define-public sbcl-geco
14347 (uri (string-append "https://common-lisp.net/project/geco/download/"
14348 "geco-" version ".tar.gz"))
14350 (base32 "0kk0bzr1019cfmf2b1jl1rk9shv3gx5z1znifxllg9mb98yqsgw0"))
14351 (patches (search-patches "sbcl-geco-fix-organism-class.patch"))))
14352 (build-system asdf-build-system/sbcl)
14353 (home-page "https://common-lisp.net/project/geco/")
14354 (synopsis "Genetic algorithm toolkit for Common Lisp")
14356 "GECO (Genetic Evolution through Combination of Objects) is an extensible,
14357 object-oriented framework for prototyping genetic algorithms in Common Lisp.")
14358 (license license:lgpl2.1+)))
14360 (define-public cl-geco
14361 (sbcl-package->cl-source-package sbcl-geco))
14363 (define-public ecl-geco
14364 (sbcl-package->ecl-package sbcl-geco))
14366 (define-public sbcl-html-entities
14367 (let ((commit "4af018048e891f41d77e7d680ed3aeb639e1eedb"))
14369 (name "sbcl-html-entities")
14370 (version (git-version "0.02" "1" commit))
14374 (uri (git-reference
14375 (url "https://github.com/BnMcGn/html-entities/")
14377 (file-name (git-file-name name version))
14379 (base32 "1b2yl6lf6vis17y4n5s505p7ica96bdafcl6vydy1hg50fy33nfr"))))
14380 (build-system asdf-build-system/sbcl)
14382 `(("ppcre" ,sbcl-cl-ppcre)))
14384 `(("fiveam" ,sbcl-fiveam)))
14385 (home-page "https://github.com/BnMcGn/html-entities/")
14386 (synopsis "Encode and decode entities in HTML with Common Lisp")
14387 (description "Html-entities is a Common Lisp library that lets you
14388 encode and decode entities in HTML.")
14389 (license license:expat))))
14391 (define-public cl-html-entities
14392 (sbcl-package->cl-source-package sbcl-html-entities))
14394 (define-public ecl-html-entities
14395 (sbcl-package->ecl-package sbcl-html-entities))
14397 (define-public sbcl-quicksearch
14398 (let ((commit "fb02ecf7c876ec580ab18c7d2c8c7814c06af599"))
14400 (name "sbcl-quicksearch")
14401 (version (git-version "0.01.04" "1" commit))
14405 (uri (git-reference
14406 (url "https://github.com/tkych/quicksearch/")
14408 (file-name (git-file-name name version))
14410 (base32 "16k19zjkhh7r64vjq371k5jwjs7cdfjz83flh561n4h4v1z89fps"))))
14411 (build-system asdf-build-system/sbcl)
14413 `(("bordeaux-threads" ,sbcl-bordeaux-threads)
14414 ("iterate" ,sbcl-iterate)
14415 ("alexandria" ,sbcl-alexandria)
14416 ("anaphora" ,sbcl-anaphora)
14417 ("ppcre" ,sbcl-cl-ppcre)
14418 ("drakma" ,sbcl-drakma)
14419 ("html-entities" ,sbcl-html-entities)
14420 ("yason" ,sbcl-yason)
14421 ("flexi-streams" ,sbcl-flexi-streams)
14422 ("do-urlencode" ,sbcl-do-urlencode)))
14423 (home-page "https://github.com/tkych/quicksearch/")
14424 (synopsis "Search Engine Interface for Common Lisp packages")
14425 (description "Quicksearch is a search-engine-interface for Common Lisp.
14426 The goal of Quicksearch is to find the Common Lisp library quickly. For
14427 example, if you will find the library about json, just type @code{(qs:?
14430 The function @code{quicksearch} searches for Common Lisp projects in
14431 Quicklisp, Cliki, GitHub and BitBucket, then outputs results in REPL. The
14432 function @code{?} is abbreviation wrapper for @code{quicksearch}.")
14433 (license license:expat))))
14435 (define-public cl-quicksearch
14436 (sbcl-package->cl-source-package sbcl-quicksearch))
14438 (define-public ecl-quicksearch
14439 (sbcl-package->ecl-package sbcl-quicksearch))
14441 (define-public sbcl-agutil
14442 (let ((commit "df188d754d472da9faa1601a48f1f37bb7b34d68"))
14444 (name "sbcl-agutil")
14445 (version (git-version "0.0.1" "1" commit))
14449 (uri (git-reference
14450 (url "https://github.com/alex-gutev/agutil/")
14452 (file-name (git-file-name name version))
14454 (base32 "1xpnyzksk2xld64b6lw6rw0gn5zxlb77jwna59sd4yl7kxhxlfpf"))))
14455 (build-system asdf-build-system/sbcl)
14457 `(("alexandria" ,sbcl-alexandria)
14458 ("trivia" ,sbcl-trivia)))
14459 (home-page "https://github.com/alex-gutev/agutil/")
14460 (synopsis "Collection of Common Lisp utilities")
14461 (description "A collection of Common Lisp utility functions and macros
14462 mostly not found in other utility packages.")
14463 (license license:expat))))
14465 (define-public cl-agutil
14466 (sbcl-package->cl-source-package sbcl-agutil))
14468 (define-public ecl-agutil
14469 (sbcl-package->ecl-package sbcl-agutil))
14471 (define-public sbcl-custom-hash-table
14472 (let ((commit "f26983133940f5edf826ebbc8077acc04816ddfa"))
14474 (name "sbcl-custom-hash-table")
14475 (version (git-version "0.3" "1" commit))
14479 (uri (git-reference
14480 (url "https://github.com/metawilm/cl-custom-hash-table")
14482 (file-name (git-file-name name version))
14484 (base32 "1k4mvrpbqqds2fwjxp1bxmrfmr8ch4dkwhnkbw559knbqshvrlj5"))))
14485 (build-system asdf-build-system/sbcl)
14487 '(#:asd-file "cl-custom-hash-table.asd"
14488 #:asd-system-name "cl-custom-hash-table"))
14489 (home-page "https://github.com/metawilm/cl-custom-hash-table")
14490 (synopsis "Custom hash tables for Common Lisp")
14491 (description "This library allows creation of hash tables with arbitrary
14492 @code{test}/@code{hash} functions, in addition to the @code{test} functions
14493 allowed by the standard (@code{EQ}, @code{EQL}, @code{EQUAL} and
14494 @code{EQUALP}), even in implementations that don't support this functionality
14496 (license license:expat))))
14498 (define-public cl-custom-hash-table
14499 (sbcl-package->cl-source-package sbcl-custom-hash-table))
14501 (define-public ecl-custom-hash-table
14502 (sbcl-package->ecl-package sbcl-custom-hash-table))
14504 (define-public sbcl-collectors
14505 (let ((commit "13acef25d8422d1d82e067b1861e513587c166ee"))
14507 (name "sbcl-collectors")
14508 (version (git-version "0.1" "1" commit))
14512 (uri (git-reference
14513 (url "https://github.com/AccelerationNet/collectors")
14515 (file-name (git-file-name name version))
14517 (base32 "1si68n1j6rpns8jw6ksqjpb937pdl30v7xza8rld7j5vh0jhy2yi"))))
14518 (build-system asdf-build-system/sbcl)
14520 `(("alexandria" ,sbcl-alexandria)
14521 ("closer-mop" ,sbcl-closer-mop)
14522 ("symbol-munger" ,sbcl-symbol-munger)))
14524 `(("lisp-unit2" ,sbcl-lisp-unit2)))
14525 (home-page "https://github.com/AccelerationNet/collectors/")
14526 (synopsis "Common lisp library providing collector macros")
14527 (description "A small collection of common lisp macros to make
14528 collecting values easier.")
14529 (license license:bsd-3))))
14531 (define-public cl-collectors
14532 (sbcl-package->cl-source-package sbcl-collectors))
14534 (define-public ecl-collectors
14535 (sbcl-package->ecl-package sbcl-collectors))
14537 (define-public cl-environments
14538 ;; TODO: asdf-build-system/sbcl fails here, why? See if it works with the
14539 ;; build system revamp once staging is merged after 2020-11-09.
14540 (let ((commit "bbcd958a9ff23ce3e6ea5f8ee2edad9634819a3a")) ; No version in 2 years.
14542 (name "cl-environments")
14543 (version (git-version "0.2.3" "1" commit))
14547 (uri (git-reference
14548 (url "https://github.com/alex-gutev/cl-environments")
14550 (file-name (git-file-name name version))
14553 "1pfxl3vcdrb4mjy4q4c3c7q95kzv6rfjif3hzd5q91i9z621d64r"))))
14554 (build-system asdf-build-system/source)
14556 `(("alexandria" ,cl-alexandria)
14557 ("anaphora" ,cl-anaphora)
14558 ("collectors" ,cl-collectors)
14559 ("optima" ,cl-optima)))
14561 `(("prove" ,sbcl-prove)
14562 ("prove-asdf" ,sbcl-prove-asdf)))
14563 (home-page "https://github.com/alex-gutev/cl-environments")
14564 (synopsis "Implements the Common Lisp standard environment access API")
14565 (description "This library provides a uniform API, as specified in Common
14566 Lisp the Language 2, for accessing information about variable and function
14567 bindings from implementation-defined lexical environment objects. All major
14568 Common Lisp implementations are supported, even those which don't support the
14569 CLTL2 environment access API.")
14570 (license license:expat))))
14572 (define-public sbcl-static-dispatch
14574 (name "sbcl-static-dispatch")
14579 (uri (git-reference
14580 (url "https://github.com/alex-gutev/static-dispatch")
14581 (commit (string-append "v" version))))
14582 (file-name (git-file-name name version))
14584 (base32 "1wp5yz8liqqic3yifqf33qhccd755pd7ycvsq1j4i7k3f1wm18i0"))))
14585 (build-system asdf-build-system/sbcl)
14587 `(("agutil" ,sbcl-agutil)
14588 ("alexandria" ,sbcl-alexandria)
14589 ("anaphora" ,sbcl-anaphora)
14590 ("arrows" ,sbcl-arrows)
14591 ("closer-mop" ,sbcl-closer-mop)
14592 ("iterate" ,sbcl-iterate)
14593 ("trivia" ,sbcl-trivia)))
14595 `(("cl-environments" ,cl-environments)))
14597 `(("prove-asdf" ,sbcl-prove-asdf)
14598 ("prove" ,sbcl-prove)))
14601 (modify-phases %standard-phases
14602 ;; Use `arrows' instead of cl-arrows which is abandoned and unlicensed.
14603 ;; https://github.com/nightfly19/cl-arrows/issues/5
14604 (add-after 'unpack 'use-arrows-instead-of-cl-arrows
14609 ((":cl-arrows") ":arrows")))
14610 '("static-dispatch.asd"
14612 "test/methods.lisp"
14613 "test/test.lisp")))))))
14614 (home-page "https://github.com/alex-gutev/static-dispatch")
14615 (synopsis "Static generic function dispatch for Common Lisp")
14616 (description "Static dispatch is a Common Lisp library, inspired by
14617 @code{inlined-generic-function}, which allows standard Common Lisp generic
14618 function dispatch to be performed statically (at compile time) rather than
14619 dynamically (runtime). This is similar to what is known as \"overloading\" in
14620 languages such as C++ and Java.
14622 The purpose of static dispatch is to provide an optimization in cases where
14623 the usual dynamic dispatch is too slow, and the dynamic features of generic
14624 functions, such as adding/removing methods at runtime are not required. An
14625 example of such a case is a generic equality comparison function. Currently
14626 generic functions are considered far too slow to implement generic arithmetic
14627 and comparison operations when used heavily in numeric code.")
14628 (license license:expat)))
14630 (define-public cl-static-dispatch
14631 (sbcl-package->cl-source-package sbcl-static-dispatch))
14633 (define-public ecl-static-dispatch
14634 (sbcl-package->ecl-package sbcl-static-dispatch))