gnu: sbcl-file-attributes: Update to 20210302.
[jackhill/guix/guix.git] / gnu / packages / lisp-xyz.scm
1 ;;; GNU Guix --- Functional package management for GNU
2 ;;; Copyright © 2014 John Darrington <jmd@gnu.org>
3 ;;; Copyright © 2015 Taylan Ulrich Bayırlı/Kammer <taylanbayirli@gmail.com>
4 ;;; Copyright © 2015 Mark H Weaver <mhw@netris.org>
5 ;;; Copyright © 2016 Federico Beffa <beffa@fbengineering.ch>
6 ;;; Copyright © 2016, 2017 Nikita <nikita@n0.is>
7 ;;; Copyright © 2016, 2017 Andy Patterson <ajpatter@uwaterloo.ca>
8 ;;; Copyright © 2017, 2019, 2020 Ricardo Wurmus <rekado@elephly.net>
9 ;;; Copyright © 2017, 2018, 2019, 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, 2021 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, 2021 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, 2021 Adam Kandur <rndd@tuta.io>
23 ;;; Copyright © 2020, 2021 Sharlatan Hellseher <sharlatanus@gmail.com>
24 ;;; Copyright © 2021 Aurora <rind38@disroot.org>
25 ;;; Copyright © 2021 Matthew Kraai <kraai@ftbfs.org>
26 ;;;
27 ;;; This file is part of GNU Guix.
28 ;;;
29 ;;; GNU Guix is free software; you can redistribute it and/or modify it
30 ;;; under the terms of the GNU General Public License as published by
31 ;;; the Free Software Foundation; either version 3 of the License, or (at
32 ;;; your option) any later version.
33 ;;;
34 ;;; GNU Guix is distributed in the hope that it will be useful, but
35 ;;; WITHOUT ANY WARRANTY; without even the implied warranty of
36 ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
37 ;;; GNU General Public License for more details.
38 ;;;
39 ;;; You should have received a copy of the GNU General Public License
40 ;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>.
41
42 ;;; This file only contains Common Lisp libraries.
43 ;;; Common Lisp compilers and tooling go to lisp.scm.
44 ;;; Common Lisp applications should go to the most appropriate file,
45 ;;; e.g. StumpWM is in wm.scm.
46
47 (define-module (gnu packages lisp-xyz)
48 #:use-module (gnu packages)
49 #:use-module ((guix licenses) #:prefix license:)
50 #:use-module (guix packages)
51 #:use-module (guix download)
52 #:use-module (guix git-download)
53 #:use-module (guix hg-download)
54 #:use-module (guix utils)
55 #:use-module (guix build-system asdf)
56 #:use-module (guix build-system trivial)
57 #:use-module (gnu packages base)
58 #:use-module (gnu packages c)
59 #:use-module (gnu packages compression)
60 #:use-module (gnu packages databases)
61 #:use-module (gnu packages enchant)
62 #:use-module (gnu packages file)
63 #:use-module (gnu packages fonts)
64 #:use-module (gnu packages fontutils)
65 #:use-module (gnu packages glib)
66 #:use-module (gnu packages gtk)
67 #:use-module (gnu packages imagemagick)
68 #:use-module (gnu packages libevent)
69 #:use-module (gnu packages libffi)
70 #:use-module (gnu packages linux)
71 #:use-module (gnu packages lisp)
72 #:use-module (gnu packages maths)
73 #:use-module (gnu packages mp3)
74 #:use-module (gnu packages networking)
75 #:use-module (gnu packages pkg-config)
76 #:use-module (gnu packages python)
77 #:use-module (gnu packages python-xyz)
78 #:use-module (gnu packages sqlite)
79 #:use-module (gnu packages tcl)
80 #:use-module (gnu packages tls)
81 #:use-module (gnu packages web)
82 #:use-module (gnu packages webkit)
83 #:use-module (gnu packages xdisorg)
84 #:use-module (ice-9 match)
85 #:use-module (srfi srfi-1)
86 #:use-module (srfi srfi-19))
87
88 (define-public sbcl-alexandria
89 (package
90 (name "sbcl-alexandria")
91 (version "1.2")
92 (source
93 (origin
94 (method git-fetch)
95 (uri (git-reference
96 (url "https://gitlab.common-lisp.net/alexandria/alexandria.git")
97 (commit (string-append "v" version))))
98 (sha256
99 (base32
100 "0bcqs0z9xlqgjz43qzgq9i07vdlnjllpm1wwa37wpkg0w975r712"))
101 (file-name (git-file-name name version))))
102 (build-system asdf-build-system/sbcl)
103 (native-inputs
104 `(("rt" ,sbcl-rt)))
105 (synopsis "Collection of portable utilities for Common Lisp")
106 (description
107 "Alexandria is a collection of portable utilities. It does not contain
108 conceptual extensions to Common Lisp. It is conservative in scope, and
109 portable between implementations.")
110 (home-page "https://common-lisp.net/project/alexandria/")
111 (license license:public-domain)))
112
113 (define-public cl-alexandria
114 (sbcl-package->cl-source-package sbcl-alexandria))
115
116 (define-public ecl-alexandria
117 (sbcl-package->ecl-package sbcl-alexandria))
118
119 (define-public sbcl-golden-utils
120 (let ((commit "9424419d867d5c2f819196ee41667a818a5058e7")
121 (revision "1"))
122 (package
123 (name "sbcl-golden-utils")
124 (version (git-version "0.0.0" revision commit))
125 (source
126 (origin
127 (method git-fetch)
128 (uri (git-reference
129 (url "https://git.mfiano.net/mfiano/golden-utils")
130 (commit commit)))
131 (file-name (git-file-name name version))
132 (sha256
133 (base32 "15x0phm6820yj3h37ibi06gjyh6z45sd2nz2n8lcbfflwm086q0h"))))
134 (build-system asdf-build-system/sbcl)
135 (inputs
136 `(("alexandria" ,sbcl-alexandria)))
137 (home-page "https://git.mfiano.net/mfiano/golden-utils")
138 (synopsis "Common Lisp utility library")
139 (description
140 "This is a Common Lisp library providing various utilities.")
141 (license license:expat))))
142
143 (define-public ecl-golden-utils
144 (sbcl-package->ecl-package sbcl-golden-utils))
145
146 (define-public cl-golden-utils
147 (sbcl-package->cl-source-package sbcl-golden-utils))
148
149 (define-public sbcl-asdf-finalizers
150 (let ((commit "7f537f6c598b662ae987c6acc268dd27c25977e0")
151 (revision "1"))
152 (package
153 (name "sbcl-asdf-finalizers")
154 (version (git-version "0.0.0" revision commit))
155 (source
156 (origin
157 (method git-fetch)
158 (uri (git-reference
159 (url "https://gitlab.common-lisp.net/asdf/asdf-finalizers")
160 (commit commit)))
161 (file-name (git-file-name name version))
162 (sha256
163 (base32 "1w56c9yjjydjshsgqxz57qlp2v3r4ilbisnsgiqphvxnhvd41y0v"))))
164 (build-system asdf-build-system/sbcl)
165 (native-inputs
166 `(("fare-utils" ,sbcl-fare-utils)
167 ("hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
168 (arguments
169 `(#:asd-files '("asdf-finalizers.asd"
170 "list-of.asd"
171 "asdf-finalizers-test.asd")
172 #:asd-systems '("asdf-finalizers"
173 "list-of")))
174 (home-page "https://gitlab.common-lisp.net/asdf/asdf-finalizers")
175 (synopsis "Enforced calling of finalizers for Lisp code")
176 (description "This library allows you to implement and enforce proper
177 finalization of compile-time constructs while building Lisp source files.
178
179 It produces two systems: asdf-finalizers and list-of.")
180 (license license:expat))))
181
182 (define-public ecl-asdf-finalizers
183 (sbcl-package->ecl-package sbcl-asdf-finalizers))
184
185 (define-public cl-asdf-finalizers
186 (sbcl-package->cl-source-package sbcl-asdf-finalizers))
187
188 (define-public sbcl-net.didierverna.asdf-flv
189 (package
190 (name "sbcl-net.didierverna.asdf-flv")
191 (version "2.1")
192 (source
193 (origin
194 (method git-fetch)
195 (uri (git-reference
196 (url "https://github.com/didierverna/asdf-flv")
197 (commit (string-append "version-" version))))
198 (file-name (git-file-name "asdf-flv" version))
199 (sha256
200 (base32 "1fi2y4baxan103jbg4idjddzihy03kwnj2mzbwrknw4d4x7xlgwj"))))
201 (build-system asdf-build-system/sbcl)
202 (synopsis "Common Lisp ASDF extension to provide support for file-local variables")
203 (description "ASDF-FLV provides support for file-local variables through
204 ASDF. A file-local variable behaves like @code{*PACKAGE*} and
205 @code{*READTABLE*} with respect to @code{LOAD} and @code{COMPILE-FILE}: a new
206 dynamic binding is created before processing the file, so that any
207 modification to the variable becomes essentially file-local.
208
209 In order to make one or several variables file-local, use the macros
210 @code{SET-FILE-LOCAL-VARIABLE(S)}.")
211 (home-page "https://www.lrde.epita.fr/~didier/software/lisp/misc.php#asdf-flv")
212 (license (license:non-copyleft
213 "https://www.gnu.org/prep/maintain/html_node/License-Notices-for-Other-Files.html"
214 "GNU All-Permissive License"))))
215
216 (define-public cl-net.didierverna.asdf-flv
217 (sbcl-package->cl-source-package sbcl-net.didierverna.asdf-flv))
218
219 (define-public ecl-net.didierverna.asdf-flv
220 (sbcl-package->ecl-package sbcl-net.didierverna.asdf-flv))
221
222 (define-public sbcl-command-line-arguments
223 (let ((commit "fbac862fb01c0e368141204f3f639920462c23fe")
224 (revision "1"))
225 (package
226 (name "sbcl-command-line-arguments")
227 (version (git-version "2.0.0" revision commit))
228 (source
229 (origin
230 (method git-fetch)
231 (uri (git-reference
232 (url "https://github.com/fare/command-line-arguments")
233 (commit commit)))
234 (file-name (git-file-name name version))
235 (sha256
236 (base32 "054m1ikndzqf72mb9ajaa64136cwr3bgag4yfbi1574a9vq75mjq"))))
237 (build-system asdf-build-system/sbcl)
238 (home-page "https://github.com/fare/command-line-arguments")
239 (synopsis "Trivial command-line argument parsing library for Common Lisp")
240 (description "This is a library to abstract away the parsing of
241 Unix-style command-line arguments. Use it in conjunction with asdf:program-op
242 or cl-launch for portable processing of command-line arguments.")
243 (license license:expat))))
244
245 (define-public ecl-command-line-arguments
246 (sbcl-package->ecl-package sbcl-command-line-arguments))
247
248 (define-public cl-command-line-arguments
249 (sbcl-package->cl-source-package sbcl-command-line-arguments))
250
251 (define-public sbcl-fiveam
252 (package
253 (name "sbcl-fiveam")
254 (version "1.4.1")
255 (source
256 (origin
257 (method git-fetch)
258 (uri (git-reference
259 (url "https://github.com/sionescu/fiveam")
260 (commit (string-append "v" version))))
261 (file-name (git-file-name "fiveam" version))
262 (sha256
263 (base32 "1q3d38pwafnwnw42clq0f8g5xw7pbzr287jl9jsqmb1vb0n1vrli"))))
264 (inputs
265 `(("alexandria" ,sbcl-alexandria)
266 ("net.didierverna.asdf-flv" ,sbcl-net.didierverna.asdf-flv)
267 ("trivial-backtrace" ,sbcl-trivial-backtrace)))
268 (build-system asdf-build-system/sbcl)
269 (synopsis "Common Lisp testing framework")
270 (description "FiveAM is a simple (as far as writing and running tests
271 goes) regression testing framework. It has been designed with Common Lisp's
272 interactive development model in mind.")
273 (home-page "https://common-lisp.net/project/fiveam/")
274 (license license:bsd-3)))
275
276 (define-public cl-fiveam
277 (sbcl-package->cl-source-package sbcl-fiveam))
278
279 (define-public ecl-fiveam
280 (sbcl-package->ecl-package sbcl-fiveam))
281
282 (define-public sbcl-cl-irc
283 (let ((commit "963823537c7bfcda2edd4c44d172192da6722175")
284 (revision "0"))
285 (package
286 (name "sbcl-cl-irc")
287 (version (git-version "0.9.2" revision commit))
288 (source
289 (origin
290 (method git-fetch)
291 (uri (git-reference
292 (url "https://salsa.debian.org/common-lisp-team/cl-irc.git")
293 (commit commit)))
294 (file-name (git-file-name "cl-irc" version))
295 (sha256
296 (base32 "1b3nqbb4pj377lxl47rfgrs82pidadnrc65l48bk553c2f59b52w"))))
297 (build-system asdf-build-system/sbcl)
298 (native-inputs
299 ;; Tests only.
300 `(("rt" ,sbcl-rt)))
301 (inputs
302 `(("cl+ssl" ,sbcl-cl+ssl)
303 ("flexi-streams" ,sbcl-flexi-streams)
304 ("split-sequence" ,sbcl-split-sequence)
305 ("usocket" ,sbcl-usocket)))
306 (arguments
307 `(#:asd-systems '("cl-irc") ;; Some inexisting "c" system is
308 ;; found by guix otherwise.
309 #:asd-files '("cl-irc.asd")
310 #:test-asd-file "test/cl-irc-test.asd"))
311 (synopsis "IRC client library for Common Lisp")
312 (description "@code{cl-irc} is a Common Lisp IRC client library that
313 features (partial) DCC, CTCP and all relevant commands from the IRC
314 RFCs (RFC2810, RFC2811 and RFC2812).
315
316 Features:
317 @itemize
318 @item implements all commands in the RFCs
319 @item extra convenience commands such as op/deop, ban, ignore, etc.
320 @item partial DCC SEND/CHAT support
321 @item event driven model with hooks makes interfacing easy
322 @item the user can keep multiple connections
323 @item all CTCP commands
324 @end itemize\n")
325 (home-page "https://common-lisp.net/project/cl-irc/")
326 (license license:bsd-2))))
327
328 (define-public cl-irc
329 (sbcl-package->cl-source-package sbcl-cl-irc))
330
331 (define-public ecl-cl-irc
332 (sbcl-package->ecl-package sbcl-cl-irc))
333
334 (define-public sbcl-trivial-timeout
335 (let ((commit "feb869357f40f5e109570fb40abad215fb370c6c")
336 (revision "1"))
337 (package
338 (name "sbcl-trivial-timeout")
339 (version (git-version "0.1.5" revision commit))
340 (source
341 (origin
342 (method git-fetch)
343 (uri (git-reference
344 (url "https://github.com/gwkkwg/trivial-timeout/")
345 (commit commit)))
346 (file-name (git-file-name "trivial-timeout" version))
347 (sha256
348 (base32 "1kninxwvvih9nhh7a9y8lfgi7pdr76675y1clw4ss17vz8fbim5p"))))
349 (build-system asdf-build-system/sbcl)
350 (native-inputs
351 `(("lift" ,sbcl-lift)))
352 (arguments
353 ;; NOTE: (Sharlatan-20210202T231437+0000): Due to the age of this library
354 ;; tests use some deprecated functionality and keep failing.
355 `(#:tests? #f))
356 (home-page "https://github.com/gwkkwg/trivial-timeout/")
357 (synopsis "Timeout library for Common Lisp")
358 (description
359 "This library provides an OS and implementation independent access to
360 timeouts.")
361 (license license:expat))))
362
363 (define-public ecl-trivial-timeout
364 (sbcl-package->ecl-package sbcl-trivial-timeout))
365
366 (define-public cl-trivial-timeout
367 (sbcl-package->cl-source-package sbcl-trivial-timeout))
368
369 (define-public sbcl-bordeaux-threads
370 (package
371 (name "sbcl-bordeaux-threads")
372 (version "0.8.8")
373 (source (origin
374 (method git-fetch)
375 (uri (git-reference
376 (url "https://github.com/sionescu/bordeaux-threads")
377 (commit (string-append "v" version))))
378 (sha256
379 (base32 "19i443fz3488v1pbbr9x24y8h8vlyhny9vj6c9jk5prm702awrp6"))
380 (file-name
381 (git-file-name "bordeaux-threads" version))))
382 (inputs `(("alexandria" ,sbcl-alexandria)))
383 (native-inputs `(("fiveam" ,sbcl-fiveam)))
384 (build-system asdf-build-system/sbcl)
385 (synopsis "Portable shared-state concurrency library for Common Lisp")
386 (description "BORDEAUX-THREADS is a proposed standard for a minimal
387 MP/Threading interface. It is similar to the CLIM-SYS threading and lock
388 support.")
389 (home-page "https://common-lisp.net/project/bordeaux-threads/")
390 (license license:x11)))
391
392 (define-public cl-bordeaux-threads
393 (sbcl-package->cl-source-package sbcl-bordeaux-threads))
394
395 (define-public ecl-bordeaux-threads
396 (sbcl-package->ecl-package sbcl-bordeaux-threads))
397
398 (define-public sbcl-trivial-gray-streams
399 (let ((revision "1")
400 (commit "ebd59b1afed03b9dc8544320f8f432fdf92ab010"))
401 (package
402 (name "sbcl-trivial-gray-streams")
403 (version (string-append "0.0.0-" revision "." (string-take commit 7)))
404 (source
405 (origin
406 (method git-fetch)
407 (uri
408 (git-reference
409 (url "https://github.com/trivial-gray-streams/trivial-gray-streams")
410 (commit commit)))
411 (sha256
412 (base32 "0b1pxlccmnagk9cbh4cy8s5k66g3x0gwib5shjwr24xvrji6lp94"))
413 (file-name
414 (string-append "trivial-gray-streams-" version "-checkout"))))
415 (build-system asdf-build-system/sbcl)
416 (synopsis "Compatibility layer for Gray streams implementations")
417 (description "Gray streams is an interface proposed for inclusion with
418 ANSI CL by David N. Gray. The proposal did not make it into ANSI CL, but most
419 popular CL implementations implement it. This package provides an extremely
420 thin compatibility layer for gray streams.")
421 (home-page "https://www.cliki.net/trivial-gray-streams")
422 (license license:x11))))
423
424 (define-public cl-trivial-gray-streams
425 (sbcl-package->cl-source-package sbcl-trivial-gray-streams))
426
427 (define-public ecl-trivial-gray-streams
428 (sbcl-package->ecl-package sbcl-trivial-gray-streams))
429
430 (define-public sbcl-fiasco
431 (let ((commit "d62f7558b21addc89f87e306f65d7f760632655f")
432 (revision "1"))
433 (package
434 (name "sbcl-fiasco")
435 (version (git-version "0.0.1" revision commit))
436 (source
437 (origin
438 (method git-fetch)
439 (uri (git-reference
440 (url "https://github.com/joaotavora/fiasco")
441 (commit commit)))
442 (file-name (git-file-name "fiasco" version))
443 (sha256
444 (base32
445 "1zwxs3d6iswayavcmb49z2892xhym7n556d8dnmvalc32pm9bkjh"))))
446 (build-system asdf-build-system/sbcl)
447 (inputs
448 `(("alexandria" ,sbcl-alexandria)
449 ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
450 (synopsis "Simple and powerful test framework for Common Lisp")
451 (description "A Common Lisp test framework that treasures your failures,
452 logical continuation of Stefil. It focuses on interactive debugging.")
453 (home-page "https://github.com/joaotavora/fiasco")
454 ;; LICENCE specifies this is public-domain unless the legislation
455 ;; doesn't allow or recognize it. In that case it falls back to a
456 ;; permissive licence.
457 (license (list license:public-domain
458 (license:x11-style "file://LICENCE"))))))
459
460 (define-public cl-fiasco
461 (sbcl-package->cl-source-package sbcl-fiasco))
462
463 (define-public ecl-fiasco
464 (sbcl-package->ecl-package sbcl-fiasco))
465
466 (define-public sbcl-flexi-streams
467 (package
468 (name "sbcl-flexi-streams")
469 (version "1.0.18")
470 (source
471 (origin
472 (method git-fetch)
473 (uri (git-reference
474 (url "https://github.com/edicl/flexi-streams")
475 (commit (string-append "v" version))))
476 (file-name (git-file-name "flexi-streams" version))
477 (sha256
478 (base32 "0bjv7fd2acknidc5dyi3h85pn10krxv5jyxs1xg8jya2rlfv7f1j"))))
479 (build-system asdf-build-system/sbcl)
480 (arguments
481 `(#:phases
482 (modify-phases %standard-phases
483 (add-after 'unpack 'make-git-checkout-writable
484 (lambda _
485 (for-each make-file-writable (find-files "."))
486 #t)))))
487 (inputs `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
488 (synopsis "Implementation of virtual bivalent streams for Common Lisp")
489 (description "Flexi-streams is an implementation of \"virtual\" bivalent
490 streams that can be layered atop real binary or bivalent streams and that can
491 be used to read and write character data in various single- or multi-octet
492 encodings which can be changed on the fly. It also supplies in-memory binary
493 streams which are similar to string streams.")
494 (home-page "http://weitz.de/flexi-streams/")
495 (license license:bsd-3)))
496
497 (define-public cl-flexi-streams
498 (sbcl-package->cl-source-package sbcl-flexi-streams))
499
500 (define-public ecl-flexi-streams
501 (sbcl-package->ecl-package sbcl-flexi-streams))
502
503 (define-public sbcl-cl-abnf
504 ;; There are no releases
505 (let ((commit "ba1fbb104dedbdaddb1ef93d2e4da711bd96cd70")
506 (revision "1"))
507 (package
508 (name "sbcl-cl-abnf")
509 (version (git-version "0.0.0" revision commit))
510 (source
511 (origin
512 (method git-fetch)
513 (uri (git-reference
514 (url "https://github.com/dimitri/cl-abnf")
515 (commit commit)))
516 (file-name (git-file-name "cl-abnf" version))
517 (sha256
518 (base32 "0f09nsndxa90acm71zd4qdnp40v705a4sqm04mnv9x76h6dlggmz"))))
519 (build-system asdf-build-system/sbcl)
520 (inputs
521 `(("cl-ppcre" ,sbcl-cl-ppcre)
522 ("esrap" ,sbcl-esrap)))
523 (arguments
524 `(#:asd-systems '("abnf")))
525 (home-page "https://github.com/dimitri/cl-abnf")
526 (synopsis "ABNF parser generator for Common Lisp")
527 (description "This Common Lisp library implements a parser generator for
528 the ABNF grammar format as described in RFC2234. The generated parser is a
529 regular expression scanner provided by the cl-ppcre lib, which means that we
530 can't parse recursive grammar definition. One such definition is the ABNF
531 definition as given by the RFC. Fortunately, as you have this lib, you most
532 probably don't need to generate another parser to handle that particular ABNF
533 grammar.")
534 (license license:expat))))
535
536 (define-public cl-abnf
537 (sbcl-package->cl-source-package sbcl-cl-abnf))
538
539 (define-public ecl-cl-abnf
540 (sbcl-package->ecl-package sbcl-cl-abnf))
541
542 (define-public sbcl-cl-ppcre
543 (package
544 (name "sbcl-cl-ppcre")
545 (version "2.1.1")
546 (source
547 (origin
548 (method git-fetch)
549 (uri (git-reference
550 (url "https://github.com/edicl/cl-ppcre")
551 (commit (string-append "v" version))))
552 (file-name (git-file-name "cl-ppcre" version))
553 (sha256
554 (base32 "0dwvr29diqzcg5n6jvbk2rnd90i05l7n828hhw99khmqd0kz7xsi"))))
555 (build-system asdf-build-system/sbcl)
556 (native-inputs
557 `(("flexi-streams" ,sbcl-flexi-streams)))
558 (arguments
559 `(#:phases
560 (modify-phases %standard-phases
561 (add-after 'unpack 'disable-ppcre-unicode
562 ;; cl-ppcre and cl-ppcre-unicode are put in different packages
563 ;; to work around the circular dependency between edicl/cl-ppcre
564 ;; and edicl/cl-unicode.
565 (lambda _
566 (delete-file "cl-ppcre-unicode.asd")
567 #t)))))
568 (synopsis "Portable regular expression library for Common Lisp")
569 (description "CL-PPCRE is a portable regular expression library for Common
570 Lisp, which is compatible with perl. It is pretty fast, thread-safe, and
571 compatible with ANSI-compliant Common Lisp implementations.")
572 (home-page "http://weitz.de/cl-ppcre/")
573 (license license:bsd-2)))
574
575 (define-public cl-ppcre
576 (sbcl-package->cl-source-package sbcl-cl-ppcre))
577
578 (define-public ecl-cl-ppcre
579 (sbcl-package->ecl-package sbcl-cl-ppcre))
580
581 (define-public sbcl-ubiquitous
582 (let ((commit "35eb7bd9e1b3daee1705f6b41260775180cce8af")
583 (revision "1"))
584 (package
585 (name "sbcl-ubiquitous")
586 (version (git-version "2.0.0" revision commit))
587 (source
588 (origin
589 (method git-fetch)
590 (uri (git-reference
591 (url "https://github.com/Shinmera/ubiquitous")
592 (commit commit)))
593 (file-name (git-file-name "ubiquitous" version))
594 (sha256
595 (base32 "1xlkaqmjcpkiv2xl2s2pvvrv976dlc846wm16s1lj62iy1315i49"))))
596 (build-system asdf-build-system/sbcl)
597 (inputs
598 `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
599 (arguments
600 '(#:asd-systems '("ubiquitous"
601 "ubiquitous-concurrent")))
602 (home-page "https://shinmera.github.io/ubiquitous/")
603 (synopsis "Application configuration mechanism for Common Lisp")
604 (description
605 "@code{UBIQUITOUS} is a very easy-to-use library for persistent
606 configuration storage. It automatically takes care of finding a suitable place
607 to save your data, and provides simple functions to access and modify the data
608 within.")
609 (license license:zlib))))
610
611 (define-public ecl-ubiquitous
612 (sbcl-package->ecl-package sbcl-ubiquitous))
613
614 (define-public cl-ubiquitous
615 (sbcl-package->cl-source-package sbcl-ubiquitous))
616
617 (define-public sbcl-uax-15
618 (package
619 (name "sbcl-uax-15")
620 (version "0.1.1")
621 (source
622 (origin
623 (method git-fetch)
624 (uri (git-reference
625 (url "https://github.com/sabracrolleton/uax-15")
626 (commit (string-append "v" version))))
627 (file-name (git-file-name "uax-15" version))
628 (sha256
629 (base32 "0p2ckw7mzxhwa9vbwj2q2dzayz9dl94d9yqd2ynp0pc5v8i0n2fr"))))
630 (build-system asdf-build-system/sbcl)
631 (arguments
632 `(#:asd-systems
633 '("uax-15")))
634 (native-inputs
635 `(("fiveam" ,sbcl-fiveam)))
636 (inputs
637 `(("cl-ppcre" ,sbcl-cl-ppcre)
638 ("split-sequence" ,sbcl-split-sequence)))
639 (home-page "https://github.com/sabracrolleton/uax-15")
640 (synopsis "Common Lisp implementation of unicode normalization functions")
641 (description
642 "This package provides supports for unicode normalization, RFC8264 and
643 RFC7564.")
644 (license license:expat)))
645
646 (define-public cl-uax-15
647 (sbcl-package->cl-source-package sbcl-uax-15))
648
649 (define-public ecl-uax-15
650 (sbcl-package->ecl-package sbcl-uax-15))
651
652 (define-public sbcl-cl-unicode
653 (package
654 (name "sbcl-cl-unicode")
655 (version "0.1.6")
656 (source (origin
657 (method git-fetch)
658 (uri (git-reference
659 (url "https://github.com/edicl/cl-unicode")
660 (commit (string-append "v" version))))
661 (file-name (git-file-name name version))
662 (sha256
663 (base32
664 "0ykx2s9lqfl74p1px0ik3l2izd1fc9jd1b4ra68s5x34rvjy0hza"))))
665 (build-system asdf-build-system/sbcl)
666 (native-inputs
667 `(("flexi-streams" ,sbcl-flexi-streams)))
668 (inputs
669 `(("cl-ppcre" ,sbcl-cl-ppcre)))
670 (home-page "http://weitz.de/cl-unicode/")
671 (synopsis "Portable Unicode library for Common Lisp")
672 (description "CL-UNICODE is a portable Unicode library Common Lisp, which
673 is compatible with perl. It is pretty fast, thread-safe, and compatible with
674 ANSI-compliant Common Lisp implementations.")
675 (license license:bsd-2)))
676
677 (define-public ecl-cl-unicode
678 (sbcl-package->ecl-package sbcl-cl-unicode))
679
680 (define-public cl-unicode
681 (sbcl-package->cl-source-package sbcl-cl-unicode))
682
683 (define-public sbcl-cl-ppcre-unicode
684 (package (inherit sbcl-cl-ppcre)
685 (name "sbcl-cl-ppcre-unicode")
686 (inputs
687 `(("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
688 ("sbcl-cl-unicode" ,sbcl-cl-unicode)))
689 (arguments
690 `(#:tests? #f ; tests fail with "Component :CL-PPCRE-TEST not found"
691 #:phases
692 (modify-phases %standard-phases
693 (add-after 'unpack 'disable-ppcre
694 ;; cl-ppcre and cl-ppcre-unicode are put in different packages
695 ;; to work around the circular dependency between edicl/cl-ppcre
696 ;; and edicl/cl-unicode.
697 (lambda _
698 (delete-file "cl-ppcre.asd")
699 #t)))))))
700
701 (define-public cl-ppcre-unicode
702 (sbcl-package->cl-source-package sbcl-cl-ppcre-unicode))
703
704 (define-public ecl-cl-ppcre-unicode
705 (sbcl-package->ecl-package sbcl-cl-ppcre-unicode))
706
707 (define-public sbcl-zpb-ttf
708 (package
709 (name "sbcl-zpb-ttf")
710 (version "1.0.3")
711 (source
712 (origin
713 (method git-fetch)
714 (uri (git-reference
715 (url "https://github.com/xach/zpb-ttf")
716 (commit (string-append "release-" version))))
717 (file-name (git-file-name name version))
718 (sha256
719 (base32
720 "1wh66vjijzqlydnrihynpwp6796917xwrh0i9li93c17kyxa74ih"))))
721 (build-system asdf-build-system/sbcl)
722 (home-page "https://github.com/xach/zpb-ttf")
723 (synopsis "TrueType font file access for Common Lisp")
724 (description
725 "ZPB-TTF is a TrueType font file parser that provides an interface for
726 reading typographic metrics, glyph outlines, and other information from the
727 file.")
728 (license license:bsd-2)))
729
730 (define-public ecl-zpb-ttf
731 (sbcl-package->ecl-package sbcl-zpb-ttf))
732
733 (define-public cl-zpb-ttf
734 (sbcl-package->cl-source-package sbcl-zpb-ttf))
735
736 (define-public sbcl-cl-vectors
737 (package
738 (name "sbcl-cl-vectors")
739 (version "0.1.5")
740 (source
741 (origin
742 (method url-fetch)
743 (uri (string-append "http://projects.tuxee.net/cl-vectors/"
744 "files/cl-vectors-" version ".tar.gz"))
745 (sha256
746 (base32
747 "04lhwi0kq8pkwhgd885pk80m1cp9sfvjjn5zj70s1dnckibhdmqh"))))
748 (build-system asdf-build-system/sbcl)
749 (inputs
750 `(("zpb-ttf" ,sbcl-zpb-ttf)))
751 (arguments
752 '(#:asd-systems '("cl-vectors"
753 "cl-paths-ttf")))
754 (home-page "http://projects.tuxee.net/cl-vectors/")
755 (synopsis "Create, transform and render anti-aliased vectorial paths")
756 (description
757 "This is a pure Common Lisp library to create, transform and render
758 anti-aliased vectorial paths.")
759 (license license:expat)))
760
761 (define-public ecl-cl-vectors
762 (sbcl-package->ecl-package sbcl-cl-vectors))
763
764 (define-public cl-vectors
765 (sbcl-package->cl-source-package sbcl-cl-vectors))
766
767 (define-public sbcl-spatial-trees
768 ;; There have been no releases.
769 (let ((commit "81fdad0a0bf109c80a53cc96eca2e093823400ba")
770 (revision "1"))
771 (package
772 (name "sbcl-spatial-trees")
773 (version (git-version "0" revision commit))
774 (source
775 (origin
776 (method git-fetch)
777 (uri (git-reference
778 (url "https://github.com/rpav/spatial-trees")
779 (commit commit)))
780 (file-name (git-file-name name version))
781 (sha256
782 (base32
783 "11rhc6h501dwcik2igkszz7b9n515cr99m5pjh4r2qfwgiri6ysa"))))
784 (build-system asdf-build-system/sbcl)
785 (arguments
786 '(#:tests? #f ; spatial-trees.test requires spatial-trees.nns
787 #:test-asd-file "spatial-trees.test.asd"))
788 (native-inputs
789 `(("fiveam" ,sbcl-fiveam)))
790 (home-page "https://github.com/rpav/spatial-trees")
791 (synopsis "Dynamic index data structures for spatially-extended data")
792 (description
793 "Spatial-trees is a set of dynamic index data structures for
794 spatially-extended data.")
795 (license license:bsd-3))))
796
797 (define-public ecl-spatial-trees
798 (sbcl-package->ecl-package sbcl-spatial-trees))
799
800 (define-public cl-spatial-trees
801 (sbcl-package->cl-source-package sbcl-spatial-trees))
802
803 (define-public sbcl-flexichain
804 ;; There are no releases.
805 (let ((commit "13d2a6c505ed0abfcd4c4ec7d7145059b06855d6")
806 (revision "1"))
807 (package
808 (name "sbcl-flexichain")
809 (version "1.5.1")
810 (source
811 (origin
812 (method git-fetch)
813 (uri (git-reference
814 (url "https://github.com/robert-strandh/Flexichain")
815 (commit commit)))
816 (file-name (git-file-name name version))
817 (sha256
818 (base32
819 "0pfyvhsfbjd2sjb30grfs52r51a428xglv7bwydvpg2lc117qimg"))))
820 (build-system asdf-build-system/sbcl)
821 (home-page "https://github.com/robert-strandh/Flexichain.git")
822 (synopsis "Dynamically add elements to or remove them from sequences")
823 (description
824 "This package provides an implementation of the flexichain protocol,
825 allowing client code to dynamically add elements to, and delete elements from
826 a sequence (or chain) of such elements.")
827 (license license:lgpl2.1+))))
828
829 (define-public ecl-flexichain
830 (sbcl-package->ecl-package sbcl-flexichain))
831
832 (define-public cl-flexichain
833 (sbcl-package->cl-source-package sbcl-flexichain))
834
835 (define-public sbcl-cl-pdf
836 ;; There are no releases
837 (let ((commit "752e337e6d6fc206f09d091a982e7f8e5c404e4e")
838 (revision "1"))
839 (package
840 (name "sbcl-cl-pdf")
841 (version (git-version "0" revision commit))
842 (source
843 (origin
844 (method git-fetch)
845 (uri (git-reference
846 (url "https://github.com/mbattyani/cl-pdf")
847 (commit commit)))
848 (file-name (git-file-name name version))
849 (sha256
850 (base32
851 "1cg3k3m3r11ipb8j008y8ipynj97l3xjlpi2knqc9ndmx4r3kb1r"))))
852 (build-system asdf-build-system/sbcl)
853 (inputs
854 `(("iterate" ,sbcl-iterate)
855 ("zpb-ttf" ,sbcl-zpb-ttf)))
856 (home-page "https://github.com/mbattyani/cl-pdf")
857 (synopsis "Common Lisp library for generating PDF files")
858 (description
859 "CL-PDF is a cross-platform Common Lisp library for generating PDF
860 files.")
861 (license license:bsd-2))))
862
863 (define-public ecl-cl-pdf
864 (sbcl-package->ecl-package sbcl-cl-pdf))
865
866 (define-public cl-pdf
867 (sbcl-package->cl-source-package sbcl-cl-pdf))
868
869 (define-public sbcl-clx
870 (package
871 (name "sbcl-clx")
872 (version "0.7.5")
873 (source
874 (origin
875 (method git-fetch)
876 (uri
877 (git-reference
878 (url "https://github.com/sharplispers/clx")
879 (commit version)))
880 (sha256
881 (base32
882 "1vi67z9hpj5rr4xcmfbfwzmlcc0ah7hzhrmfid6lqdkva238v2wf"))
883 (file-name (string-append "clx-" version))))
884 (build-system asdf-build-system/sbcl)
885 (native-inputs
886 `(("fiasco" ,sbcl-fiasco)))
887 (home-page "https://www.cliki.net/portable-clx")
888 (synopsis "X11 client library for Common Lisp")
889 (description "CLX is an X11 client library for Common Lisp. The code was
890 originally taken from a CMUCL distribution, was modified somewhat in order to
891 make it compile and run under SBCL, then a selection of patches were added
892 from other CLXes around the net.")
893 (license license:x11)))
894
895 (define-public cl-clx
896 (sbcl-package->cl-source-package sbcl-clx))
897
898 (define-public ecl-clx
899 (sbcl-package->ecl-package sbcl-clx))
900
901 (define-public sbcl-clx-truetype
902 (let ((commit "c6e10a918d46632324d5863a8ed067a83fc26de8")
903 (revision "1"))
904 (package
905 (name "sbcl-clx-truetype")
906 (version (git-version "0.0.1" revision commit))
907 (source
908 (origin
909 (method git-fetch)
910 (uri (git-reference
911 (url "https://github.com/l04m33/clx-truetype")
912 (commit commit)))
913 (file-name (git-file-name name version))
914 (sha256
915 (base32
916 "079hyp92cjkdfn6bhkxsrwnibiqbz4y4af6nl31lzw6nm91j5j37"))
917 (modules '((guix build utils)))
918 (snippet
919 '(begin
920 (substitute* "package.lisp"
921 ((":export") ":export\n :+font-cache-filename+"))
922 #t))))
923 (build-system asdf-build-system/sbcl)
924 (inputs
925 `(("clx" ,sbcl-clx)
926 ("zpb-ttf" ,sbcl-zpb-ttf)
927 ("cl-vectors" ,sbcl-cl-vectors)
928 ("cl-fad" ,sbcl-cl-fad)
929 ("cl-store" ,sbcl-cl-store)
930 ("trivial-features" ,sbcl-trivial-features)))
931 (home-page "https://github.com/l04m33/clx-truetype")
932 (synopsis "Antialiased TrueType font rendering using CLX and XRender")
933 (description "CLX-TrueType is pure common lisp solution for
934 antialiased TrueType font rendering using CLX and XRender extension.")
935 (license license:expat))))
936
937 (define-public cl-clx-truetype
938 (sbcl-package->cl-source-package sbcl-clx-truetype))
939
940 (define-public ecl-clx-truetype
941 (sbcl-package->ecl-package sbcl-clx-truetype))
942
943 (define-public sbcl-slynk
944 (let ((commit "0f46f91a9542599d62c0c332b39636b2941ea372"))
945 (package
946 (name "sbcl-slynk")
947 (version (git-version "1.0.43" "3" commit))
948 (source
949 (origin
950 (method git-fetch)
951 (uri
952 (git-reference
953 (url "https://github.com/joaotavora/sly")
954 (commit commit)))
955 (sha256
956 (base32 "0p3j0zylacy6vms8ngis2hx2351xnwfzsw3zy043q6vmqd14wrf1"))
957 (file-name (git-file-name "slynk" version))))
958 (build-system asdf-build-system/sbcl)
959 (outputs '("out" "image"))
960 (arguments
961 `(#:phases
962 (modify-phases %standard-phases
963 (add-after 'create-asdf-configuration 'build-image
964 (lambda* (#:key outputs #:allow-other-keys)
965 (build-image (string-append
966 (assoc-ref %outputs "image")
967 "/bin/slynk")
968 %outputs
969 #:dependencies '("slynk"
970 "slynk/arglists"
971 "slynk/fancy-inspector"
972 "slynk/package-fu"
973 "slynk/mrepl"
974 "slynk/trace-dialog"
975 "slynk/profiler"
976 "slynk/stickers"
977 "slynk/indentation"
978 "slynk/retro"))
979 #t)))))
980 (synopsis "Common Lisp IDE for Emacs")
981 (description "SLY is a fork of SLIME, an IDE backend for Common Lisp.
982 It also features a completely redesigned REPL based on Emacs's own
983 full-featured @code{comint-mode}, live code annotations, and a consistent interactive
984 button interface. Everything can be copied to the REPL. One can create
985 multiple inspectors with independent history.")
986 (home-page "https://github.com/joaotavora/sly")
987 (license license:public-domain)
988 (properties `((cl-source-variant . ,(delay cl-slynk)))))))
989
990 (define-public cl-slynk
991 (sbcl-package->cl-source-package sbcl-slynk))
992
993 (define-public ecl-slynk
994 (let ((pkg (sbcl-package->ecl-package sbcl-slynk)))
995 (package
996 (inherit pkg)
997 (outputs '("out"))
998 (arguments
999 (substitute-keyword-arguments (package-arguments pkg)
1000 ((#:phases phases)
1001 `(modify-phases ,phases
1002 (delete 'build-image))))))))
1003
1004 (define-public sbcl-parse-js
1005 (let ((commit "fbadc6029bec7039602abfc06c73bb52970998f6")
1006 (revision "1"))
1007 (package
1008 (name "sbcl-parse-js")
1009 (version (string-append "0.0.0-" revision "." (string-take commit 9)))
1010 (source
1011 (origin
1012 (method git-fetch)
1013 (uri (git-reference
1014 (url "http://marijn.haverbeke.nl/git/parse-js")
1015 (commit commit)))
1016 (file-name (string-append name "-" commit "-checkout"))
1017 (sha256
1018 (base32
1019 "1wddrnr5kiya5s3gp4cdq6crbfy9fqcz7fr44p81502sj3bvdv39"))))
1020 (build-system asdf-build-system/sbcl)
1021 (home-page "https://marijnhaverbeke.nl/parse-js/")
1022 (synopsis "Parse JavaScript")
1023 (description "Parse-js is a Common Lisp package for parsing
1024 JavaScript (ECMAScript 3). It has basic support for ECMAScript 5.")
1025 (license license:zlib))))
1026
1027 (define-public cl-parse-js
1028 (sbcl-package->cl-source-package sbcl-parse-js))
1029
1030 (define-public ecl-parse-js
1031 (sbcl-package->ecl-package sbcl-parse-js))
1032
1033 (define-public sbcl-parse-number
1034 (package
1035 (name "sbcl-parse-number")
1036 (version "1.7")
1037 (source
1038 (origin
1039 (method git-fetch)
1040 (uri (git-reference
1041 (url "https://github.com/sharplispers/parse-number/")
1042 (commit (string-append "v" version))))
1043 (file-name (git-file-name name version))
1044 (sha256
1045 (base32
1046 "0sk06ib1bhqv9y39vwnnw44vmbc4b0kvqm37xxmkxd4dwchq82d7"))))
1047 (build-system asdf-build-system/sbcl)
1048 (home-page "https://www.cliki.net/PARSE-NUMBER")
1049 (synopsis "Parse numbers")
1050 (description "@code{parse-number} is a library of functions for parsing
1051 strings into one of the standard Common Lisp number types without using the
1052 reader. @code{parse-number} accepts an arbitrary string and attempts to parse
1053 the string into one of the standard Common Lisp number types, if possible, or
1054 else @code{parse-number} signals an error of type @code{invalid-number}.")
1055 (license license:bsd-3)))
1056
1057 (define-public cl-parse-number
1058 (sbcl-package->cl-source-package sbcl-parse-number))
1059
1060 (define-public ecl-parse-number
1061 (sbcl-package->ecl-package sbcl-parse-number))
1062
1063 (define-public sbcl-iterate
1064 (package
1065 (name "sbcl-iterate")
1066 (version "1.5")
1067 (source
1068 (origin
1069 (method url-fetch)
1070 (uri (string-append "https://common-lisp.net/project/iterate/releases/"
1071 "iterate-" version ".tar.gz"))
1072 (sha256
1073 (base32
1074 "1lqsbhrkfl0yif46aymvb7l3nb9wdcmj4jyw485blj32jb4famzn"))))
1075 (build-system asdf-build-system/sbcl)
1076 (native-inputs
1077 `(("rt" ,sbcl-rt)))
1078 (home-page "https://common-lisp.net/project/iterate/")
1079 (synopsis "Iteration construct for Common Lisp")
1080 (description "@code{iterate} is an iteration construct for Common Lisp.
1081 It is similar to the @code{CL:LOOP} macro, with these distinguishing marks:
1082
1083 @itemize
1084 @item it is extensible,
1085 @item it helps editors like Emacs indent iterate forms by having a more
1086 lisp-like syntax, and
1087 @item it isn't part of the ANSI standard for Common Lisp.
1088 @end itemize\n")
1089 (license license:expat)))
1090
1091 (define-public cl-iterate
1092 (sbcl-package->cl-source-package sbcl-iterate))
1093
1094 (define-public ecl-iterate
1095 (sbcl-package->ecl-package sbcl-iterate))
1096
1097 (define-public sbcl-cl-uglify-js
1098 ;; There have been many bug fixes since the 2010 release.
1099 (let ((commit "429c5e1d844e2f96b44db8fccc92d6e8e28afdd5")
1100 (revision "1"))
1101 (package
1102 (name "sbcl-cl-uglify-js")
1103 (version (string-append "0.1-" revision "." (string-take commit 9)))
1104 (source
1105 (origin
1106 (method git-fetch)
1107 (uri (git-reference
1108 (url "https://github.com/mishoo/cl-uglify-js")
1109 (commit commit)))
1110 (file-name (git-file-name name version))
1111 (sha256
1112 (base32
1113 "0k39y3c93jgxpr7gwz7w0d8yknn1fdnxrjhd03057lvk5w8js27a"))))
1114 (build-system asdf-build-system/sbcl)
1115 (inputs
1116 `(("sbcl-parse-js" ,sbcl-parse-js)
1117 ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
1118 ("sbcl-cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)
1119 ("sbcl-parse-number" ,sbcl-parse-number)
1120 ("sbcl-iterate" ,sbcl-iterate)))
1121 (home-page "https://github.com/mishoo/cl-uglify-js")
1122 (synopsis "JavaScript compressor library for Common Lisp")
1123 (description "This is a Common Lisp version of UglifyJS, a JavaScript
1124 compressor. It works on data produced by @code{parse-js} to generate a
1125 @dfn{minified} version of the code. Currently it can:
1126
1127 @itemize
1128 @item reduce variable names (usually to single letters)
1129 @item join consecutive @code{var} statements
1130 @item resolve simple binary expressions
1131 @item group most consecutive statements using the @code{sequence} operator (comma)
1132 @item remove unnecessary blocks
1133 @item convert @code{IF} expressions in various ways that result in smaller code
1134 @item remove some unreachable code
1135 @end itemize\n")
1136 (license license:zlib))))
1137
1138 (define-public cl-uglify-js
1139 (sbcl-package->cl-source-package sbcl-cl-uglify-js))
1140
1141 (define-public ecl-cl-uglify-js
1142 (sbcl-package->ecl-package sbcl-cl-uglify-js))
1143
1144 (define-public uglify-js
1145 (package
1146 (inherit sbcl-cl-uglify-js)
1147 (name "uglify-js")
1148 (build-system trivial-build-system)
1149 (arguments
1150 `(#:modules ((guix build utils))
1151 #:builder
1152 (let* ((bin (string-append (assoc-ref %outputs "out") "/bin/"))
1153 (script (string-append bin "uglify-js")))
1154 (use-modules (guix build utils))
1155 (mkdir-p bin)
1156 (with-output-to-file script
1157 (lambda _
1158 (format #t "#!~a/bin/sbcl --script
1159
1160 (require :asdf)
1161 (asdf:initialize-source-registry
1162 #p\"~a/etc/common-lisp/source-registry.conf.d/\")
1163 (asdf:initialize-output-translations
1164 #p\"~a/etc/common-lisp/asdf-output-translations.conf.d/\")"
1165 (assoc-ref %build-inputs "sbcl")
1166 (assoc-ref %build-inputs "sbcl-cl-uglify-js")
1167 (assoc-ref %build-inputs "sbcl-cl-uglify-js"))
1168 ;; FIXME: cannot use progn here because otherwise it fails to
1169 ;; find cl-uglify-js.
1170 (for-each
1171 write
1172 '(;; Quiet, please!
1173 (let ((*standard-output* (make-broadcast-stream))
1174 (*error-output* (make-broadcast-stream)))
1175 (asdf:load-system :cl-uglify-js))
1176 (let ((file (cadr *posix-argv*)))
1177 (if file
1178 (format t "~a"
1179 (cl-uglify-js:ast-gen-code
1180 (cl-uglify-js:ast-mangle
1181 (cl-uglify-js:ast-squeeze
1182 (with-open-file (in file)
1183 (parse-js:parse-js in))))
1184 :beautify nil))
1185 (progn
1186 (format *error-output*
1187 "Please provide a JavaScript file.~%")
1188 (sb-ext:exit :code 1))))))))
1189 (chmod script #o755)
1190 #t)))
1191 (inputs
1192 `(("sbcl" ,sbcl)
1193 ("sbcl-cl-uglify-js" ,sbcl-cl-uglify-js)))
1194 (synopsis "JavaScript compressor")))
1195
1196 (define-public sbcl-cl-strings
1197 (let ((revision "1")
1198 (commit "c5c5cbafbf3e6181d03c354d66e41a4f063f00ae"))
1199 (package
1200 (name "sbcl-cl-strings")
1201 (version (git-version "0.0.0" revision commit))
1202 (source
1203 (origin
1204 (method git-fetch)
1205 (uri (git-reference
1206 (url "https://github.com/diogoalexandrefranco/cl-strings")
1207 (commit commit)))
1208 (sha256
1209 (base32
1210 "00754mfaqallj480lwd346nkfb6ra8pa8xcxcylf4baqn604zlmv"))
1211 (file-name (string-append "cl-strings-" version "-checkout"))))
1212 (build-system asdf-build-system/sbcl)
1213 (synopsis "Portable, dependency-free set of utilities to manipulate strings in Common Lisp")
1214 (description
1215 "@command{cl-strings} is a small, portable, dependency-free set of
1216 utilities that make it even easier to manipulate text in Common Lisp. It has
1217 100% test coverage and works at least on sbcl, ecl, ccl, abcl and clisp.")
1218 (home-page "https://github.com/diogoalexandrefranco/cl-strings")
1219 (license license:expat))))
1220
1221 (define-public cl-strings
1222 (sbcl-package->cl-source-package sbcl-cl-strings))
1223
1224 (define-public ecl-cl-strings
1225 (sbcl-package->ecl-package sbcl-cl-strings))
1226
1227 (define-public sbcl-trivial-features
1228 ;; No release since 2014.
1229 (let ((commit "870d03de0ed44067963350936856e17ee725153e"))
1230 (package
1231 (name "sbcl-trivial-features")
1232 (version (git-version "0.8" "1" commit))
1233 (source
1234 (origin
1235 (method git-fetch)
1236 (uri (git-reference
1237 (url "https://github.com/trivial-features/trivial-features")
1238 (commit commit)))
1239 (file-name (git-file-name "trivial-features" version))
1240 (sha256
1241 (base32 "14pcahr8r2j3idhyy216zyw8jnj1dnrx0qbkkbdqkvwzign1ah4j"))))
1242 (build-system asdf-build-system/sbcl)
1243 (arguments
1244 '(#:asd-files '("trivial-features.asd")
1245 #:tests? #f))
1246 (home-page "https://cliki.net/trivial-features")
1247 (synopsis "Ensures consistency of @code{*FEATURES*} in Common Lisp")
1248 (description "Trivial-features ensures that @code{*FEATURES*} is
1249 consistent across multiple Common Lisp implementations.")
1250 (license license:expat))))
1251
1252 (define-public cl-trivial-features
1253 (sbcl-package->cl-source-package sbcl-trivial-features))
1254
1255 (define-public ecl-trivial-features
1256 (sbcl-package->ecl-package sbcl-trivial-features))
1257
1258 (define-public sbcl-hu.dwim.asdf
1259 (let ((commit "67cdf84390e530af4303cc4bc815fdf2a5e48f59"))
1260 (package
1261 (name "sbcl-hu.dwim.asdf")
1262 (version "20200724")
1263 (source
1264 (origin
1265 (method git-fetch)
1266 (uri (git-reference
1267 (url "https://github.com/hu-dwim/hu.dwim.asdf")
1268 (commit commit)))
1269 (file-name (git-file-name name version))
1270 (sha256
1271 (base32
1272 "0p81jalilkaqw832a12s35q0z6rrarxjasm1jy6h4fvyj9pf0zkx"))))
1273 (build-system asdf-build-system/sbcl)
1274 (home-page "https://hub.darcs.net/hu.dwim/hu.dwim.asdf")
1275 (synopsis "Extensions to ASDF")
1276 (description "Various ASDF extensions such as attached test and
1277 documentation system, explicit development support, etc.")
1278 (license license:public-domain))))
1279
1280 (define-public cl-hu.dwim.asdf
1281 (sbcl-package->cl-source-package sbcl-hu.dwim.asdf))
1282
1283 (define-public ecl-hu.dwim.asdf
1284 (sbcl-package->ecl-package sbcl-hu.dwim.asdf))
1285
1286 (define-public sbcl-hu.dwim.stefil
1287 (let ((commit "414902c6f575818c39a8a156b8b61b1adfa73dad"))
1288 (package
1289 (name "sbcl-hu.dwim.stefil")
1290 (version (git-version "0.0.0" "2" commit))
1291 (source
1292 (origin
1293 (method git-fetch)
1294 (uri
1295 (git-reference
1296 (url "https://github.com/hu-dwim/hu.dwim.stefil")
1297 (commit commit)))
1298 (sha256
1299 (base32 "14izmjjim590rh74swrssavdmdznj2z8vhqixy780sjhpcr5pmkc"))
1300 (file-name (git-file-name "hu.dwim.stefil" version))))
1301 (build-system asdf-build-system/sbcl)
1302 (native-inputs
1303 `(("asdf:cl-hu.dwim.asdf" ,sbcl-hu.dwim.asdf)))
1304 (inputs
1305 `(("sbcl-alexandria" ,sbcl-alexandria)))
1306 (home-page "http://dwim.hu/project/hu.dwim.stefil")
1307 (synopsis "Simple test framework")
1308 (description "Stefil is a simple test framework for Common Lisp,
1309 with a focus on interactive development.")
1310 (license license:public-domain))))
1311
1312 (define-public cl-hu.dwim.stefil
1313 (sbcl-package->cl-source-package sbcl-hu.dwim.stefil))
1314
1315 (define-public ecl-hu.dwim.stefil
1316 (sbcl-package->ecl-package sbcl-hu.dwim.stefil))
1317
1318 (define-public sbcl-babel
1319 ;; No release since 2014.
1320 (let ((commit "aeed2d1b76358db48e6b70a64399c05678a6b9ea"))
1321 (package
1322 (name "sbcl-babel")
1323 (version (git-version "0.5.0" "1" commit))
1324 (source
1325 (origin
1326 (method git-fetch)
1327 (uri (git-reference
1328 (url "https://github.com/cl-babel/babel")
1329 (commit commit)))
1330 (file-name (git-file-name "babel" version))
1331 (sha256
1332 (base32 "0lkvv4xdpv4cv1y2bqillmabx8sdb2y4l6pbinq6mjh33w2brpvb"))))
1333 (build-system asdf-build-system/sbcl)
1334 (native-inputs
1335 `(("tests:cl-hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
1336 (inputs
1337 `(("sbcl-alexandria" ,sbcl-alexandria)
1338 ("sbcl-trivial-features" ,sbcl-trivial-features)))
1339 (home-page "https://common-lisp.net/project/babel/")
1340 (synopsis "Charset encoding and decoding library")
1341 (description "Babel is a charset encoding and decoding library, not unlike
1342 GNU libiconv, but completely written in Common Lisp.")
1343 (license license:expat))))
1344
1345 (define-public cl-babel
1346 (sbcl-package->cl-source-package sbcl-babel))
1347
1348 (define-public ecl-babel
1349 (sbcl-package->ecl-package sbcl-babel))
1350
1351 (define-public sbcl-cl-yacc
1352 (package
1353 (name "sbcl-cl-yacc")
1354 (version "0.3")
1355 (source
1356 (origin
1357 (method git-fetch)
1358 (uri (git-reference
1359 (url "https://github.com/jech/cl-yacc")
1360 (commit (string-append "cl-yacc-" version))))
1361 (sha256
1362 (base32
1363 "16946pzf8vvadnyfayvj8rbh4zjzw90h0azz2qk1mxrvhh5wklib"))
1364 (file-name (string-append "cl-yacc-" version "-checkout"))))
1365 (build-system asdf-build-system/sbcl)
1366 (arguments
1367 `(#:asd-systems '("yacc")))
1368 (synopsis "LALR(1) parser generator for Common Lisp, similar in spirit to Yacc")
1369 (description
1370 "CL-Yacc is a LALR(1) parser generator for Common Lisp, similar in spirit
1371 to AT&T Yacc, Berkeley Yacc, GNU Bison, Zebu, lalr.cl or lalr.scm.
1372
1373 CL-Yacc uses the algorithm due to Aho and Ullman, which is the one also used
1374 by AT&T Yacc, Berkeley Yacc and Zebu. It does not use the faster algorithm due
1375 to DeRemer and Pennello, which is used by Bison and lalr.scm (not lalr.cl).")
1376 (home-page "https://www.irif.fr/~jch//software/cl-yacc/")
1377 (license license:expat)))
1378
1379 (define-public cl-yacc
1380 (sbcl-package->cl-source-package sbcl-cl-yacc))
1381
1382 (define-public ecl-cl-yacc
1383 (sbcl-package->ecl-package sbcl-cl-yacc))
1384
1385 (define-public sbcl-eager-future2
1386 (let ((commit "54df8effd9d9eccac917509590286b5ac5f9cb30"))
1387 (package
1388 (name "sbcl-eager-future2")
1389 (version (git-version "0.0.0" "1" commit))
1390 (source
1391 (origin
1392 (method git-fetch)
1393 (uri (git-reference
1394 (url "https://gitlab.common-lisp.net/vsedach/eager-future2.git")
1395 (commit commit)))
1396 (file-name (git-file-name name version))
1397 (sha256
1398 (base32
1399 "1qs1bv3m0ki8l5czhsflxcryh22r9d9g9a3a3b0cr0pl954q5rld"))))
1400 (build-system asdf-build-system/sbcl)
1401 (inputs
1402 `(("bordeaux-threads" ,sbcl-bordeaux-threads)
1403 ("trivial-garbage" ,sbcl-trivial-garbage)))
1404 (synopsis "Futures promises synchronization mechanism for Common Lisp")
1405 (description
1406 "Eager Future2 is a Common Lisp library that provides composable
1407 concurrency primitives that unify parallel and lazy evaluation, are integrated
1408 with the Common Lisp condition system, and have automatic resource
1409 management.")
1410 (home-page "https://gitlab.common-lisp.net/vsedach/eager-future2")
1411 (license license:lgpl3+))))
1412
1413 (define-public cl-eager-future2
1414 (sbcl-package->cl-source-package sbcl-eager-future2))
1415
1416 (define-public ecl-eager-future2
1417 (sbcl-package->ecl-package sbcl-eager-future2))
1418
1419 (define-public sbcl-jpl-util
1420 (let ((commit "0311ed374e19a49d43318064d729fe3abd9a3b62"))
1421 (package
1422 (name "sbcl-jpl-util")
1423 (version "20151005")
1424 (source
1425 (origin
1426 (method git-fetch)
1427 (uri (git-reference
1428 ;; Quicklisp uses this fork.
1429 (url "https://github.com/hawkir/cl-jpl-util")
1430 (commit commit)))
1431 (file-name
1432 (git-file-name "jpl-util" version))
1433 (sha256
1434 (base32
1435 "0nc0rk9n8grkg3045xsw34whmcmddn2sfrxki4268g7kpgz0d2yz"))))
1436 (build-system asdf-build-system/sbcl)
1437 (synopsis "Collection of Common Lisp utility functions and macros")
1438 (description
1439 "@command{cl-jpl-util} is a collection of Common Lisp utility functions
1440 and macros, primarily for software projects written in CL by the author.")
1441 (home-page "https://www.thoughtcrime.us/software/cl-jpl-util/")
1442 (license license:isc))))
1443
1444 (define-public cl-jpl-util
1445 (sbcl-package->cl-source-package sbcl-jpl-util))
1446
1447 (define-public ecl-jpl-util
1448 (sbcl-package->ecl-package sbcl-jpl-util))
1449
1450 (define-public sbcl-piping
1451 (let ((commit "c7a4163c00dea7e72bf6ad33d6abac0d5826a656")
1452 (revision "1"))
1453 (package
1454 (name "sbcl-piping")
1455 (version (git-version "2.0.0" revision commit))
1456 (source
1457 (origin
1458 (method git-fetch)
1459 (uri (git-reference
1460 (url "https://github.com/Shinmera/piping/")
1461 (commit commit)))
1462 (file-name (git-file-name "piping" version))
1463 (sha256
1464 (base32 "0in84qnfkynm36d4n4d6v87vprpi27xrydnga462wfhplji6klv5"))))
1465 (build-system asdf-build-system/sbcl)
1466 (home-page "https://shinmera.github.io/piping/")
1467 (synopsis "Library to enable simple message pipelines")
1468 (description
1469 "This is a Common Lisp library to enable simple message pipelines.")
1470 (license license:zlib))))
1471
1472 (define-public ecl-piping
1473 (sbcl-package->ecl-package sbcl-piping))
1474
1475 (define-public cl-piping
1476 (sbcl-package->cl-source-package sbcl-piping))
1477
1478 (define-public sbcl-cl-pcg
1479 (let ((commit "8263d85ab0ca17fb05637a4430c2d564456bce8f")
1480 (revision "1"))
1481 (package
1482 (name "sbcl-cl-pcg")
1483 (version (git-version "1.0.0" revision commit))
1484 (source
1485 (origin
1486 (method git-fetch)
1487 (uri (git-reference
1488 (url "https://github.com/sjl/cl-pcg")
1489 (commit commit)))
1490 (file-name (git-file-name "cl-pcg" version))
1491 (sha256
1492 (base32 "0s57wvvlvshp1gcp9i9d3qcmqhswnxps3i0y7wbb0v8i1a3p46m4"))))
1493 (build-system asdf-build-system/sbcl)
1494 (native-inputs
1495 `(("1am" ,sbcl-1am)))
1496 (home-page "https://github.com/sjl/cl-pcg")
1497 (synopsis "Permuted congruential generators in Common Lisp")
1498 (description
1499 "This is a bare-bones Permuted Congruential Generator implementation in
1500 pure Common Lisp.")
1501 (license license:expat))))
1502
1503 (define-public ecl-cl-pcg
1504 (sbcl-package->ecl-package sbcl-cl-pcg))
1505
1506 (define-public cl-pcg
1507 (sbcl-package->cl-source-package sbcl-cl-pcg))
1508
1509 (define-public sbcl-seedable-rng
1510 (let ((commit "aa1a1564b6e07e2698df37c7a98348c4f762cb15")
1511 (revision "1"))
1512 (package
1513 (name "sbcl-seedable-rng")
1514 (version (git-version "0.0.0" revision commit))
1515 (source
1516 (origin
1517 (method git-fetch)
1518 (uri (git-reference
1519 (url "https://git.mfiano.net/mfiano/seedable-rng")
1520 (commit commit)))
1521 (file-name (git-file-name "seedable-rng" version))
1522 (sha256
1523 (base32 "1ldpsbp3qrfzvknclsxj3sdyms1jf9ad20dvh4w0kw3zgahn2nr5"))))
1524 (build-system asdf-build-system/sbcl)
1525 (inputs
1526 `(("cl-pcg" ,sbcl-cl-pcg)
1527 ("golden-utils" ,sbcl-golden-utils)
1528 ("ironclad" ,sbcl-ironclad)))
1529 (home-page "https://git.mfiano.net/mfiano/seedable-rng")
1530 (synopsis "Common Lisp random number generator")
1531 (description
1532 "SEEDABLE-RNG provides a convenient means of generating random numbers
1533 that are seedable with deterministic results across hardware and Common Lisp
1534 implementations.")
1535 (license license:expat))))
1536
1537 (define-public ecl-seedable-rng
1538 (sbcl-package->ecl-package sbcl-seedable-rng))
1539
1540 (define-public cl-seedable-rng
1541 (sbcl-package->cl-source-package sbcl-seedable-rng))
1542
1543 (define-public sbcl-jpl-queues
1544 (package
1545 (name "sbcl-jpl-queues")
1546 (version "0.1")
1547 (source
1548 (origin
1549 (method url-fetch)
1550 (uri (string-append
1551 "http://www.thoughtcrime.us/software/jpl-queues/jpl-queues-"
1552 version
1553 ".tar.gz"))
1554 (sha256
1555 (base32
1556 "1wvvv7j117h9a42qaj1g4fh4mji28xqs7s60rn6d11gk9jl76h96"))))
1557 (build-system asdf-build-system/sbcl)
1558 (inputs
1559 `(("jpl-util" ,sbcl-jpl-util)
1560 ("bordeaux-threads" ,sbcl-bordeaux-threads)))
1561 (arguments
1562 ;; Tests seem to be broken.
1563 `(#:tests? #f))
1564 (synopsis "Common Lisp library implementing a few different kinds of queues")
1565 (description
1566 "A Common Lisp library implementing a few different kinds of queues:
1567
1568 @itemize
1569 @item Bounded and unbounded FIFO queues.
1570 @item Lossy bounded FIFO queues that drop elements when full.
1571 @item Unbounded random-order queues that use less memory than unbounded FIFO queues.
1572 @end itemize
1573
1574 Additionally, a synchronization wrapper is provided to make any queue
1575 conforming to the @command{jpl-queues} API thread-safe for lightweight
1576 multithreading applications. (See Calispel for a more sophisticated CL
1577 multithreaded message-passing library with timeouts and alternation among
1578 several blockable channels.)")
1579 (home-page "https://www.thoughtcrime.us/software/jpl-queues/")
1580 (license license:isc)))
1581
1582 (define-public cl-jpl-queues
1583 (sbcl-package->cl-source-package sbcl-jpl-queues))
1584
1585 (define-public ecl-jpl-queues
1586 (sbcl-package->ecl-package sbcl-jpl-queues))
1587
1588 (define-public sbcl-calispel
1589 (let ((commit "e9f2f9c1af97f4d7bb4c8ac25fb2a8f3e8fada7a"))
1590 (package
1591 (name "sbcl-calispel")
1592 (version (git-version "0.1" "1" commit))
1593 (source
1594 (origin
1595 (method git-fetch)
1596 (uri (git-reference
1597 ;; This fork replaces the dependency on the obsolete
1598 ;; eager-future with eager-future2.
1599 (url "https://github.com/hawkir/calispel")
1600 (commit commit)))
1601 (file-name (git-file-name name version))
1602 (sha256
1603 (base32
1604 "08bmf3pi7n5hadpmqqkg65cxcj6kbvm997wcs1f53ml1nb79d9z8"))))
1605 (build-system asdf-build-system/sbcl)
1606 (inputs
1607 `(("jpl-queues" ,sbcl-jpl-queues)
1608 ("bordeaux-threads" ,sbcl-bordeaux-threads)))
1609 (native-inputs
1610 `(("eager-future2" ,sbcl-eager-future2)))
1611 (synopsis "Thread-safe message-passing channels in Common Lisp")
1612 (description
1613 "Calispel is a Common Lisp library for thread-safe message-passing
1614 channels, in the style of the occam programming language, also known as
1615 communicating sequential processes (CSP). See
1616 @url{https://en.wikipedia.org/wiki/Communicating_sequential_processes}.
1617
1618 Calispel channels let one thread communicate with another, facilitating
1619 unidirectional communication of any Lisp object. Channels may be unbuffered,
1620 where a sender waits for a receiver (or vice versa) before either operation can
1621 continue, or channels may be buffered with flexible policy options.
1622
1623 Because sending and receiving on a channel may block, either operation can time
1624 out after a specified amount of time.
1625
1626 A syntax for alternation is provided (like @code{ALT} in occam, or Unix
1627 @code{select()}): given a sequence of operations, any or all of which may
1628 block, alternation selects the first operation that doesn't block and executes
1629 associated code. Alternation can also time out, executing an \"otherwise\"
1630 clause if no operation becomes available within a set amount of time.
1631
1632 Calispel is a message-passing library, and as such leaves the role of
1633 threading abstractions and utilities left to be filled by complementary
1634 libraries such as Bordeaux-Threads and Eager Future.")
1635 (home-page "https://www.thoughtcrime.us/software/jpl-queues/")
1636 (license license:isc))))
1637
1638 (define-public cl-calispel
1639 (sbcl-package->cl-source-package sbcl-calispel))
1640
1641 (define-public ecl-calispel
1642 (sbcl-package->ecl-package sbcl-calispel))
1643
1644 (define-public sbcl-eos
1645 (let ((commit "b4413bccc4d142cbe1bf49516c3a0a22c9d99243")
1646 (revision "2"))
1647 (package
1648 (name "sbcl-eos")
1649 (version (git-version "0.0.0" revision commit))
1650 (source
1651 (origin
1652 (method git-fetch)
1653 (uri (git-reference
1654 (url "https://github.com/adlai/Eos")
1655 (commit commit)))
1656 (sha256
1657 (base32 "1afllvmlnx97yzz404gycl3pa3kwx427k3hrbf37rpmjlv47knhk"))
1658 (file-name (git-file-name "eos" version))))
1659 (build-system asdf-build-system/sbcl)
1660 (synopsis "Unit Testing for Common Lisp")
1661 (description
1662 "Eos was a unit testing library for Common Lisp.
1663 It began as a fork of FiveAM; however, FiveAM development has continued, while
1664 that of Eos has not. Thus, Eos is now deprecated in favor of FiveAM.")
1665 (home-page "https://github.com/adlai/Eos")
1666 (license license:expat))))
1667
1668 (define-public cl-eos
1669 (sbcl-package->cl-source-package sbcl-eos))
1670
1671 (define-public ecl-eos
1672 (sbcl-package->ecl-package sbcl-eos))
1673
1674 (define-public sbcl-esrap
1675 (let ((commit "133be8b05c2aae48696fe5b739eea2fa573fa48d"))
1676 (package
1677 (name "sbcl-esrap")
1678 (version (git-version "0.0.0" "1" commit))
1679 (source
1680 (origin
1681 (method git-fetch)
1682 (uri (git-reference
1683 (url "https://github.com/nikodemus/esrap")
1684 (commit commit)))
1685 (sha256
1686 (base32
1687 "02d5clihsdryhf7pix8c5di2571fdsffh75d40fkzhws90r5mksl"))
1688 (file-name (git-file-name "esrap" version))))
1689 (build-system asdf-build-system/sbcl)
1690 (native-inputs
1691 `(("eos" ,sbcl-eos))) ;For testing only.
1692 (inputs
1693 `(("alexandria" ,sbcl-alexandria)))
1694 (synopsis "Common Lisp packrat parser")
1695 (description
1696 "A packrat parser for Common Lisp.
1697 In addition to regular Packrat / Parsing Grammar / TDPL features ESRAP supports:
1698
1699 @itemize
1700 @item dynamic redefinition of nonterminals
1701 @item inline grammars
1702 @item semantic predicates
1703 @item introspective facilities (describing grammars, tracing, setting breaks)
1704 @end itemize\n")
1705 (home-page "https://nikodemus.github.io/esrap/")
1706 (license license:expat))))
1707
1708 (define-public cl-esrap
1709 (sbcl-package->cl-source-package sbcl-esrap))
1710
1711 (define-public ecl-esrap
1712 (sbcl-package->ecl-package sbcl-esrap))
1713
1714 (define-public sbcl-split-sequence
1715 (package
1716 (name "sbcl-split-sequence")
1717 (version "2.0.0")
1718 (source
1719 (origin
1720 (method git-fetch)
1721 (uri (git-reference
1722 (url "https://github.com/sharplispers/split-sequence")
1723 (commit (string-append "v" version))))
1724 (sha256
1725 (base32
1726 "0jcpnx21hkfwqj5fvp7kc6pn1qcz9hk7g2s5x8h0349x1j2irln0"))
1727 (file-name (git-file-name "split-sequence" version))))
1728 (build-system asdf-build-system/sbcl)
1729 (native-inputs
1730 `(("fiveam" ,sbcl-fiveam)))
1731 (synopsis "Member of the Common Lisp Utilities family of programs")
1732 (description
1733 "Splits sequence into a list of subsequences delimited by objects
1734 satisfying the test.")
1735 (home-page "https://cliki.net/split-sequence")
1736 (license license:expat)))
1737
1738 (define-public cl-split-sequence
1739 (sbcl-package->cl-source-package sbcl-split-sequence))
1740
1741 (define-public ecl-split-sequence
1742 (sbcl-package->ecl-package sbcl-split-sequence))
1743
1744 (define-public sbcl-html-encode
1745 (package
1746 (name "sbcl-html-encode")
1747 (version "1.2")
1748 (source
1749 (origin
1750 (method url-fetch)
1751 (uri (string-append
1752 "http://beta.quicklisp.org/archive/html-encode/2010-10-06/html-encode-"
1753 version ".tgz"))
1754 (sha256
1755 (base32
1756 "06mf8wn95yf5swhmzk4vp0xr4ylfl33dgfknkabbkd8n6jns8gcf"))
1757 (file-name (string-append "colorize" version "-checkout"))))
1758 (build-system asdf-build-system/sbcl)
1759 (synopsis "Common Lisp library for encoding text in various web-savvy encodings")
1760 (description
1761 "A library for encoding text in various web-savvy encodings.")
1762 (home-page "http://quickdocs.org/html-encode/")
1763 (license license:expat)))
1764
1765 (define-public cl-html-encode
1766 (sbcl-package->cl-source-package sbcl-html-encode))
1767
1768 (define-public ecl-html-encode
1769 (sbcl-package->ecl-package sbcl-html-encode))
1770
1771 (define-public sbcl-colorize
1772 (let ((commit "ea676b584e0899cec82f21a9e6871172fe3c0eb5"))
1773 (package
1774 (name "sbcl-colorize")
1775 (version (git-version "0.0.0" "1" commit))
1776 (source
1777 (origin
1778 (method git-fetch)
1779 (uri (git-reference
1780 (url "https://github.com/kingcons/colorize")
1781 (commit commit)))
1782 (sha256
1783 (base32
1784 "1pdg4kiaczmr3ivffhirp7m3lbr1q27rn7dhaay0vwghmi31zcw9"))
1785 (file-name (git-file-name "colorize" version))))
1786 (build-system asdf-build-system/sbcl)
1787 (inputs
1788 `(("alexandria" ,sbcl-alexandria)
1789 ("split-sequence" ,sbcl-split-sequence)
1790 ("html-encode" ,sbcl-html-encode)))
1791 (synopsis "Common Lisp for syntax highlighting")
1792 (description
1793 "@command{colorize} is a Lisp library for syntax highlighting
1794 supporting the following languages: Common Lisp, Emacs Lisp, Scheme, Clojure,
1795 C, C++, Java, Python, Erlang, Haskell, Objective-C, Diff, Webkit.")
1796 (home-page "https://github.com/kingcons/colorize")
1797 ;; TODO: Missing license?
1798 (license license:expat))))
1799
1800 (define-public cl-colorize
1801 (sbcl-package->cl-source-package sbcl-colorize))
1802
1803 (define-public ecl-colorize
1804 (sbcl-package->ecl-package sbcl-colorize))
1805
1806 (define-public sbcl-3bmd
1807 (let ((commit "6fc5759448f6f6df6f6df556e020a289a2643288")
1808 (revision "2"))
1809 (package
1810 (name "sbcl-3bmd")
1811 (version (git-version "0.0.0" revision commit))
1812 (source
1813 (origin
1814 (method git-fetch)
1815 (uri (git-reference
1816 (url "https://github.com/3b/3bmd")
1817 (commit commit)))
1818 (sha256
1819 (base32 "1avmbp8xdjlbqpqk7p3vmj7abiw5p3vb5mrxp4wlvgql4sf6z3p4"))
1820 (file-name (git-file-name "3bmd" version))))
1821 (build-system asdf-build-system/sbcl)
1822 (arguments
1823 ;; FIXME: #41437 - Build fails when package name starts from a digit
1824 `(#:asd-systems
1825 '("3bmd"
1826 "3bmd-ext-definition-lists"
1827 "3bmd-ext-math"
1828 "3bmd-ext-tables"
1829 "3bmd-ext-wiki-links"
1830 "3bmd-youtube"
1831 "3bmd-ext-code-blocks")))
1832 (inputs
1833 `(("alexandria" ,sbcl-alexandria)
1834 ("colorize" ,sbcl-colorize)
1835 ("esrap" ,sbcl-esrap)
1836 ("split-sequence" ,sbcl-split-sequence)))
1837 (home-page "https://github.com/3b/3bmd")
1838 (synopsis "Markdown processor in Command Lisp using esrap parser")
1839 (description
1840 "This is a Common Lisp Markdown to HTML converter, using @command{esrap}
1841 for parsing, and grammar based on @command{peg-markdown}.")
1842 (license license:expat))))
1843
1844 (define-public cl-3bmd
1845 (sbcl-package->cl-source-package sbcl-3bmd))
1846
1847 (define-public ecl-3bmd
1848 (sbcl-package->ecl-package sbcl-3bmd))
1849
1850 (define-public sbcl-cl-fad
1851 (package
1852 (name "sbcl-cl-fad")
1853 (version "0.7.6")
1854 (source
1855 (origin
1856 (method git-fetch)
1857 (uri (git-reference
1858 (url "https://github.com/edicl/cl-fad/")
1859 (commit (string-append "v" version))))
1860 (sha256
1861 (base32
1862 "1gc8i82v6gks7g0lnm54r4prk2mklidv2flm5fvbr0a7rsys0vpa"))
1863 (file-name (string-append "cl-fad" version "-checkout"))))
1864 (build-system asdf-build-system/sbcl)
1865 (inputs
1866 `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
1867 (synopsis "Portable pathname library for Common Lisp")
1868 (description
1869 "CL-FAD (for \"Files and Directories\") is a thin layer atop Common
1870 Lisp's standard pathname functions. It is intended to provide some
1871 unification between current CL implementations on Windows, OS X, Linux, and
1872 Unix. Most of the code was written by Peter Seibel for his book Practical
1873 Common Lisp.")
1874 (home-page "https://edicl.github.io/cl-fad/")
1875 (license license:bsd-2)))
1876
1877 (define-public cl-fad
1878 (sbcl-package->cl-source-package sbcl-cl-fad))
1879
1880 (define-public ecl-cl-fad
1881 (sbcl-package->ecl-package sbcl-cl-fad))
1882
1883 (define-public sbcl-fn
1884 (let ((commit "8d8587d03a7b5e26b306fc90018e385d9e5acc2c")
1885 (revision "1"))
1886 (package
1887 (name "sbcl-fn")
1888 (version (git-version "0.0.0" revision commit))
1889 (source
1890 (origin
1891 (method git-fetch)
1892 (uri (git-reference
1893 (url "https://github.com/cbaggers/fn")
1894 (commit commit)))
1895 (file-name (git-file-name "fn" version))
1896 (sha256
1897 (base32 "0yyp9z6iwx476whz0n1rpjznjyqqhlylhzwpgg5xx92lxmskl752"))))
1898 (build-system asdf-build-system/sbcl)
1899 (inputs
1900 `(("named-readtables" ,sbcl-named-readtables)))
1901 (home-page "https://github.com/cbaggers/fn")
1902 (synopsis "Macros for lambda brevity")
1903 (description
1904 "This is a Common Lisp library providing lambda shorthand macros aiming
1905 to be used in cases where the word @emph{lambda} and the arguments are longer
1906 than the body of the lambda.")
1907 (license license:public-domain))))
1908
1909 (define-public ecl-fn
1910 (sbcl-package->ecl-package sbcl-fn))
1911
1912 (define-public cl-fn
1913 (sbcl-package->cl-source-package sbcl-fn))
1914
1915 (define-public sbcl-rt
1916 (let ((commit "a6a7503a0b47953bc7579c90f02a6dba1f6e4c5a")
1917 (revision "1"))
1918 (package
1919 (name "sbcl-rt")
1920 (version (git-version "1990.12.19" revision commit))
1921 (source
1922 (origin
1923 (method git-fetch)
1924 (uri (git-reference
1925 (url "http://git.kpe.io/rt.git")
1926 (commit commit)))
1927 (file-name (git-file-name name version))
1928 (sha256
1929 (base32 "13si2rrxaagbr0bkvg6sqicxxpyshabx6ad6byc9n2ik5ysna69b"))))
1930 (build-system asdf-build-system/sbcl)
1931 (synopsis "MIT Regression Tester")
1932 (description
1933 "RT provides a framework for writing regression test suites.")
1934 (home-page "https://www.cliki.net/rt")
1935 (license license:expat))))
1936
1937 (define-public cl-rt
1938 (sbcl-package->cl-source-package sbcl-rt))
1939
1940 (define-public ecl-rt
1941 (sbcl-package->ecl-package sbcl-rt))
1942
1943 (define-public sbcl-nibbles
1944 ;; No tagged release since 2018.
1945 (let ((commit "8e6b9b42d9f69000f55e5c45ad974d9e376ffdbd")
1946 (revision "1"))
1947 (package
1948 (name "sbcl-nibbles")
1949 (version (git-version "0.14" revision commit))
1950 (source
1951 (origin
1952 (method git-fetch)
1953 (uri (git-reference
1954 (url "https://github.com/sharplispers/nibbles/")
1955 (commit commit)))
1956 (sha256
1957 (base32 "15qlsm82h36pjgvfnbzdg60l21qxbaii4d049jc5y0dn56y93amb"))
1958 (file-name (git-file-name "nibbles" version))))
1959 (build-system asdf-build-system/sbcl)
1960 (native-inputs
1961 ;; Tests only.
1962 `(("rt" ,sbcl-rt)))
1963 (synopsis
1964 "Common Lisp library for accessing octet-addressed blocks of data")
1965 (description
1966 "When dealing with network protocols and file formats, it's common to
1967 have to read or write 16-, 32-, or 64-bit datatypes in signed or unsigned
1968 flavors. Common Lisp sort of supports this by specifying :element-type for
1969 streams, but that facility is underspecified and there's nothing similar for
1970 read/write from octet vectors. What most people wind up doing is rolling their
1971 own small facility for their particular needs and calling it a day.
1972
1973 This library attempts to be comprehensive and centralize such
1974 facilities. Functions to read 16-, 32-, and 64-bit quantities from octet
1975 vectors in signed or unsigned flavors are provided; these functions are also
1976 SETFable. Since it's sometimes desirable to read/write directly from streams,
1977 functions for doing so are also provided. On some implementations,
1978 reading/writing IEEE singles/doubles (i.e. single-float and double-float) will
1979 also be supported.")
1980 (home-page "https://github.com/sharplispers/nibbles")
1981 (license license:bsd-3))))
1982
1983 (define-public cl-nibbles
1984 (sbcl-package->cl-source-package sbcl-nibbles))
1985
1986 (define-public ecl-nibbles
1987 (sbcl-package->ecl-package sbcl-nibbles))
1988
1989 (define-public sbcl-ironclad
1990 (package
1991 (name "sbcl-ironclad")
1992 (version "0.54")
1993 (source
1994 (origin
1995 (method git-fetch)
1996 (uri (git-reference
1997 (url "https://github.com/sharplispers/ironclad/")
1998 (commit (string-append "v" version))))
1999 (sha256
2000 (base32 "07g0wpvfqq2yk23prs890d4qvbnr3xd6w8ssd88g89xdg483wpvk"))
2001 (file-name (git-file-name name version))))
2002 (build-system asdf-build-system/sbcl)
2003 (native-inputs
2004 ;; Tests only.
2005 `(("rt" ,sbcl-rt)))
2006 (inputs
2007 `(("bordeaux-threads" ,sbcl-bordeaux-threads)
2008 ("flexi-streams" ,sbcl-flexi-streams)))
2009 (synopsis "Cryptographic toolkit written in Common Lisp")
2010 (description
2011 "Ironclad is a cryptography library written entirely in Common Lisp.
2012 It includes support for several popular ciphers, digests, MACs and public key
2013 cryptography algorithms. For several implementations that support Gray
2014 streams, support is included for convenient stream wrappers.")
2015 (home-page "https://github.com/sharplispers/ironclad")
2016 (license license:bsd-3)))
2017
2018 (define-public cl-ironclad
2019 (sbcl-package->cl-source-package sbcl-ironclad))
2020
2021 (define-public ecl-ironclad
2022 (sbcl-package->ecl-package sbcl-ironclad))
2023
2024 (define-public sbcl-named-readtables
2025 (let ((commit "585a28eee8b1b1999279b48cb7e9731187e14b66")
2026 (revision "3"))
2027 (package
2028 (name "sbcl-named-readtables")
2029 (version (git-version "0.9" revision commit))
2030 (source
2031 (origin
2032 (method git-fetch)
2033 (uri (git-reference
2034 (url "https://github.com/melisgl/named-readtables")
2035 (commit commit)))
2036 (sha256
2037 (base32 "072p5djqq9pliw9r20rmpz5r5q5yn6rhbp98vkkp7gfcnp5ppj51"))
2038 (file-name (git-file-name "named-readtables" version))))
2039 (build-system asdf-build-system/sbcl)
2040 (home-page "https://github.com/melisgl/named-readtables/")
2041 (synopsis "Library that creates a namespace for named readtables")
2042 (description
2043 "Named readtables is a library that creates a namespace for named
2044 readtables, which is akin to package namespacing in Common Lisp.")
2045 (license license:bsd-3))))
2046
2047 (define-public cl-named-readtables
2048 (sbcl-package->cl-source-package sbcl-named-readtables))
2049
2050 (define-public ecl-named-readtables
2051 (sbcl-package->ecl-package sbcl-named-readtables))
2052
2053 (define-public sbcl-py-configparser
2054 ;; NOTE: (Sharlatan <2021-01-05 Tue> <19:52:19 UTC+0000>) Project updated last
2055 ;; time 8y ago, it looks like abandoned. VCS of the project:
2056 ;; https://svn.common-lisp.net/py-configparser/trunk
2057 (package
2058 (name "sbcl-py-configparser")
2059 (version "1.0.3")
2060 (source
2061 (origin
2062 (method url-fetch)
2063 (uri (string-append
2064 "https://common-lisp.net/project/py-configparser/releases/"
2065 "py-configparser-" version ".tar.gz"))
2066 (sha256
2067 (base32 "0i4rqz5cv7d7c2w81x5lwy05s6fbi3zikf4k5kpi3bkx3cabwdxj"))))
2068 (build-system asdf-build-system/sbcl)
2069 (inputs
2070 `(("parse-number" ,sbcl-parse-number)))
2071 (home-page "http://common-lisp.net/project/py-configparser/")
2072 (synopsis "ConfigParser Python module functionality for Common Lisp")
2073 (description "The py-configparser package implements the ConfigParser
2074 Python module functionality in Common Lisp. In short, it implements reading
2075 and writing of .INI-file style configuration files with sections containing
2076 key/value pairs of configuration options. In line with the functionalities in
2077 the python module, does this package implement basic interpolation of option
2078 values in other options.")
2079 (license license:expat)))
2080
2081 (define-public cl-py-configparser
2082 (sbcl-package->cl-source-package sbcl-py-configparser))
2083
2084 (define-public ecl-py-configparser
2085 (sbcl-package->ecl-package sbcl-py-configparser))
2086
2087 (define-public sbcl-pythonic-string-reader
2088 (let ((commit "47a70ba1e32362e03dad6ef8e6f36180b560f86a"))
2089 (package
2090 (name "sbcl-pythonic-string-reader")
2091 (version (git-version "0.0.0" "1" commit))
2092 (source
2093 (origin
2094 (method git-fetch)
2095 (uri (git-reference
2096 (url "https://github.com/smithzvk/pythonic-string-reader/")
2097 (commit commit)))
2098 (sha256
2099 (base32 "1b5iryqw8xsh36swckmz8rrngmc39k92si33fgy5pml3n9l5rq3j"))
2100 (file-name (git-file-name "pythonic-string-reader" version))))
2101 (build-system asdf-build-system/sbcl)
2102 (inputs
2103 `(("named-readtables" ,sbcl-named-readtables)))
2104 (home-page "https://github.com/smithzvk/pythonic-string-reader")
2105 (synopsis "Read table modification inspired by Python's three quote strings")
2106 (description "This piece of code sets up some reader macros that make it
2107 simpler to input string literals which contain backslashes and double quotes
2108 This is very useful for writing complicated docstrings and, as it turns out,
2109 writing code that contains string literals that contain code themselves.")
2110 (license license:bsd-3))))
2111
2112 (define-public cl-pythonic-string-reader
2113 (sbcl-package->cl-source-package sbcl-pythonic-string-reader))
2114
2115 (define-public ecl-pythonic-string-reader
2116 (sbcl-package->ecl-package sbcl-pythonic-string-reader))
2117
2118 (define-public sbcl-slime-swank
2119 (package
2120 (name "sbcl-slime-swank")
2121 (version "2.26")
2122 (source
2123 (origin
2124 (file-name (git-file-name "slime-swank" version))
2125 (method git-fetch)
2126 (uri (git-reference
2127 (url "https://github.com/slime/slime/")
2128 (commit (string-append "v" version))))
2129 (sha256
2130 (base32
2131 "0mxb1wnw19v0s72w2wkz5afdlzvpy5nn7pr4vav403qybac0sw5c"))))
2132 (build-system asdf-build-system/sbcl)
2133 (arguments
2134 '(#:asd-systems '("swank")))
2135 (home-page "https://github.com/slime/slime")
2136 (synopsis "Common Lisp Swank server")
2137 (description
2138 "This is only useful if you want to start a Swank server in a Lisp
2139 processes that doesn't run under Emacs. Lisp processes created by
2140 @command{M-x slime} automatically start the server.")
2141 (license (list license:gpl2+ license:public-domain))))
2142
2143 (define-public cl-slime-swank
2144 (sbcl-package->cl-source-package sbcl-slime-swank))
2145
2146 (define-public ecl-slime-swank
2147 (sbcl-package->ecl-package sbcl-slime-swank))
2148
2149 (define-public sbcl-mgl-pax
2150 (let ((commit "4ada6eb26364e71addb169ce58e4ba83bc7a8eaa")
2151 (revision "2"))
2152 (package
2153 (name "sbcl-mgl-pax")
2154 (version (git-version "0.0.3" revision commit))
2155 (source
2156 (origin
2157 (method git-fetch)
2158 (uri (git-reference
2159 (url "https://github.com/melisgl/mgl-pax")
2160 (commit commit)))
2161 (sha256
2162 (base32 "1s38crgvmd9hgqwsscqpj6m6c10a074zjgg8k5sl15yih1wkpssm"))
2163 (file-name (git-file-name "mgl-pax" version))))
2164 (build-system asdf-build-system/sbcl)
2165 (inputs
2166 `(("3bmd" ,sbcl-3bmd)
2167 ("babel" ,sbcl-babel)
2168 ("cl-fad" ,sbcl-cl-fad)
2169 ("ironclad" ,sbcl-ironclad)
2170 ("named-readtables" ,sbcl-named-readtables)
2171 ("pythonic-string-reader" ,sbcl-pythonic-string-reader)
2172 ("swank" ,sbcl-slime-swank)))
2173 (synopsis "Exploratory programming environment and documentation generator")
2174 (description
2175 "PAX provides an extremely poor man's Explorable Programming
2176 environment. Narrative primarily lives in so called sections that mix markdown
2177 docstrings with references to functions, variables, etc, all of which should
2178 probably have their own docstrings.
2179
2180 The primary focus is on making code easily explorable by using SLIME's
2181 @command{M-.} (@command{slime-edit-definition}). See how to enable some
2182 fanciness in Emacs Integration. Generating documentation from sections and all
2183 the referenced items in Markdown or HTML format is also implemented.
2184
2185 With the simplistic tools provided, one may accomplish similar effects as with
2186 Literate Programming, but documentation is generated from code, not vice versa
2187 and there is no support for chunking yet. Code is first, code must look
2188 pretty, documentation is code.")
2189 (home-page "http://quotenil.com/")
2190 (license license:expat))))
2191
2192 (define-public cl-mgl-pax
2193 (sbcl-package->cl-source-package sbcl-mgl-pax))
2194
2195 (define-public ecl-mgl-pax
2196 (sbcl-package->ecl-package sbcl-mgl-pax))
2197
2198 (define-public sbcl-mssql
2199 (let ((commit "045602a19a32254108f2b75871049293f49731eb")
2200 (revision "1"))
2201 (package
2202 (name "sbcl-mssql")
2203 (version (git-version "0.0.3" revision commit))
2204 (source
2205 (origin
2206 (method git-fetch)
2207 (uri (git-reference
2208 (url "https://github.com/archimag/cl-mssql")
2209 (commit commit)))
2210 (file-name (git-file-name "cl-mssql" version))
2211 (sha256
2212 (base32 "09i50adppgc1ybm3ka9vbindhwa2x29f9n3n0jkrryymdhb8zknm"))))
2213 (build-system asdf-build-system/sbcl)
2214 (inputs
2215 `(("cffi" ,sbcl-cffi)
2216 ("freetds" ,freetds)
2217 ("garbage-pools" ,sbcl-garbage-pools)
2218 ("iterate" ,sbcl-iterate)
2219 ("parse-number" ,sbcl-parse-number)))
2220 (arguments
2221 `(#:phases
2222 (modify-phases %standard-phases
2223 (add-after 'unpack 'fix-paths
2224 (lambda* (#:key inputs #:allow-other-keys)
2225 (substitute* "src/mssql.lisp"
2226 (("libsybdb" all)
2227 (string-append (assoc-ref inputs "freetds") "/lib/" all)))
2228 #t)))))
2229 (home-page "https://github.com/archimag/cl-mssql")
2230 (synopsis "Common Lisp library to interact with MS SQL Server databases")
2231 (description
2232 "@code{cl-mssql} provides an interface to connect to Microsoft SQL
2233 server. It uses the @code{libsybdb} foreign library provided by the FreeTDS
2234 project.")
2235 (license license:llgpl))))
2236
2237 (define-public ecl-mssql
2238 (sbcl-package->ecl-package sbcl-mssql))
2239
2240 (define-public cl-mssql
2241 (sbcl-package->cl-source-package sbcl-mssql))
2242
2243 (define-public sbcl-lisp-unit
2244 (let ((commit "89653a232626b67400bf9a941f9b367da38d3815"))
2245 (package
2246 (name "sbcl-lisp-unit")
2247 (version (git-version "0.0.0" "1" commit))
2248 (source
2249 (origin
2250 (method git-fetch)
2251 (uri (git-reference
2252 (url "https://github.com/OdonataResearchLLC/lisp-unit")
2253 (commit commit)))
2254 (sha256
2255 (base32
2256 "0p6gdmgr7p383nvd66c9y9fp2bjk4jx1lpa5p09g43hr9y9pp9ry"))
2257 (file-name (git-file-name "lisp-unit" version))))
2258 (build-system asdf-build-system/sbcl)
2259 (synopsis "Common Lisp Test framework inspired by JUnit to be simple of use")
2260 (description
2261 "@command{lisp-unit} is a Common Lisp library that supports unit
2262 testing. It is an extension of the library written by Chris Riesbeck.")
2263 (home-page "https://github.com/OdonataResearchLLC/lisp-unit")
2264 (license license:expat))))
2265
2266 (define-public cl-lisp-unit
2267 (sbcl-package->cl-source-package sbcl-lisp-unit))
2268
2269 (define-public ecl-lisp-unit
2270 (sbcl-package->ecl-package sbcl-lisp-unit))
2271
2272 (define-public sbcl-anaphora
2273 (package
2274 (name "sbcl-anaphora")
2275 (version "0.9.6")
2276 (source
2277 (origin
2278 (method git-fetch)
2279 (uri (git-reference
2280 (url "https://github.com/tokenrove/anaphora")
2281 (commit version)))
2282 (sha256
2283 (base32
2284 "19wfrk3asimznkli0x2rfy637hwpdgqyvwj3vhq9x7vjvyf5vv6x"))
2285 (file-name (git-file-name "anaphora" version))))
2286 (build-system asdf-build-system/sbcl)
2287 (native-inputs
2288 `(("rt" ,sbcl-rt)))
2289 (synopsis "The anaphoric macro collection from Hell")
2290 (description
2291 "Anaphora is the anaphoric macro collection from Hell: it includes many
2292 new fiends in addition to old friends like @command{aif} and
2293 @command{awhen}.")
2294 (home-page "https://github.com/tokenrove/anaphora")
2295 (license license:public-domain)))
2296
2297 (define-public cl-anaphora
2298 (sbcl-package->cl-source-package sbcl-anaphora))
2299
2300 (define-public ecl-anaphora
2301 (sbcl-package->ecl-package sbcl-anaphora))
2302
2303 (define-public sbcl-lift
2304 (let ((commit "2594160d6ca3a77d8750110dfa63214256aab852")
2305 (revision "2"))
2306 (package
2307 (name "sbcl-lift")
2308 (version (git-version "1.7.1" revision commit))
2309 (source
2310 (origin
2311 (method git-fetch)
2312 (uri (git-reference
2313 (url "https://github.com/gwkkwg/lift")
2314 (commit commit)))
2315 (sha256
2316 (base32 "01xvz9sl5l5lai4h9dabmcjnm659wf5zllaxqbs55lffskp6jwq3"))
2317 (file-name (git-file-name "lift" version))
2318 (modules '((guix build utils)))
2319 (snippet
2320 ;; Don't keep the bundled website
2321 `(begin
2322 (delete-file-recursively "website")
2323 #t))))
2324 (build-system asdf-build-system/sbcl)
2325 (arguments
2326 ;; The tests require a debugger, but we run with the debugger disabled.
2327 '(#:tests? #f))
2328 (synopsis "LIsp Framework for Testing")
2329 (description
2330 "The LIsp Framework for Testing (LIFT) is a unit and system test tool for LISP.
2331 Though inspired by SUnit and JUnit, it's built with Lisp in mind. In LIFT,
2332 testcases are organized into hierarchical testsuites each of which can have
2333 its own fixture. When run, a testcase can succeed, fail, or error. LIFT
2334 supports randomized testing, benchmarking, profiling, and reporting.")
2335 (home-page "https://github.com/gwkkwg/lift")
2336 (license license:expat))))
2337
2338 (define-public cl-lift
2339 (sbcl-package->cl-source-package sbcl-lift))
2340
2341 (define-public ecl-lift
2342 (sbcl-package->ecl-package sbcl-lift))
2343
2344 (define-public sbcl-let-plus
2345 (let ((commit "5f14af61d501ecead02ec6b5a5c810efc0c9fdbb"))
2346 (package
2347 (name "sbcl-let-plus")
2348 (version (git-version "0.0.0" "1" commit))
2349 (source
2350 (origin
2351 (method git-fetch)
2352 (uri (git-reference
2353 (url "https://github.com/sharplispers/let-plus")
2354 (commit commit)))
2355 (sha256
2356 (base32
2357 "0i050ca2iys9f5mb7dgqgqdxfnc3b0rnjdwv95sqd490vkiwrsaj"))
2358 (file-name (git-file-name "let-plus" version))))
2359 (build-system asdf-build-system/sbcl)
2360 (inputs
2361 `(("alexandria" ,sbcl-alexandria)
2362 ("anaphora" ,sbcl-anaphora)))
2363 (native-inputs
2364 `(("lift" ,sbcl-lift)))
2365 (synopsis "Destructuring extension of let*")
2366 (description
2367 "This library implements the let+ macro, which is a dectructuring
2368 extension of let*. It features:
2369
2370 @itemize
2371 @item Clean, consistent syntax and small implementation (less than 300 LOC,
2372 not counting tests)
2373 @item Placeholder macros allow editor hints and syntax highlighting
2374 @item @command{&ign} for ignored values (in forms where that makes sense)
2375 @item Very easy to extend
2376 @end itemize\n")
2377 (home-page "https://github.com/sharplispers/let-plus")
2378 (license license:boost1.0))))
2379
2380 (define-public cl-let-plus
2381 (sbcl-package->cl-source-package sbcl-let-plus))
2382
2383 (define-public ecl-let-plus
2384 (sbcl-package->ecl-package sbcl-let-plus))
2385
2386 (define-public sbcl-cl-colors
2387 (let ((commit "827410584553f5c717eec6182343b7605f707f75"))
2388 (package
2389 (name "sbcl-cl-colors")
2390 (version (git-version "0.0.0" "1" commit))
2391 (source
2392 (origin
2393 (method git-fetch)
2394 (uri (git-reference
2395 (url "https://github.com/tpapp/cl-colors")
2396 (commit commit)))
2397 (sha256
2398 (base32
2399 "0l446lday4hybsm9bq3jli97fvv8jb1d33abg79vbylpwjmf3y9a"))
2400 (file-name (git-file-name "cl-colors" version))))
2401 (build-system asdf-build-system/sbcl)
2402 (inputs
2403 `(("alexandria" ,sbcl-alexandria)
2404 ("let-plus" ,sbcl-let-plus)))
2405 (synopsis "Simple color library for Common Lisp")
2406 (description
2407 "This is a very simple color library for Common Lisp, providing
2408
2409 @itemize
2410 @item Types for representing colors in HSV and RGB spaces.
2411 @item Simple conversion functions between the above types (and also
2412 hexadecimal representation for RGB).
2413 @item Some predefined colors (currently X11 color names – of course the
2414 library does not depend on X11).Because color in your terminal is nice.
2415 @end itemize
2416
2417 This library is no longer supported by its author.")
2418 (home-page "https://github.com/tpapp/cl-colors")
2419 (license license:boost1.0))))
2420
2421 (define-public cl-colors
2422 (sbcl-package->cl-source-package sbcl-cl-colors))
2423
2424 (define-public ecl-cl-colors
2425 (sbcl-package->ecl-package sbcl-cl-colors))
2426
2427 (define-public sbcl-cl-ansi-text
2428 (let ((commit "53badf7878f27f22f2d4a2a43e6df458e43acbe9"))
2429 (package
2430 (name "sbcl-cl-ansi-text")
2431 (version (git-version "1.0.0" "1" commit))
2432 (source
2433 (origin
2434 (method git-fetch)
2435 (uri (git-reference
2436 (url "https://github.com/pnathan/cl-ansi-text")
2437 (commit commit)))
2438 (sha256
2439 (base32
2440 "11i27n0dbz5lmygiw65zzr8lx0rac6b6yysqranphn31wls6ja3v"))
2441 (file-name (git-file-name "cl-ansi-text" version))))
2442 (build-system asdf-build-system/sbcl)
2443 (inputs
2444 `(("alexandria" ,sbcl-alexandria)
2445 ("cl-colors" ,sbcl-cl-colors)))
2446 (native-inputs
2447 `(("fiveam" ,sbcl-fiveam)))
2448 (synopsis "ANSI terminal color implementation for Common Lisp")
2449 (description
2450 "@command{cl-ansi-text} provides utilities which enable printing to an
2451 ANSI terminal with colored text. It provides the macro @command{with-color}
2452 which causes everything printed in the body to be displayed with the provided
2453 color. It further provides functions which will print the argument with the
2454 named color.")
2455 (home-page "https://github.com/pnathan/cl-ansi-text")
2456 (license license:llgpl))))
2457
2458 (define-public cl-ansi-text
2459 (sbcl-package->cl-source-package sbcl-cl-ansi-text))
2460
2461 (define-public ecl-cl-ansi-text
2462 (sbcl-package->ecl-package sbcl-cl-ansi-text))
2463
2464 (define-public sbcl-prove
2465 (let ((commit "4f9122bd393e63c5c70c1fba23070622317cfaa0"))
2466 (package
2467 (name "sbcl-prove")
2468 (version (git-version "1.0.0" "1" commit))
2469 (source
2470 (origin
2471 (method git-fetch)
2472 (uri (git-reference
2473 (url "https://github.com/fukamachi/prove")
2474 (commit commit)))
2475 (sha256
2476 (base32
2477 "07sbfw459z8bbjvx1qlmfa8qk2mvbjnnzi2mi0x72blaj8bkl4vc"))
2478 (file-name (git-file-name "prove" version))))
2479 (build-system asdf-build-system/sbcl)
2480 (inputs
2481 `(("alexandria" ,sbcl-alexandria)
2482 ("cl-ppcre" ,sbcl-cl-ppcre)
2483 ("cl-ansi-text" ,sbcl-cl-ansi-text)))
2484 (synopsis "Yet another unit testing framework for Common Lisp")
2485 (description
2486 "This project was originally called @command{cl-test-more}.
2487 @command{prove} is yet another unit testing framework for Common Lisp. The
2488 advantages of @command{prove} are:
2489
2490 @itemize
2491 @item Various simple functions for testing and informative error messages
2492 @item ASDF integration
2493 @item Extensible test reporters
2494 @item Colorizes the report if it's available (note for SLIME)
2495 @item Reports test durations
2496 @end itemize\n")
2497 (home-page "https://github.com/fukamachi/prove")
2498 (license license:expat))))
2499
2500 (define-public cl-prove
2501 (sbcl-package->cl-source-package sbcl-prove))
2502
2503 (define-public ecl-prove
2504 (sbcl-package->ecl-package sbcl-prove))
2505
2506 (define-public sbcl-proc-parse
2507 (let ((commit "ac3636834d561bdc2686c956dbd82494537285fd"))
2508 (package
2509 (name "sbcl-proc-parse")
2510 (version (git-version "0.0.0" "1" commit))
2511 (source
2512 (origin
2513 (method git-fetch)
2514 (uri (git-reference
2515 (url "https://github.com/fukamachi/proc-parse")
2516 (commit commit)))
2517 (sha256
2518 (base32
2519 "06rnl0h4cx6xv2wj3jczmmcxqn2703inmmvg1s4npbghmijsybfh"))
2520 (file-name (git-file-name "proc-parse" version))))
2521 (build-system asdf-build-system/sbcl)
2522 (inputs
2523 `(("alexandria" ,sbcl-alexandria)
2524 ("babel" ,sbcl-babel)))
2525 (native-inputs
2526 `(("prove" ,sbcl-prove)))
2527 (arguments
2528 ;; TODO: Tests don't find "proc-parse-test", why?
2529 `(#:tests? #f))
2530 (synopsis "Procedural vector parser")
2531 (description
2532 "This is a string/octets parser library for Common Lisp with speed and
2533 readability in mind. Unlike other libraries, the code is not a
2534 pattern-matching-like, but a char-by-char procedural parser.")
2535 (home-page "https://github.com/fukamachi/proc-parse")
2536 (license license:bsd-2))))
2537
2538 (define-public cl-proc-parse
2539 (sbcl-package->cl-source-package sbcl-proc-parse))
2540
2541 (define-public ecl-proc-parse
2542 (sbcl-package->ecl-package sbcl-proc-parse))
2543
2544 (define-public sbcl-parse-float
2545 (let ((commit "3074765101e41222b6b624a66aaf1e6416379f9c")
2546 (revision "2"))
2547 (package
2548 (name "sbcl-parse-float")
2549 (version (git-version "0.0.0" revision commit))
2550 (source
2551 (origin
2552 (method git-fetch)
2553 (uri (git-reference
2554 (url "https://github.com/soemraws/parse-float")
2555 (commit commit)))
2556 (sha256
2557 (base32 "0jd2spawc3v8vzqf8ky4cngl45jm65fhkrdf20mf6dcbn3mzpkmr"))
2558 (file-name (git-file-name "proc-parse" version))))
2559 (build-system asdf-build-system/sbcl)
2560 (arguments
2561 ;; FIXME: https://github.com/soemraws/parse-float/issues/12
2562 `(#:asd-systems '("parse-float" "parse-float-tests")))
2563 (native-inputs
2564 `(("lisp-unit" ,sbcl-lisp-unit)))
2565 (inputs
2566 `(("alexandria" ,sbcl-alexandria)))
2567 (home-page "https://github.com/soemraws/parse-float")
2568 (synopsis "Parse a floating point value from a string in Common Lisp")
2569 (description
2570 "This package exports the following function to parse floating-point
2571 values from a string in Common Lisp.")
2572 (license license:public-domain))))
2573
2574 (define-public cl-parse-float
2575 (sbcl-package->cl-source-package sbcl-parse-float))
2576
2577 (define-public ecl-parse-float
2578 (sbcl-package->ecl-package sbcl-parse-float))
2579
2580 (define-public sbcl-cl-string-match
2581 (let ((revision "1")
2582 (changeset "5048480a61243e6f1b02884012c8f25cdbee6d97"))
2583 (package
2584 (name "sbcl-cl-string-match")
2585 (version (git-version "0" revision changeset))
2586 (source
2587 (origin
2588 (method hg-fetch)
2589 (uri (hg-reference
2590 (url "https://bitbucket.org/vityok/cl-string-match/")
2591 (changeset changeset)))
2592 (sha256
2593 (base32
2594 "01wn5qx562w43ssy92xlfgv79w7p0nv0wbl76mpmba131n9ziq2y"))
2595 (file-name (git-file-name "cl-string-match" version))))
2596 (build-system asdf-build-system/sbcl)
2597 (inputs
2598 `(("alexandria" ,sbcl-alexandria)
2599 ("babel" ,sbcl-babel)
2600 ("iterate" ,sbcl-iterate)
2601 ("jpl-queues" ,sbcl-jpl-queues)
2602 ("jpl-util" ,sbcl-jpl-util)
2603 ("mgl-pax" ,sbcl-mgl-pax)
2604 ("parse-float" ,sbcl-parse-float)
2605 ("proc-parse" ,sbcl-proc-parse)
2606 ("yacc" ,sbcl-cl-yacc)))
2607 ;; TODO: Tests are not evaluated properly.
2608 (native-inputs
2609 ;; For testing:
2610 `(("lisp-unit" ,sbcl-lisp-unit)))
2611 (arguments
2612 `(#:tests? #f))
2613 (synopsis "Set of utilities to manipulate strings in Common Lisp")
2614 (description
2615 "@command{cl-strings} is a small, portable, dependency-free set of
2616 utilities that make it even easier to manipulate text in Common Lisp. It has
2617 100% test coverage and works at least on sbcl, ecl, ccl, abcl and clisp.")
2618 (home-page "https://bitbucket.org/vityok/cl-string-match/")
2619 (license license:bsd-3))))
2620
2621 (define-public cl-string-match
2622 (sbcl-package->cl-source-package sbcl-cl-string-match))
2623
2624 (define-public ecl-cl-string-match
2625 (sbcl-package->ecl-package sbcl-cl-string-match))
2626
2627 (define-public sbcl-ptester
2628 (let ((commit "fe69fde54f4bce00ce577feb918796c293fc7253")
2629 (revision "1"))
2630 (package
2631 (name "sbcl-ptester")
2632 (version (git-version "2.1.3" revision commit))
2633 (source
2634 (origin
2635 (method git-fetch)
2636 (uri (git-reference
2637 (url "http://git.kpe.io/ptester.git")
2638 (commit commit)))
2639 (file-name (git-file-name name version))
2640 (sha256
2641 (base32 "1l0lfl7cdnr2qf4zh38hi4llxg22c49zkm639bdkmvlkzwj3ndwf"))))
2642 (build-system asdf-build-system/sbcl)
2643 (home-page "http://quickdocs.org/ptester/")
2644 (synopsis "Portable test harness package")
2645 (description
2646 "@command{ptester} is a portable testing framework based on Franz's
2647 tester module.")
2648 (license license:llgpl))))
2649
2650 (define-public cl-ptester
2651 (sbcl-package->cl-source-package sbcl-ptester))
2652
2653 (define-public ecl-ptester
2654 (sbcl-package->ecl-package sbcl-ptester))
2655
2656 (define-public sbcl-puri
2657 (let ((commit "4bbab89d9ccbb26346899d1f496c97604fec567b")
2658 (revision "2"))
2659 (package
2660 (name "sbcl-puri")
2661 (version (git-version "1.5.7" revision commit))
2662 (source
2663 (origin
2664 (method git-fetch)
2665 (uri (git-reference
2666 (url "http://git.kpe.io/puri.git")
2667 (commit commit)))
2668 (file-name (git-file-name "puri" version))
2669 (sha256
2670 (base32 "0gq2rsr0aihs0z20v4zqvmdl4szq53b52rh97pvnmwrlbn4mapmd"))))
2671 (build-system asdf-build-system/sbcl)
2672 (native-inputs
2673 `(("ptester" ,sbcl-ptester)))
2674 (home-page "http://puri.kpe.io/")
2675 (synopsis "Portable URI Library")
2676 (description
2677 "This is a portable Universal Resource Identifier library for Common
2678 Lisp programs. It parses URI according to the RFC 2396 specification.")
2679 (license license:llgpl))))
2680
2681 (define-public cl-puri
2682 (sbcl-package->cl-source-package sbcl-puri))
2683
2684 (define-public ecl-puri
2685 (sbcl-package->ecl-package sbcl-puri))
2686
2687 (define-public sbcl-qmynd
2688 (let ((commit "7e56daf73f0ed5f49a931c01af75fb874bcf3445")
2689 (revision "1"))
2690 (package
2691 (name "sbcl-qmynd")
2692 (version (git-version "1.0.0" revision commit))
2693 (source
2694 (origin
2695 (method git-fetch)
2696 (uri (git-reference
2697 (url "https://github.com/qitab/qmynd")
2698 (commit commit)))
2699 (file-name (git-file-name name version))
2700 (sha256
2701 (base32
2702 "06gw5wxcpdclb6a5i5k9lbmdlyqsp182czrm9bm1cpklzbj0ihrl"))))
2703 (build-system asdf-build-system/sbcl)
2704 (inputs
2705 `(("asdf-finalizers" ,sbcl-asdf-finalizers)
2706 ("babel" ,sbcl-babel)
2707 ("chipz" ,sbcl-chipz)
2708 ("cl+ssl" ,sbcl-cl+ssl)
2709 ("flexi-streams" ,sbcl-flexi-streams)
2710 ("ironclad" ,sbcl-ironclad)
2711 ("salza2" ,sbcl-salza2)
2712 ("trivial-gray-streams" ,sbcl-trivial-gray-streams)
2713 ("usocket" ,sbcl-usocket)))
2714 (home-page "https://github.com/qitab/qmynd")
2715 (synopsis "QITAB MySQL Native Driver for Common Lisp")
2716 (description "QMyND, the QITAB MySQL Native Driver, is a MySQL client
2717 library that directly talks to a MySQL server in its native network protocol.
2718
2719 It's a part of QITAB umbrella project.")
2720 (license license:expat))))
2721
2722 (define-public ecl-qmynd
2723 (sbcl-package->ecl-package sbcl-qmynd))
2724
2725 (define-public cl-qmynd
2726 (sbcl-package->cl-source-package sbcl-qmynd))
2727
2728 (define-public sbcl-queues
2729 (let ((commit "47d4da65e9ea20953b74aeeab7e89a831b66bc94"))
2730 (package
2731 (name "sbcl-queues")
2732 (version (git-version "0.0.0" "1" commit))
2733 (source
2734 (origin
2735 (method git-fetch)
2736 (uri (git-reference
2737 (url "https://github.com/oconnore/queues")
2738 (commit commit)))
2739 (file-name (git-file-name "queues" version))
2740 (sha256
2741 (base32
2742 "0wdhfnzi4v6d97pggzj2aw55si94w4327br94jrmyvwf351wqjvv"))))
2743 (build-system asdf-build-system/sbcl)
2744 (inputs
2745 `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
2746 (arguments
2747 '(#:asd-systems '("queues"
2748 "queues.simple-queue"
2749 "queues.simple-cqueue"
2750 "queues.priority-queue"
2751 "queues.priority-cqueue")))
2752 (home-page "https://github.com/oconnore/queues")
2753 (synopsis "Common Lisp queue library")
2754 (description
2755 "This is a simple queue library for Common Lisp with features such as
2756 non-consing thread safe queues and fibonacci priority queues.")
2757 (license license:expat))))
2758
2759 (define-public cl-queues
2760 (sbcl-package->cl-source-package sbcl-queues))
2761
2762 (define-public ecl-queues
2763 (sbcl-package->ecl-package sbcl-queues))
2764
2765 (define-public sbcl-glsl-packing
2766 (let ((commit "03628159468a8e5b7f2a1d5e78b77053e136794a")
2767 (revision "1"))
2768 (package
2769 (name "sbcl-glsl-packing")
2770 (version (git-version "0.0.0" revision commit))
2771 (source
2772 (origin
2773 (method git-fetch)
2774 (uri (git-reference
2775 (url "https://github.com/3b/glsl-packing/")
2776 (commit commit)))
2777 (file-name (git-file-name "glsl-packing" version))
2778 (sha256
2779 (base32 "0k2f1771wd9kdrcasldy1r00k5bdgi9fd07in52zmjggc0i7dd80"))))
2780 (build-system asdf-build-system/sbcl)
2781 (inputs
2782 `(("alexandria" ,sbcl-alexandria)))
2783 (home-page "https://github.com/3b/glsl-packing/")
2784 (synopsis "Common Lisp utilities to calculate OpenGL layouts")
2785 (description
2786 "This is a Common Lisp library to calculate std140 or std430 layouts for
2787 a glsl UBO/SSBO.")
2788 (license license:expat))))
2789
2790 (define-public ecl-glsl-packing
2791 (sbcl-package->ecl-package sbcl-glsl-packing))
2792
2793 (define-public cl-glsl-packing
2794 (sbcl-package->cl-source-package sbcl-glsl-packing))
2795
2796 (define-public sbcl-glsl-spec
2797 (let ((commit "f04476f7da89355ae6856b33283c60ba95c6555d")
2798 (revision "1"))
2799 (package
2800 (name "sbcl-glsl-spec")
2801 (version (git-version "0.0.0" revision commit))
2802 (source
2803 (origin
2804 (method git-fetch)
2805 (uri (git-reference
2806 (url "https://github.com/cbaggers/glsl-spec")
2807 (commit commit)))
2808 (file-name (git-file-name "glsl-spec" version))
2809 (sha256
2810 (base32 "01ipspr22fgfj3w8wq2y81lzrjc4vpfiwnr3dqhjlpzzra46am8c"))))
2811 (build-system asdf-build-system/sbcl)
2812 (arguments
2813 `(#:asd-systems '("glsl-spec" "glsl-symbols" "glsl-docs")))
2814 (home-page "https://github.com/cbaggers/glsl-spec")
2815 (synopsis "Common Lisp GLSL specification as a datastructure")
2816 (description
2817 "This package contains the specification of all functions and variables
2818 from GLSL as data.")
2819 (license license:unlicense))))
2820
2821 (define-public ecl-glsl-spec
2822 (sbcl-package->ecl-package sbcl-glsl-spec))
2823
2824 (define-public cl-glsl-spec
2825 (sbcl-package->cl-source-package sbcl-glsl-spec))
2826
2827 (define-public sbcl-varjo
2828 (let ((commit "9e77f30220053155d2ef8870ceba157f75e538d4")
2829 (revision "1"))
2830 (package
2831 (name "sbcl-varjo")
2832 (version (git-version "0.0.0" revision commit))
2833 (source
2834 (origin
2835 (method git-fetch)
2836 (uri (git-reference
2837 (url "https://github.com/cbaggers/varjo")
2838 (commit commit)))
2839 (file-name (git-file-name "varjo" version))
2840 (sha256
2841 (base32 "1p9x1wj576x5d31yvls9r1avkjkyhri7kyxbjfkg9z93a1w18j9z"))))
2842 (build-system asdf-build-system/sbcl)
2843 (native-inputs
2844 `(("fiveam" ,sbcl-fiveam)))
2845 (inputs
2846 `(("alexandria" ,sbcl-alexandria)
2847 ("cl-ppcre" ,sbcl-cl-ppcre)
2848 ("documentation-utils" ,sbcl-documentation-utils)
2849 ("fn" ,sbcl-fn)
2850 ("glsl-spec" ,sbcl-glsl-spec)
2851 ("named-readtables" ,sbcl-named-readtables)
2852 ("parse-float" ,sbcl-parse-float)
2853 ("vas-string-metrics" ,sbcl-vas-string-metrics)))
2854 (home-page "https://github.com/cbaggers/varjo")
2855 (synopsis "Lisp to GLSL Language Translator")
2856 (description
2857 "Varjo is a Lisp to GLSL compiler. Vari is the dialect of lisp Varjo
2858 compiles. It aims to be as close to Common Lisp as possible, but naturally it
2859 is statically typed so there are differences.")
2860 (license license:bsd-2))))
2861
2862 (define-public ecl-varjo
2863 (sbcl-package->ecl-package sbcl-varjo))
2864
2865 (define-public cl-varjo
2866 (sbcl-package->cl-source-package sbcl-varjo))
2867
2868 (define-public sbcl-cffi
2869 (package
2870 (name "sbcl-cffi")
2871 (version "0.23.0")
2872 (source
2873 (origin
2874 (method git-fetch)
2875 (uri (git-reference
2876 (url "https://github.com/cffi/cffi")
2877 (commit (string-append "v" version))))
2878 (file-name (git-file-name "cffi-bootstrap" version))
2879 (sha256
2880 (base32 "03s98imc5niwnpj3hhrafl7dmxq45g74h96sm68976k7ahi3vl5b"))))
2881 (build-system asdf-build-system/sbcl)
2882 (inputs
2883 `(("alexandria" ,sbcl-alexandria)
2884 ("babel" ,sbcl-babel)
2885 ("libffi" ,libffi)
2886 ("trivial-features" ,sbcl-trivial-features)))
2887 (native-inputs
2888 `(("bordeaux-threads" ,sbcl-bordeaux-threads)
2889 ("pkg-config" ,pkg-config)
2890 ("rt" ,sbcl-rt)))
2891 (arguments
2892 '(#:phases
2893 (modify-phases %standard-phases
2894 (add-after 'unpack 'fix-arm-support
2895 (lambda _
2896 ;; This is apparently deprecated since libffi-3.3.
2897 (substitute* "libffi/libffi-types.lisp"
2898 (("\\\(\\\(:unix64.*") ")\n"))
2899 #t))
2900 (add-after 'unpack 'fix-paths
2901 (lambda* (#:key inputs #:allow-other-keys)
2902 (substitute* "libffi/libffi.lisp"
2903 (("libffi.so.7" all) (string-append
2904 (assoc-ref inputs "libffi")
2905 "/lib/" all)))
2906 (substitute* "toolchain/c-toolchain.lisp"
2907 (("\"cc\"") (format #f "~S" (which "gcc"))))))
2908 (add-after 'build 'install-headers
2909 (lambda* (#:key outputs #:allow-other-keys)
2910 (install-file "grovel/common.h"
2911 (string-append
2912 (assoc-ref outputs "out")
2913 "/include/grovel")))))
2914 #:asd-files '("cffi.asd"
2915 "cffi-toolchain.asd"
2916 "cffi-grovel.asd"
2917 "cffi-libffi.asd"
2918 "cffi-uffi-compat.asd")
2919 #:asd-systems '("cffi"
2920 "cffi-libffi"
2921 "cffi-uffi-compat")))
2922 (home-page "https://common-lisp.net/project/cffi/")
2923 (synopsis "Common Foreign Function Interface for Common Lisp")
2924 (description "The Common Foreign Function Interface (CFFI)
2925 purports to be a portable foreign function interface for Common Lisp.
2926 The CFFI library is composed of a Lisp-implementation-specific backend
2927 in the CFFI-SYS package, and a portable frontend in the CFFI
2928 package.")
2929 (license license:expat)))
2930
2931 (define-public cl-cffi
2932 (sbcl-package->cl-source-package sbcl-cffi))
2933
2934 (define-public ecl-cffi
2935 (sbcl-package->ecl-package sbcl-cffi))
2936
2937 (define-public sbcl-cffi-c-ref
2938 (let ((commit "8123cbb6034c5f7921a0766107cfb8c4e8efd5ce")
2939 (revision "0"))
2940 (package
2941 (name "sbcl-cffi-c-ref")
2942 (version (git-version "1.0" revision commit))
2943 (source
2944 (origin
2945 (method git-fetch)
2946 (uri (git-reference
2947 (url "https://github.com/borodust/cffi-c-ref")
2948 (commit commit)))
2949 (sha256
2950 (base32 "1a3pp6xcisabqir3rp1gvvjfdxcvpm8yr35p38nri9azsinmmc7z"))
2951 (file-name (git-file-name "cffi-c-ref" version))))
2952 (build-system asdf-build-system/sbcl)
2953 (inputs
2954 `(("alexandria" ,sbcl-alexandria)
2955 ("cffi" ,sbcl-cffi)))
2956 (synopsis "Streamlined access to foreign memory")
2957 (description
2958 "This Common Lisp library provides macros to access foreign memory.")
2959 (home-page "https://github.com/borodust/cffi-c-ref")
2960 (license license:expat))))
2961
2962 (define-public cl-cffi-c-ref
2963 (sbcl-package->cl-source-package sbcl-cffi-c-ref))
2964
2965 (define-public ecl-cffi-c-ref
2966 (sbcl-package->ecl-package sbcl-cffi-c-ref))
2967
2968 (define-public sbcl-cl-sqlite
2969 (package
2970 (name "sbcl-cl-sqlite")
2971 (version "0.2.1")
2972 (source
2973 (origin
2974 (method git-fetch)
2975 (uri (git-reference
2976 (url "https://github.com/dmitryvk/cl-sqlite")
2977 (commit version)))
2978 (file-name (git-file-name "cl-sqlite" version))
2979 (sha256
2980 (base32
2981 "08iv7b4m0hh7qx2cvq4f510nrgdld0vicnvmqsh9w0fgrcgmyg4k"))))
2982 (build-system asdf-build-system/sbcl)
2983 (inputs
2984 `(("iterate" ,sbcl-iterate)
2985 ("cffi" ,sbcl-cffi)
2986 ("sqlite" ,sqlite)))
2987 (native-inputs
2988 `(("fiveam" ,sbcl-fiveam)
2989 ("bordeaux-threads" ,sbcl-bordeaux-threads)))
2990 (arguments
2991 `(#:asd-systems '("sqlite")
2992 #:phases
2993 (modify-phases %standard-phases
2994 (add-after 'unpack 'fix-paths
2995 (lambda* (#:key inputs #:allow-other-keys)
2996 (substitute* "sqlite-ffi.lisp"
2997 (("libsqlite3" all) (string-append
2998 (assoc-ref inputs "sqlite")"/lib/" all))))))))
2999 (home-page "https://common-lisp.net/project/cl-sqlite/")
3000 (synopsis "Common Lisp binding for SQLite")
3001 (description
3002 "The @command{cl-sqlite} package is an interface to the SQLite embedded
3003 relational database engine.")
3004 (license license:public-domain)))
3005
3006 (define-public cl-sqlite
3007 (sbcl-package->cl-source-package sbcl-cl-sqlite))
3008
3009 (define-public ecl-cl-sqlite
3010 (sbcl-package->ecl-package sbcl-cl-sqlite))
3011
3012 (define-public sbcl-parenscript
3013 ;; Source archives are overwritten on every release, we use the Git repo instead.
3014 (let ((commit "7a1ac46353cecd144fc91915ba9f122aafcf4766"))
3015 (package
3016 (name "sbcl-parenscript")
3017 (version (git-version "2.7.1" "1" commit))
3018 (source
3019 (origin
3020 (method git-fetch)
3021 (uri (git-reference
3022 (url "https://gitlab.common-lisp.net/parenscript/parenscript")
3023 (commit commit)))
3024 (file-name (git-file-name "parenscript" version))
3025 (sha256
3026 (base32
3027 "0c22lqarrpbq82dg1sb3y6mp6w2faczp34ymzhnmff88yfq1xzsf"))))
3028 (build-system asdf-build-system/sbcl)
3029 (inputs
3030 `(("cl-ppcre" ,sbcl-cl-ppcre)
3031 ("anaphora" ,sbcl-anaphora)
3032 ("named-readtables" ,sbcl-named-readtables)))
3033 (home-page "https://common-lisp.net/project/parenscript/")
3034 (synopsis "Translator from a subset of Common Lisp to JavaScript")
3035 (description
3036 "Parenscript is a translator from an extended subset of Common Lisp to
3037 JavaScript. Parenscript code can run almost identically on both the
3038 browser (as JavaScript) and server (as Common Lisp).
3039
3040 Parenscript code is treated the same way as Common Lisp code, making the full
3041 power of Lisp macros available for JavaScript. This provides a web
3042 development environment that is unmatched in its ability to reduce code
3043 duplication and provide advanced meta-programming facilities to web
3044 developers.
3045
3046 At the same time, Parenscript is different from almost all other \"language
3047 X\" to JavaScript translators in that it imposes almost no overhead:
3048
3049 @itemize
3050 @item No run-time dependencies: Any piece of Parenscript code is runnable
3051 as-is. There are no JavaScript files to include.
3052 @item Native types: Parenscript works entirely with native JavaScript data
3053 types. There are no new types introduced, and object prototypes are not
3054 touched.
3055 @item Native calling convention: Any JavaScript code can be called without the
3056 need for bindings. Likewise, Parenscript can be used to make efficient,
3057 self-contained JavaScript libraries.
3058 @item Readable code: Parenscript generates concise, formatted, idiomatic
3059 JavaScript code. Identifier names are preserved. This enables seamless
3060 debugging in tools like Firebug.
3061 @item Efficiency: Parenscript introduces minimal overhead for advanced Common
3062 Lisp features. The generated code is almost as fast as hand-written
3063 JavaScript.
3064 @end itemize\n")
3065 (license license:bsd-3))))
3066
3067 (define-public cl-parenscript
3068 (sbcl-package->cl-source-package sbcl-parenscript))
3069
3070 (define-public ecl-parenscript
3071 (sbcl-package->ecl-package sbcl-parenscript))
3072
3073 (define-public sbcl-cl-json
3074 (let ((commit "6dfebb9540bfc3cc33582d0c03c9ec27cb913e79"))
3075 (package
3076 (name "sbcl-cl-json")
3077 (version (git-version "0.5" "1" commit))
3078 (source
3079 (origin
3080 (method git-fetch)
3081 (uri (git-reference
3082 (url "https://github.com/hankhero/cl-json")
3083 (commit commit)))
3084 (file-name (git-file-name "cl-json" version))
3085 (sha256
3086 (base32
3087 "0fx3m3x3s5ji950yzpazz4s0img3l6b3d6l3jrfjv0lr702496lh"))))
3088 (build-system asdf-build-system/sbcl)
3089 (native-inputs
3090 `(("fiveam" ,sbcl-fiveam)))
3091 (home-page "https://github.com/hankhero/cl-json")
3092 (synopsis "JSON encoder and decoder for Common-Lisp")
3093 (description
3094 "@command{cl-json} provides an encoder of Lisp objects to JSON format
3095 and a corresponding decoder of JSON data to Lisp objects. Both the encoder
3096 and the decoder are highly customizable; at the same time, the default
3097 settings ensure a very simple mode of operation, similar to that provided by
3098 @command{yason} or @command{st-json}.")
3099 (license license:expat))))
3100
3101 (define-public cl-json
3102 (sbcl-package->cl-source-package sbcl-cl-json))
3103
3104 (define-public ecl-cl-json
3105 (sbcl-package->ecl-package sbcl-cl-json))
3106
3107 (define-public sbcl-unix-opts
3108 (package
3109 (name "sbcl-unix-opts")
3110 (version "0.1.7")
3111 (source
3112 (origin
3113 (method git-fetch)
3114 (uri (git-reference
3115 (url "https://github.com/libre-man/unix-opts")
3116 (commit version)))
3117 (file-name (git-file-name "unix-opts" version))
3118 (sha256
3119 (base32
3120 "08djdi1ard09fijb7w9bdmhmwd98b1hzmcnjw9fqjiqa0g3b44rr"))))
3121 (build-system asdf-build-system/sbcl)
3122 (home-page "https://github.com/hankhero/cl-json")
3123 (synopsis "Unix-style command line options parser")
3124 (description
3125 "This is a minimalistic parser of command line options. The main
3126 advantage of the library is the ability to concisely define command line
3127 options once and then use this definition for parsing and extraction of
3128 command line arguments, as well as printing description of command line
3129 options (you get --help for free). This way you don't need to repeat
3130 yourself. Also, @command{unix-opts} doesn't depend on anything and
3131 precisely controls the behavior of the parser via Common Lisp restarts.")
3132 (license license:expat)))
3133
3134 (define-public cl-unix-opts
3135 (sbcl-package->cl-source-package sbcl-unix-opts))
3136
3137 (define-public ecl-unix-opts
3138 (sbcl-package->ecl-package sbcl-unix-opts))
3139
3140 (define-public sbcl-trivial-garbage
3141 (package
3142 (name "sbcl-trivial-garbage")
3143 (version "0.21")
3144 (source
3145 (origin
3146 (method git-fetch)
3147 (uri (git-reference
3148 (url "https://github.com/trivial-garbage/trivial-garbage")
3149 (commit (string-append "v" version))))
3150 (file-name (git-file-name "trivial-garbage" version))
3151 (sha256
3152 (base32 "0122jicfg7pca1wxw8zak1n92h5friqy60988ns0ysksj3fphw9n"))))
3153 (build-system asdf-build-system/sbcl)
3154 (native-inputs
3155 `(("rt" ,sbcl-rt)))
3156 (home-page "https://common-lisp.net/project/trivial-garbage/")
3157 (synopsis "Portable GC-related APIs for Common Lisp")
3158 (description "@command{trivial-garbage} provides a portable API to
3159 finalizers, weak hash-tables and weak pointers on all major implementations of
3160 the Common Lisp programming language.")
3161 (license license:public-domain)))
3162
3163 (define-public cl-trivial-garbage
3164 (sbcl-package->cl-source-package sbcl-trivial-garbage))
3165
3166 (define-public ecl-trivial-garbage
3167 (sbcl-package->ecl-package sbcl-trivial-garbage))
3168
3169 (define-public sbcl-closer-mop
3170 (let ((commit "19c9d33f576e10715fd79cc1d4f688dab0f241d6"))
3171 (package
3172 (name "sbcl-closer-mop")
3173 (version (git-version "1.0.0" "2" commit))
3174 (source
3175 (origin
3176 (method git-fetch)
3177 (uri (git-reference
3178 (url "https://github.com/pcostanza/closer-mop")
3179 (commit commit)))
3180 (sha256
3181 (base32 "1w3x087wvlwkd6swfdgbvjfs6kazf0la8ax4pjfzikwjch4snn2c"))
3182 (file-name (git-file-name "closer-mop" version ))))
3183 (build-system asdf-build-system/sbcl)
3184 (home-page "https://github.com/pcostanza/closer-mop")
3185 (synopsis "Rectifies absent or incorrect CLOS MOP features")
3186 (description "Closer to MOP is a compatibility layer that rectifies many
3187 of the absent or incorrect CLOS MOP features across a broad range of Common
3188 Lisp implementations.")
3189 (license license:expat))))
3190
3191 (define-public cl-closer-mop
3192 (sbcl-package->cl-source-package sbcl-closer-mop))
3193
3194 (define-public ecl-closer-mop
3195 (sbcl-package->ecl-package sbcl-closer-mop))
3196
3197 (define-public sbcl-cl-cffi-gtk
3198 (let ((commit "e9a46df65995d9a16e6c8dbdc1e09b775eb4a966"))
3199 (package
3200 (name "sbcl-cl-cffi-gtk")
3201 (version (git-version "0.11.2" "2" commit))
3202 (source
3203 (origin
3204 (method git-fetch)
3205 (uri (git-reference
3206 (url "https://github.com/Ferada/cl-cffi-gtk/")
3207 (commit commit)))
3208 (file-name (git-file-name "cl-cffi-gtk" version))
3209 (sha256
3210 (base32
3211 "04vix0gmqsj91lm975sx7jhlnz5gq1xf9jp873mp7c8frc5dk1jj"))))
3212 (build-system asdf-build-system/sbcl)
3213 (native-inputs
3214 `(("fiveam" ,sbcl-fiveam)))
3215 (inputs
3216 `(("bordeaux-threads" ,sbcl-bordeaux-threads)
3217 ("cairo" ,cairo)
3218 ("cffi" ,sbcl-cffi)
3219 ("closer-mop" ,sbcl-closer-mop)
3220 ("gdk-pixbuf" ,gdk-pixbuf)
3221 ("glib" ,glib)
3222 ("gtk" ,gtk+)
3223 ("iterate" ,sbcl-iterate)
3224 ("pango" ,pango)
3225 ("trivial-features" ,sbcl-trivial-features)
3226 ("trivial-garbage" ,sbcl-trivial-garbage)))
3227 (arguments
3228 `(#:asd-files '("gtk/cl-cffi-gtk.asd"
3229 "glib/cl-cffi-gtk-glib.asd"
3230 "gobject/cl-cffi-gtk-gobject.asd"
3231 "gio/cl-cffi-gtk-gio.asd"
3232 "cairo/cl-cffi-gtk-cairo.asd"
3233 "pango/cl-cffi-gtk-pango.asd"
3234 "gdk-pixbuf/cl-cffi-gtk-gdk-pixbuf.asd"
3235 "gdk/cl-cffi-gtk-gdk.asd")
3236 #:test-asd-file "test/cl-cffi-gtk-test.asd"
3237 ;; TODO: Tests fail with memory fault.
3238 ;; See https://github.com/Ferada/cl-cffi-gtk/issues/24.
3239 #:tests? #f
3240 #:phases
3241 (modify-phases %standard-phases
3242 (add-after 'unpack 'fix-paths
3243 (lambda* (#:key inputs #:allow-other-keys)
3244 (substitute* "glib/glib.init.lisp"
3245 (("libglib|libgthread" all)
3246 (string-append (assoc-ref inputs "glib") "/lib/" all)))
3247 (substitute* "gobject/gobject.init.lisp"
3248 (("libgobject" all)
3249 (string-append (assoc-ref inputs "glib") "/lib/" all)))
3250 (substitute* "gio/gio.init.lisp"
3251 (("libgio" all)
3252 (string-append (assoc-ref inputs "glib") "/lib/" all)))
3253 (substitute* "cairo/cairo.init.lisp"
3254 (("libcairo" all)
3255 (string-append (assoc-ref inputs "cairo") "/lib/" all)))
3256 (substitute* "pango/pango.init.lisp"
3257 (("libpango" all)
3258 (string-append (assoc-ref inputs "pango") "/lib/" all)))
3259 (substitute* "gdk-pixbuf/gdk-pixbuf.init.lisp"
3260 (("libgdk_pixbuf" all)
3261 (string-append (assoc-ref inputs "gdk-pixbuf") "/lib/" all)))
3262 (substitute* "gdk/gdk.init.lisp"
3263 (("libgdk" all)
3264 (string-append (assoc-ref inputs "gtk") "/lib/" all)))
3265 (substitute* "gdk/gdk.package.lisp"
3266 (("libgtk" all)
3267 (string-append (assoc-ref inputs "gtk") "/lib/" all))))))))
3268 (home-page "https://github.com/Ferada/cl-cffi-gtk/")
3269 (synopsis "Common Lisp binding for GTK+3")
3270 (description
3271 "@command{cl-cffi-gtk} is a Lisp binding to GTK+ 3 (GIMP Toolkit) which
3272 is a library for creating graphical user interfaces.")
3273 (license license:lgpl3))))
3274
3275 (define-public cl-cffi-gtk
3276 (sbcl-package->cl-source-package sbcl-cl-cffi-gtk))
3277
3278 (define-public ecl-cl-cffi-gtk
3279 (sbcl-package->ecl-package sbcl-cl-cffi-gtk))
3280
3281 (define-public sbcl-cl-webkit
3282 (let ((commit "0bc05cc73257670ab241853b9cc9ccb68940fe44"))
3283 (package
3284 (name "sbcl-cl-webkit")
3285 (version (git-version "2.4" "10" commit))
3286 (source
3287 (origin
3288 (method git-fetch)
3289 (uri (git-reference
3290 (url "https://github.com/joachifm/cl-webkit")
3291 (commit commit)))
3292 (file-name (git-file-name "cl-webkit" version))
3293 (sha256
3294 (base32
3295 "1kg6illspvb5647pm0x819ag2n7njnqvrm18jzgd28vk6nlkrcmq"))))
3296 (build-system asdf-build-system/sbcl)
3297 (inputs
3298 `(("cffi" ,sbcl-cffi)
3299 ("cl-cffi-gtk" ,sbcl-cl-cffi-gtk)
3300 ("webkitgtk" ,webkitgtk)))
3301 (arguments
3302 `(#:asd-systems '("cl-webkit2")
3303 #:phases
3304 (modify-phases %standard-phases
3305 (add-after 'unpack 'fix-paths
3306 (lambda* (#:key inputs #:allow-other-keys)
3307 (substitute* "webkit2/webkit2.init.lisp"
3308 (("libwebkit2gtk" all)
3309 (string-append
3310 (assoc-ref inputs "webkitgtk") "/lib/" all))))))))
3311 (home-page "https://github.com/joachifm/cl-webkit")
3312 (synopsis "Binding to WebKitGTK+ for Common Lisp")
3313 (description
3314 "@command{cl-webkit} is a binding to WebKitGTK+ for Common Lisp,
3315 currently targeting WebKit version 2. The WebKitGTK+ library adds web
3316 browsing capabilities to an application, leveraging the full power of the
3317 WebKit browsing engine.")
3318 (license license:expat))))
3319
3320 (define-public cl-webkit
3321 (sbcl-package->cl-source-package sbcl-cl-webkit))
3322
3323 (define-public ecl-cl-webkit
3324 (sbcl-package->ecl-package sbcl-cl-webkit))
3325
3326 (define-public sbcl-lparallel
3327 (package
3328 (name "sbcl-lparallel")
3329 (version "2.8.4")
3330 (source
3331 (origin
3332 (method git-fetch)
3333 (uri (git-reference
3334 (url "https://github.com/lmj/lparallel/")
3335 (commit (string-append "lparallel-" version))))
3336 (file-name (git-file-name "lparallel" version))
3337 (sha256
3338 (base32
3339 "0g0aylrbbrqsz0ahmwhvnk4cmc2931fllbpcfgzsprwnqqd7vwq9"))))
3340 (build-system asdf-build-system/sbcl)
3341 (inputs
3342 `(("alexandria" ,sbcl-alexandria)
3343 ("bordeaux-threads" ,sbcl-bordeaux-threads)
3344 ("trivial-garbage" ,sbcl-trivial-garbage)))
3345 (arguments
3346 `(#:phases
3347 (modify-phases %standard-phases
3348 (add-after 'unpack 'fix-dependency
3349 ;; lparallel loads a SBCL specific system in its asd file. This is
3350 ;; not carried over into the fasl which is generated. In order for
3351 ;; it to be carried over, it needs to be listed as a dependency.
3352 (lambda _
3353 (substitute* "lparallel.asd"
3354 ((":depends-on \\(:alexandria" all)
3355 (string-append all " #+sbcl :sb-cltl2"))))))))
3356 (home-page "https://lparallel.org/")
3357 (synopsis "Parallelism for Common Lisp")
3358 (description
3359 "@command{lparallel} is a library for parallel programming in Common
3360 Lisp, featuring:
3361
3362 @itemize
3363 @item a simple model of task submission with receiving queue,
3364 @item constructs for expressing fine-grained parallelism,
3365 @item asynchronous condition handling across thread boundaries,
3366 @item parallel versions of map, reduce, sort, remove, and many others,
3367 @item promises, futures, and delayed evaluation constructs,
3368 @item computation trees for parallelizing interconnected tasks,
3369 @item bounded and unbounded FIFO queues,
3370 @item high and low priority tasks,
3371 @item task killing by category,
3372 @item integrated timeouts.
3373 @end itemize\n")
3374 (license license:expat)))
3375
3376 (define-public cl-lparallel
3377 (sbcl-package->cl-source-package sbcl-lparallel))
3378
3379 (define-public ecl-lparallel
3380 (package
3381 (inherit (sbcl-package->ecl-package sbcl-lparallel))
3382 (arguments
3383 ;; TODO: Find why the tests get stuck forever; disable them for now.
3384 `(#:tests? #f))))
3385
3386 (define-public sbcl-cl-markup
3387 (let ((commit "e0eb7debf4bdff98d1f49d0f811321a6a637b390"))
3388 (package
3389 (name "sbcl-cl-markup")
3390 (version (git-version "0.1" "1" commit))
3391 (source
3392 (origin
3393 (method git-fetch)
3394 (uri (git-reference
3395 (url "https://github.com/arielnetworks/cl-markup/")
3396 (commit commit)))
3397 (file-name (git-file-name "cl-markup" version))
3398 (sha256
3399 (base32
3400 "10l6k45971dl13fkdmva7zc6i453lmq9j4xax2ci6pjzlc6xjhp7"))))
3401 (build-system asdf-build-system/sbcl)
3402 (home-page "https://github.com/arielnetworks/cl-markup/")
3403 (synopsis "Markup generation library for Common Lisp")
3404 (description
3405 "A modern markup generation library for Common Lisp that features:
3406
3407 @itemize
3408 @item Fast (even faster through compiling the code)
3409 @item Safety
3410 @item Support for multiple document types (markup, xml, html, html5, xhtml)
3411 @item Output with doctype
3412 @item Direct output to stream
3413 @end itemize\n")
3414 (license license:lgpl3+))))
3415
3416 (define-public cl-markup
3417 (sbcl-package->cl-source-package sbcl-cl-markup))
3418
3419 (define-public ecl-cl-markup
3420 (sbcl-package->ecl-package sbcl-cl-markup))
3421
3422 (define-public sbcl-cl-mustache
3423 (package
3424 (name "sbcl-cl-mustache")
3425 (version "0.12.1")
3426 (source
3427 (origin
3428 (method git-fetch)
3429 (uri (git-reference
3430 (url "https://github.com/kanru/cl-mustache")
3431 (commit (string-append "v" version))))
3432 (file-name (git-file-name "cl-mustache" version))
3433 (sha256
3434 (base32 "149xbb6wxq1napliwm9cv729hwcgfnjli6y8hingfixz7f10lhks"))))
3435 (build-system asdf-build-system/sbcl)
3436 (home-page "https://github.com/kanru/cl-mustache")
3437 (synopsis "Common Lisp Mustache template renderer")
3438 (description "This is a Common Lisp implementation for the Mustache
3439 template system. More details on the standard are available at
3440 @url{https://mustache.github.io}.")
3441 (license license:expat)))
3442
3443 (define-public cl-mustache
3444 (sbcl-package->cl-source-package sbcl-cl-mustache))
3445
3446 (define-public ecl-cl-mustache
3447 (sbcl-package->ecl-package sbcl-cl-mustache))
3448
3449 (define-public sbcl-cl-css
3450 (let ((commit "8fe654c8f0cf95b300718101cce4feb517f78e2f"))
3451 (package
3452 (name "sbcl-cl-css")
3453 (version (git-version "0.1" "1" commit))
3454 (source
3455 (origin
3456 (method git-fetch)
3457 (uri (git-reference
3458 (url "https://github.com/inaimathi/cl-css/")
3459 (commit commit)))
3460 (file-name (git-file-name "cl-css" version))
3461 (sha256
3462 (base32
3463 "1lc42zi2sw11fl2589sc19nr5sd2p0wy7wgvgwaggxa5f3ajhsmd"))))
3464 (build-system asdf-build-system/sbcl)
3465 (home-page "https://github.com/inaimathi/cl-css/")
3466 (synopsis "Non-validating, inline CSS generator for Common Lisp")
3467 (description
3468 "This is a dead-simple, non validating, inline CSS generator for Common
3469 Lisp. Its goals are axiomatic syntax, simple implementation to support
3470 portability, and boilerplate reduction in CSS.")
3471 (license license:expat))))
3472
3473 (define-public cl-css
3474 (sbcl-package->cl-source-package sbcl-cl-css))
3475
3476 (define-public ecl-cl-css
3477 (sbcl-package->ecl-package sbcl-cl-css))
3478
3479 (define-public sbcl-portable-threads
3480 (let ((commit "aa26bf38338a6b068bf8bfb3375d8d8c3b0a28df"))
3481 (package
3482 (name "sbcl-portable-threads")
3483 (version (git-version "2.3" "2" commit))
3484 (source
3485 (origin
3486 (method git-fetch)
3487 (uri (git-reference
3488 (url "https://github.com/binghe/portable-threads/")
3489 (commit commit)))
3490 (file-name (git-file-name "portable-threads" version))
3491 (sha256
3492 (base32 "058ksi07vfdmhrf5mdlc833s82m1rcqfja2266520m3r8bzs8bvs"))))
3493 (build-system asdf-build-system/sbcl)
3494 (arguments
3495 `(;; Tests seem broken.
3496 #:tests? #f))
3497 (home-page "https://github.com/binghe/portable-threads")
3498 (synopsis "Portable threads API for Common Lisp")
3499 (description
3500 "Portable Threads (and Scheduled and Periodic Functions) API for Common
3501 Lisp (from GBBopen project).")
3502 (license license:asl2.0))))
3503
3504 (define-public cl-portable-threads
3505 (sbcl-package->cl-source-package sbcl-portable-threads))
3506
3507 (define-public ecl-portable-threads
3508 (sbcl-package->ecl-package sbcl-portable-threads))
3509
3510 (define-public sbcl-usocket
3511 (package
3512 (name "sbcl-usocket")
3513 (version "0.8.3")
3514 (source
3515 (origin
3516 (method git-fetch)
3517 (uri (git-reference
3518 (url "https://github.com/usocket/usocket/")
3519 (commit (string-append "v" version))))
3520 (file-name (git-file-name "usocket" version))
3521 (sha256
3522 (base32
3523 "0x746wr2324l6bn7skqzgkzcbj5kd0zp2ck0c8rldrw0rzabg826"))))
3524 (build-system asdf-build-system/sbcl)
3525 (native-inputs
3526 `(("rt" ,sbcl-rt)))
3527 (inputs
3528 `(("bordeaux-threads" ,sbcl-bordeaux-threads)
3529 ("split-sequence" ,sbcl-split-sequence)))
3530 (arguments
3531 `(#:tests? #f ; FIXME: Tests need network access?
3532 #:asd-systems '("usocket"
3533 "usocket-server")))
3534 (home-page "https://common-lisp.net/project/usocket/")
3535 (synopsis "Universal socket library for Common Lisp")
3536 (description
3537 "This library strives to provide a portable TCP/IP and UDP/IP socket
3538 interface for as many Common Lisp implementations as possible, while keeping
3539 the abstraction and portability layer as thin as possible.")
3540 (license license:expat)))
3541
3542 (define-public cl-usocket
3543 (sbcl-package->cl-source-package sbcl-usocket))
3544
3545 (define-public ecl-usocket
3546 (sbcl-package->ecl-package sbcl-usocket))
3547
3548 (define-public sbcl-s-xml
3549 (package
3550 (name "sbcl-s-xml")
3551 (version "3")
3552 (source
3553 (origin
3554 (method url-fetch)
3555 (uri "https://common-lisp.net/project/s-xml/s-xml.tgz")
3556 (sha256
3557 (base32
3558 "061qcr0dzshsa38s5ma4ay924cwak2nq9gy59dw6v9p0qb58nzjf"))))
3559 (build-system asdf-build-system/sbcl)
3560 (home-page "https://common-lisp.net/project/s-xml/")
3561 (synopsis "Simple XML parser implemented in Common Lisp")
3562 (description
3563 "S-XML is a simple XML parser implemented in Common Lisp. This XML
3564 parser implementation has the following features:
3565
3566 @itemize
3567 @item It works (handling many common XML usages).
3568 @item It is very small (the core is about 700 lines of code, including
3569 comments and whitespace).
3570 @item It has a core API that is simple, efficient and pure functional, much
3571 like that from SSAX (see also http://ssax.sourceforge.net).
3572 @item It supports different DOM models: an XSML-based one, an LXML-based one
3573 and a classic xml-element struct based one.
3574 @item It is reasonably time and space efficient (internally avoiding garbage
3575 generatation as much as possible).
3576 @item It does support CDATA.
3577 @item It should support the same character sets as your Common Lisp
3578 implementation.
3579 @item It does support XML name spaces.
3580 @end itemize
3581
3582 This XML parser implementation has the following limitations:
3583
3584 @itemize
3585 @item It does not support any special tags (like processing instructions).
3586 @item It is not validating, even skips DTD's all together.
3587 @end itemize\n")
3588 (license license:lgpl3+)))
3589
3590 (define-public cl-s-xml
3591 (sbcl-package->cl-source-package sbcl-s-xml))
3592
3593 (define-public ecl-s-xml
3594 (sbcl-package->ecl-package sbcl-s-xml))
3595
3596 (define-public sbcl-s-xml-rpc
3597 (package
3598 (name "sbcl-s-xml-rpc")
3599 (version "7")
3600 (source
3601 (origin
3602 (method url-fetch)
3603 (uri "https://common-lisp.net/project/s-xml-rpc/s-xml-rpc.tgz")
3604 (sha256
3605 (base32
3606 "02z7k163d51v0pzk8mn1xb6h5s6x64gjqkslhwm3a5x26k2gfs11"))))
3607 (build-system asdf-build-system/sbcl)
3608 (inputs
3609 `(("s-xml" ,sbcl-s-xml)))
3610 (home-page "https://common-lisp.net/project/s-xml-rpc/")
3611 (synopsis "Implementation of XML-RPC in Common Lisp for both client and server")
3612 (description
3613 "S-XML-RPC is an implementation of XML-RPC in Common Lisp for both
3614 client and server.")
3615 (license license:lgpl3+)))
3616
3617 (define-public cl-s-xml-rpc
3618 (sbcl-package->cl-source-package sbcl-s-xml-rpc))
3619
3620 (define-public ecl-s-xml-rpc
3621 (sbcl-package->ecl-package sbcl-s-xml-rpc))
3622
3623 (define-public sbcl-trivial-arguments
3624 (let ((commit "ecd84ed9cf9ef8f1e873d7409e6bd04979372aa7")
3625 (revision "1"))
3626 (package
3627 (name "sbcl-trivial-arguments")
3628 (version (git-version "1.1.0" revision commit))
3629 (source
3630 (origin
3631 (method git-fetch)
3632 (uri (git-reference
3633 (url "https://github.com/Shinmera/trivial-arguments")
3634 (commit commit)))
3635 (file-name (git-file-name "trivial-arguments" version))
3636 (sha256
3637 (base32 "02vaqfavhj8jqxnr68nnzvzshm8jbgcy6m9lvyv4daa6f7ihqf88"))))
3638 (build-system asdf-build-system/sbcl)
3639 (home-page "https://github.com/Shinmera/trivial-arguments")
3640 (synopsis "Common Lisp library to retrieve a function's lambda-list")
3641 (description
3642 "This is a simple library to retrieve the argument list of a function.")
3643 (license license:zlib))))
3644
3645 (define-public ecl-trivial-arguments
3646 (sbcl-package->ecl-package sbcl-trivial-arguments))
3647
3648 (define-public cl-trivial-arguments
3649 (sbcl-package->cl-source-package sbcl-trivial-arguments))
3650
3651 (define-public sbcl-trivial-clipboard
3652 (let ((commit "8a580cb97196be7cf096548eb1f46794cd22bb39"))
3653 (package
3654 (name "sbcl-trivial-clipboard")
3655 (version (git-version "0.0.0.0" "4" commit))
3656 (source
3657 (origin
3658 (method git-fetch)
3659 (uri (git-reference
3660 (url "https://github.com/snmsts/trivial-clipboard")
3661 (commit commit)))
3662 (file-name (git-file-name "trivial-clipboard" version))
3663 (sha256
3664 (base32
3665 "0apkgqrscylw3hhm5x2vs0z3hz6h7zd7dl5y3wr2zl8qjpvpc80k"))))
3666 (build-system asdf-build-system/sbcl)
3667 (inputs
3668 `(("xclip" ,xclip)))
3669 (native-inputs
3670 `(("fiveam" ,sbcl-fiveam)))
3671 (arguments
3672 `(#:phases
3673 (modify-phases %standard-phases
3674 (add-after 'unpack 'fix-paths
3675 (lambda* (#:key inputs #:allow-other-keys)
3676 (substitute* "src/text.lisp"
3677 (("\"xclip\"")
3678 (string-append "\"" (assoc-ref inputs "xclip") "/bin/xclip\""))))))))
3679 (home-page "https://github.com/snmsts/trivial-clipboard")
3680 (synopsis "Access system clipboard in Common Lisp")
3681 (description
3682 "@command{trivial-clipboard} gives access to the system clipboard.")
3683 (license license:expat))))
3684
3685 (define-public cl-trivial-clipboard
3686 (sbcl-package->cl-source-package sbcl-trivial-clipboard))
3687
3688 (define-public ecl-trivial-clipboard
3689 (sbcl-package->ecl-package sbcl-trivial-clipboard))
3690
3691 (define-public sbcl-trivial-backtrace
3692 (let ((commit "ca81c011b86424a381a7563cea3b924f24e6fbeb")
3693 (revision "1"))
3694 (package
3695 (name "sbcl-trivial-backtrace")
3696 (version (git-version "0.0.0" revision commit))
3697 (source
3698 (origin
3699 (method git-fetch)
3700 (uri (git-reference
3701 (url "https://github.com/gwkkwg/trivial-backtrace")
3702 (commit commit)))
3703 (file-name (git-file-name "trivial-backtrace" version))
3704 (sha256
3705 (base32 "10p41p43skj6cimdg8skjy7372s8v2xpkg8djjy0l8rm45i654k1"))))
3706 (build-system asdf-build-system/sbcl)
3707 (inputs
3708 `(("sbcl-lift" ,sbcl-lift)))
3709 (arguments
3710 `(#:phases
3711 (modify-phases %standard-phases
3712 (add-after 'check 'delete-test-results
3713 (lambda* (#:key outputs #:allow-other-keys)
3714 (let ((test-results (string-append (assoc-ref outputs "out")
3715 "/share/common-lisp/"
3716 (%lisp-type)
3717 "/trivial-backtrace"
3718 "/test-results")))
3719 (when (file-exists? test-results)
3720 (delete-file-recursively test-results)))
3721 #t)))))
3722 (home-page "https://common-lisp.net/project/trivial-backtrace/")
3723 (synopsis "Portable simple API to work with backtraces in Common Lisp")
3724 (description
3725 "One of the many things that didn't quite get into the Common Lisp
3726 standard was how to get a Lisp to output its call stack when something has
3727 gone wrong. As such, each Lisp has developed its own notion of what to
3728 display, how to display it, and what sort of arguments can be used to
3729 customize it. @code{trivial-backtrace} is a simple solution to generating a
3730 backtrace portably.")
3731 (license license:expat))))
3732
3733 (define-public cl-trivial-backtrace
3734 (sbcl-package->cl-source-package sbcl-trivial-backtrace))
3735
3736 (define-public ecl-trivial-backtrace
3737 (sbcl-package->ecl-package sbcl-trivial-backtrace))
3738
3739 (define-public sbcl-rfc2388
3740 (let ((commit "591bcf7e77f2c222c43953a80f8c297751dc0c4e")
3741 (revision "1"))
3742 (package
3743 (name "sbcl-rfc2388")
3744 (version (git-version "0.0.0" revision commit))
3745 (source
3746 (origin
3747 (method git-fetch)
3748 (uri (git-reference
3749 (url "https://github.com/jdz/rfc2388")
3750 (commit commit)))
3751 (file-name (git-file-name "rfc2388" version))
3752 (sha256
3753 (base32 "0phh5n3clhl9ji8jaxrajidn22d3f0aq87mlbfkkxlnx2pnw694k"))))
3754 (build-system asdf-build-system/sbcl)
3755 (home-page "https://github.com/jdz/rfc2388/")
3756 (synopsis "An implementation of RFC 2388 in Common Lisp")
3757 (description
3758 "This package contains an implementation of RFC 2388, which is used to
3759 process form data posted with HTTP POST method using enctype
3760 \"multipart/form-data\".")
3761 (license license:bsd-2))))
3762
3763 (define-public cl-rfc2388
3764 (sbcl-package->cl-source-package sbcl-rfc2388))
3765
3766 (define-public ecl-rfc2388
3767 (sbcl-package->ecl-package sbcl-rfc2388))
3768
3769 (define-public sbcl-md5
3770 (package
3771 (name "sbcl-md5")
3772 (version "2.0.4")
3773 (source
3774 (origin
3775 (method git-fetch)
3776 (uri (git-reference
3777 (url "https://github.com/pmai/md5")
3778 (commit (string-append "release-" version))))
3779 (file-name (git-file-name "md5" version))
3780 (sha256
3781 (base32 "1waqxzm7vlc22n92hv8r27anlvvjkkh9slhrky1ww7mdx4mmxwb8"))))
3782 (build-system asdf-build-system/sbcl)
3783 (home-page "https://github.com/pmai/md5")
3784 (synopsis
3785 "Common Lisp implementation of the MD5 Message-Digest Algorithm (RFC 1321)")
3786 (description
3787 "This package implements The MD5 Message-Digest Algorithm, as defined in
3788 RFC 1321 by R. Rivest, published April 1992.")
3789 (license license:public-domain)))
3790
3791 (define-public cl-md5
3792 (sbcl-package->cl-source-package sbcl-md5))
3793
3794 (define-public ecl-md5
3795 (package
3796 (inherit (sbcl-package->ecl-package sbcl-md5))
3797 (inputs
3798 `(("flexi-streams" ,ecl-flexi-streams)))))
3799
3800 (define-public sbcl-cl+ssl
3801 (let ((commit "701e645081e6533a3f0f0b3ac86389d6f506c4b5")
3802 (revision "1"))
3803 (package
3804 (name "sbcl-cl+ssl")
3805 (version (git-version "0.0.0" revision commit))
3806 (source
3807 (origin
3808 (method git-fetch)
3809 (uri (git-reference
3810 (url "https://github.com/cl-plus-ssl/cl-plus-ssl")
3811 (commit commit)))
3812 (file-name (git-file-name "cl+ssl" version))
3813 (sha256
3814 (base32 "0nfl275nwhff3m25872y388cydz14kqb6zbwywa6nj85r9k8bgs0"))))
3815 (build-system asdf-build-system/sbcl)
3816 (arguments
3817 '(#:phases
3818 (modify-phases %standard-phases
3819 (add-after 'unpack 'fix-paths
3820 (lambda* (#:key inputs #:allow-other-keys)
3821 (substitute* "src/reload.lisp"
3822 (("libssl.so" all)
3823 (string-append
3824 (assoc-ref inputs "openssl") "/lib/" all))))))))
3825 (inputs
3826 `(("openssl" ,openssl)
3827 ("sbcl-cffi" ,sbcl-cffi)
3828 ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)
3829 ("sbcl-flexi-streams" ,sbcl-flexi-streams)
3830 ("sbcl-bordeaux-threads" ,sbcl-bordeaux-threads)
3831 ("sbcl-trivial-garbage" ,sbcl-trivial-garbage)
3832 ("sbcl-alexandria" ,sbcl-alexandria)
3833 ("sbcl-trivial-features" ,sbcl-trivial-features)))
3834 (home-page "https://common-lisp.net/project/cl-plus-ssl/")
3835 (synopsis "Common Lisp bindings to OpenSSL")
3836 (description
3837 "This library is a fork of SSL-CMUCL. The original SSL-CMUCL source
3838 code was written by Eric Marsden and includes contributions by Jochen Schmidt.
3839 Development into CL+SSL was done by David Lichteblau.")
3840 (license license:expat))))
3841
3842 (define-public cl-cl+ssl
3843 (sbcl-package->cl-source-package sbcl-cl+ssl))
3844
3845 (define-public ecl-cl+ssl
3846 (sbcl-package->ecl-package sbcl-cl+ssl))
3847
3848 (define-public sbcl-kmrcl
3849 (let ((version "1.111")
3850 (commit "4a27407aad9deb607ffb8847630cde3d041ea25a")
3851 (revision "1"))
3852 (package
3853 (name "sbcl-kmrcl")
3854 (version (git-version version revision commit))
3855 (source
3856 (origin
3857 (method git-fetch)
3858 (uri (git-reference
3859 (url "http://git.kpe.io/kmrcl.git/")
3860 (commit commit)))
3861 (file-name (git-file-name name version))
3862 (sha256
3863 (base32 "06gx04mah5nc8w78s0j8628divbf1s5w7af8w7pvzb2d5mgvrbd2"))))
3864 (build-system asdf-build-system/sbcl)
3865 (inputs
3866 `(("sbcl-rt" ,sbcl-rt)))
3867 (home-page "http://files.kpe.io/kmrcl/")
3868 (synopsis "General utilities for Common Lisp programs")
3869 (description
3870 "KMRCL is a collection of utilities used by a number of Kevin
3871 Rosenberg's Common Lisp packages.")
3872 (license license:llgpl))))
3873
3874 (define-public cl-kmrcl
3875 (sbcl-package->cl-source-package sbcl-kmrcl))
3876
3877 (define-public ecl-kmrcl
3878 (sbcl-package->ecl-package sbcl-kmrcl))
3879
3880 (define-public sbcl-cl-base64
3881 ;; 3.3.4 tests are broken, upstream fixes them.
3882 (let ((commit "577683b18fd880b82274d99fc96a18a710e3987a"))
3883 (package
3884 (name "sbcl-cl-base64")
3885 (version (git-version "3.3.4" "1" commit))
3886 (source
3887 (origin
3888 (method git-fetch)
3889 (uri (git-reference
3890 (url "http://git.kpe.io/cl-base64.git/")
3891 (commit commit)))
3892 (file-name (git-file-name name version))
3893 (sha256
3894 (base32 "12jj54h0fs6n237cvnp8v6hn0imfksammq22ys6pi0gwz2w47rbj"))))
3895 (build-system asdf-build-system/sbcl)
3896 (native-inputs ; For tests.
3897 `(("sbcl-ptester" ,sbcl-ptester)
3898 ("sbcl-kmrcl" ,sbcl-kmrcl)))
3899 (home-page "http://files.kpe.io/cl-base64/")
3900 (synopsis
3901 "Common Lisp package to encode and decode base64 with URI support")
3902 (description
3903 "This package provides highly optimized base64 encoding and decoding.
3904 Besides conversion to and from strings, integer conversions are supported.
3905 Encoding with Uniform Resource Identifiers is supported by using a modified
3906 encoding table that uses only URI-compatible characters.")
3907 (license license:bsd-3))))
3908
3909 (define-public cl-base64
3910 (sbcl-package->cl-source-package sbcl-cl-base64))
3911
3912 (define-public ecl-cl-base64
3913 (sbcl-package->ecl-package sbcl-cl-base64))
3914
3915 (define-public sbcl-chunga
3916 (package
3917 (name "sbcl-chunga")
3918 (version "1.1.7")
3919 (source
3920 (origin
3921 (method git-fetch)
3922 (uri (git-reference
3923 (url "https://github.com/edicl/chunga")
3924 (commit (string-append "v" version))))
3925 (file-name (git-file-name name version))
3926 (sha256
3927 (base32 "0jzn3nyb3f22gm983rfk99smqs3mhb9ivjmasvhq9qla5cl9pyhd"))))
3928 (build-system asdf-build-system/sbcl)
3929 (inputs
3930 `(("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)))
3931 (home-page "https://edicl.github.io/chunga/")
3932 (synopsis "Portable chunked streams for Common Lisp")
3933 (description
3934 "Chunga implements streams capable of chunked encoding on demand as
3935 defined in RFC 2616.")
3936 (license license:bsd-2)))
3937
3938 (define-public cl-chunga
3939 (sbcl-package->cl-source-package sbcl-chunga))
3940
3941 (define-public ecl-chunga
3942 (sbcl-package->ecl-package sbcl-chunga))
3943
3944 (define-public sbcl-cl-who
3945 (let ((version "1.1.4")
3946 (commit "2c08caa4bafba720409af9171feeba3f32e86d32")
3947 (revision "1"))
3948 (package
3949 (name "sbcl-cl-who")
3950 (version (git-version version revision commit))
3951 (source
3952 (origin
3953 (method git-fetch)
3954 (uri (git-reference
3955 (url "https://github.com/edicl/cl-who")
3956 (commit commit)))
3957 (file-name (git-file-name name version))
3958 (sha256
3959 (base32
3960 "0yjb6sr3yazm288m318kqvj9xk8rm9n1lpimgf65ymqv0i5agxsb"))))
3961 (build-system asdf-build-system/sbcl)
3962 (native-inputs
3963 `(("sbcl-flexi-streams" ,sbcl-flexi-streams)))
3964 (home-page "https://edicl.github.io/cl-who/")
3965 (synopsis "Yet another Lisp markup language")
3966 (description
3967 "There are plenty of Lisp Markup Languages out there - every Lisp
3968 programmer seems to write at least one during his career - and CL-WHO (where
3969 WHO means \"with-html-output\" for want of a better acronym) is probably just
3970 as good or bad as the next one.")
3971 (license license:bsd-2))))
3972
3973 (define-public cl-who
3974 (sbcl-package->cl-source-package sbcl-cl-who))
3975
3976 (define-public ecl-cl-who
3977 (sbcl-package->ecl-package sbcl-cl-who))
3978
3979 (define-public sbcl-chipz
3980 (let ((version "0.8")
3981 (commit "75dfbc660a5a28161c57f115adf74c8a926bfc4d")
3982 (revision "1"))
3983 (package
3984 (name "sbcl-chipz")
3985 (version (git-version version revision commit))
3986 (source
3987 (origin
3988 (method git-fetch)
3989 (uri (git-reference
3990 (url "https://github.com/froydnj/chipz")
3991 (commit commit)))
3992 (file-name (git-file-name name version))
3993 (sha256
3994 (base32
3995 "0plx4rs39zbs4gjk77h4a2q11zpy75fh9v8hnxrvsf8fnakajhwg"))))
3996 (build-system asdf-build-system/sbcl)
3997 (native-inputs
3998 `(("sbcl-flexi-streams" ,sbcl-flexi-streams)))
3999 (home-page "http://method-combination.net/lisp/chipz/")
4000 (synopsis
4001 "Common Lisp library for decompressing deflate, zlib, gzip, and bzip2
4002 data")
4003 (description
4004 "DEFLATE data, defined in RFC1951, forms the core of popular
4005 compression formats such as zlib (RFC 1950) and gzip (RFC 1952). As such,
4006 Chipz also provides for decompressing data in those formats as well. BZIP2 is
4007 the format used by the popular compression tool bzip2.")
4008 ;; The author describes it as "MIT-like"
4009 (license license:expat))))
4010
4011 (define-public cl-chipz
4012 (sbcl-package->cl-source-package sbcl-chipz))
4013
4014 (define-public ecl-chipz
4015 (sbcl-package->ecl-package sbcl-chipz))
4016
4017 (define-public sbcl-drakma
4018 (package
4019 (name "sbcl-drakma")
4020 (version "2.0.7")
4021 (source
4022 (origin
4023 (method git-fetch)
4024 (uri (git-reference
4025 (url "https://github.com/edicl/drakma")
4026 (commit (string-append "v" version))))
4027 (file-name (git-file-name name version))
4028 (sha256
4029 (base32
4030 "1441idnyif9xzx3ln1p3fg36k2v9h4wasjqrzc8y52j61420qpci"))))
4031 (build-system asdf-build-system/sbcl)
4032 (inputs
4033 `(("sbcl-puri" ,sbcl-puri)
4034 ("sbcl-cl-base64" ,sbcl-cl-base64)
4035 ("sbcl-chunga" ,sbcl-chunga)
4036 ("sbcl-flexi-streams" ,sbcl-flexi-streams)
4037 ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
4038 ("sbcl-chipz" ,sbcl-chipz)
4039 ("sbcl-usocket" ,sbcl-usocket)
4040 ("sbcl-cl+ssl" ,sbcl-cl+ssl)))
4041 (native-inputs
4042 `(("sbcl-fiveam" ,sbcl-fiveam)))
4043 (home-page "https://edicl.github.io/drakma/")
4044 (synopsis "HTTP client written in Common Lisp")
4045 (description
4046 "Drakma is a full-featured HTTP client implemented in Common Lisp. It
4047 knows how to handle HTTP/1.1 chunking, persistent connections, re-usable
4048 sockets, SSL, continuable uploads, file uploads, cookies, and more.")
4049 (license license:bsd-2)))
4050
4051 (define-public cl-drakma
4052 (sbcl-package->cl-source-package sbcl-drakma))
4053
4054 (define-public ecl-drakma
4055 (sbcl-package->ecl-package sbcl-drakma))
4056
4057 (define-public sbcl-hunchentoot
4058 (package
4059 (name "sbcl-hunchentoot")
4060 (version "1.2.38")
4061 (source
4062 (origin
4063 (method git-fetch)
4064 (uri (git-reference
4065 (url "https://github.com/edicl/hunchentoot")
4066 (commit (string-append "v" version))))
4067 (file-name (git-file-name "hunchentoot" version))
4068 (sha256
4069 (base32 "1anpcad7w045m4rsjs1f3xdhjwx5cppq1h0vlb3q7dz81fi3i6yq"))))
4070 (build-system asdf-build-system/sbcl)
4071 (native-inputs
4072 `(("sbcl-cl-who" ,sbcl-cl-who)
4073 ("sbcl-drakma" ,sbcl-drakma)))
4074 (inputs
4075 `(("sbcl-chunga" ,sbcl-chunga)
4076 ("sbcl-cl-base64" ,sbcl-cl-base64)
4077 ("sbcl-cl-fad" ,sbcl-cl-fad)
4078 ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
4079 ("sbcl-flexi-streams" ,sbcl-flexi-streams)
4080 ("sbcl-cl+ssl" ,sbcl-cl+ssl)
4081 ("sbcl-md5" ,sbcl-md5)
4082 ("sbcl-rfc2388" ,sbcl-rfc2388)
4083 ("sbcl-trivial-backtrace" ,sbcl-trivial-backtrace)
4084 ("sbcl-usocket" ,sbcl-usocket)))
4085 (home-page "https://edicl.github.io/hunchentoot/")
4086 (synopsis "Web server written in Common Lisp")
4087 (description
4088 "Hunchentoot is a web server written in Common Lisp and at the same
4089 time a toolkit for building dynamic websites. As a stand-alone web server,
4090 Hunchentoot is capable of HTTP/1.1 chunking (both directions), persistent
4091 connections (keep-alive), and SSL.")
4092 (license license:bsd-2)))
4093
4094 (define-public cl-hunchentoot
4095 (sbcl-package->cl-source-package sbcl-hunchentoot))
4096
4097 (define-public ecl-hunchentoot
4098 (package
4099 (inherit (sbcl-package->ecl-package sbcl-hunchentoot))
4100 (arguments
4101 ;; Tests fail on ECL with 'Socket error in "socket": EINVAL'.
4102 '(#:tests? #f))))
4103
4104 (define-public sbcl-trivial-types
4105 (package
4106 (name "sbcl-trivial-types")
4107 (version "0.0.1")
4108 (source
4109 (origin
4110 (method git-fetch)
4111 (uri (git-reference
4112 (url "https://github.com/m2ym/trivial-types")
4113 (commit "ee869f2b7504d8aa9a74403641a5b42b16f47d88")))
4114 (file-name (git-file-name name version))
4115 (sha256
4116 (base32 "1s4cp9bdlbn8447q7w7f1wkgwrbvfzp20mgs307l5pxvdslin341"))))
4117 (build-system asdf-build-system/sbcl)
4118 (home-page "https://github.com/m2ym/trivial-types")
4119 (synopsis "Trivial type definitions for Common Lisp")
4120 (description
4121 "TRIVIAL-TYPES provides missing but important type definitions such as
4122 PROPER-LIST, ASSOCIATION-LIST, PROPERTY-LIST and TUPLE.")
4123 (license license:llgpl)))
4124
4125 (define-public cl-trivial-types
4126 (sbcl-package->cl-source-package sbcl-trivial-types))
4127
4128 (define-public ecl-trivial-types
4129 (sbcl-package->ecl-package sbcl-trivial-types))
4130
4131 (define-public sbcl-cl-annot
4132 (let ((commit "c99e69c15d935eabc671b483349a406e0da9518d")
4133 (revision "1"))
4134 (package
4135 (name "sbcl-cl-annot")
4136 (version (git-version "0.0.0" revision commit))
4137 (source
4138 (origin
4139 (method git-fetch)
4140 (uri (git-reference
4141 (url "https://github.com/m2ym/cl-annot")
4142 (commit commit)))
4143 (file-name (git-file-name name version))
4144 (sha256
4145 (base32 "1wq1gs9jjd5m6iwrv06c2d7i5dvqsfjcljgbspfbc93cg5xahk4n"))))
4146 (build-system asdf-build-system/sbcl)
4147 (inputs
4148 `(("sbcl-alexandria" ,sbcl-alexandria)))
4149 (home-page "https://github.com/m2ym/cl-annot")
4150 (synopsis "Python-like Annotation Syntax for Common Lisp.")
4151 (description
4152 "@code{cl-annot} is an general annotation library for Common Lisp.")
4153 (license license:llgpl))))
4154
4155 (define-public cl-annot
4156 (sbcl-package->cl-source-package sbcl-cl-annot))
4157
4158 (define-public ecl-cl-annot
4159 (sbcl-package->ecl-package sbcl-cl-annot))
4160
4161 (define-public sbcl-cl-syntax
4162 (package
4163 (name "sbcl-cl-syntax")
4164 (version "0.0.3")
4165 (source
4166 (origin
4167 (method git-fetch)
4168 (uri (git-reference
4169 (url "https://github.com/m2ym/cl-syntax")
4170 (commit "03f0c329bbd55b8622c37161e6278366525e2ccc")))
4171 (file-name (git-file-name "cl-syntax" version))
4172 (sha256
4173 (base32 "17ran8xp77asagl31xv8w819wafh6whwfc9p6dgx22ca537gyl4y"))))
4174 (build-system asdf-build-system/sbcl)
4175 (inputs
4176 `(("cl-annot" ,sbcl-cl-annot)
4177 ("cl-interpol" ,sbcl-cl-interpol)
4178 ("named-readtables" ,sbcl-named-readtables)
4179 ("trivial-types" ,sbcl-trivial-types)))
4180 (arguments
4181 '(#:asd-systems '("cl-syntax"
4182 "cl-syntax-annot"
4183 "cl-syntax-interpol")))
4184 (home-page "https://github.com/m2ym/cl-syntax")
4185 (synopsis "Reader Syntax Coventions for Common Lisp and SLIME")
4186 (description
4187 "CL-SYNTAX provides Reader Syntax Coventions for Common Lisp and SLIME.")
4188 (license license:llgpl)))
4189
4190 (define-public cl-syntax
4191 (sbcl-package->cl-source-package sbcl-cl-syntax))
4192
4193 (define-public ecl-cl-syntax
4194 (sbcl-package->ecl-package sbcl-cl-syntax))
4195
4196 (define-public sbcl-cl-utilities
4197 (let ((commit "dce2d2f6387091ea90357a130fa6d13a6776884b")
4198 (revision "1"))
4199 (package
4200 (name "sbcl-cl-utilities")
4201 (version (git-version "0.0.0" revision commit))
4202 (source
4203 (origin
4204 (method url-fetch)
4205 (uri
4206 (string-append
4207 "https://gitlab.common-lisp.net/cl-utilities/cl-utilities/-/"
4208 "archive/" commit "/cl-utilities-" commit ".tar.gz"))
4209 (sha256
4210 (base32 "1r46v730yf96nk2vb24qmagv9x96xvd08abqwhf02ghgydv1a7z2"))))
4211 (build-system asdf-build-system/sbcl)
4212 (arguments
4213 '(#:phases
4214 (modify-phases %standard-phases
4215 (add-after 'unpack 'fix-paths
4216 (lambda* (#:key inputs #:allow-other-keys)
4217 (substitute* "rotate-byte.lisp"
4218 (("in-package :cl-utilities)" all)
4219 "in-package :cl-utilities)\n\n#+sbcl\n(require :sb-rotate-byte)")))))))
4220 (home-page "http://common-lisp.net/project/cl-utilities")
4221 (synopsis "A collection of semi-standard utilities")
4222 (description
4223 "On Cliki.net <http://www.cliki.net/Common%20Lisp%20Utilities>, there
4224 is a collection of Common Lisp Utilities, things that everybody writes since
4225 they're not part of the official standard. There are some very useful things
4226 there; the only problems are that they aren't implemented as well as you'd
4227 like (some aren't implemented at all) and they aren't conveniently packaged
4228 and maintained. It takes quite a bit of work to carefully implement utilities
4229 for common use, commented and documented, with error checking placed
4230 everywhere some dumb user might make a mistake.")
4231 (license license:public-domain))))
4232
4233 (define-public cl-utilities
4234 (sbcl-package->cl-source-package sbcl-cl-utilities))
4235
4236 (define-public ecl-cl-utilities
4237 (sbcl-package->ecl-package sbcl-cl-utilities))
4238
4239 (define-public sbcl-map-set
4240 (let ((commit "7b4b545b68b8")
4241 (revision "1"))
4242 (package
4243 (name "sbcl-map-set")
4244 (version (git-version "0.0.0" revision commit))
4245 (source
4246 (origin
4247 (method url-fetch)
4248 (uri (string-append
4249 "https://bitbucket.org/tarballs_are_good/map-set/get/"
4250 commit ".tar.gz"))
4251 (sha256
4252 (base32 "1sx5j5qdsy5fklspfammwb16kjrhkggdavm922a9q86jm5l0b239"))))
4253 (build-system asdf-build-system/sbcl)
4254 (home-page "https://bitbucket.org/tarballs_are_good/map-set")
4255 (synopsis "Set-like data structure")
4256 (description
4257 "Implementation of a set-like data structure with constant time
4258 addition, removal, and random selection.")
4259 (license license:bsd-3))))
4260
4261 (define-public cl-map-set
4262 (sbcl-package->cl-source-package sbcl-map-set))
4263
4264 (define-public ecl-map-set
4265 (sbcl-package->ecl-package sbcl-map-set))
4266
4267 (define-public sbcl-quri
4268 (let ((commit "d7f2720568146c6674187f625f115925e6364a7f")
4269 (revision "4"))
4270 (package
4271 (name "sbcl-quri")
4272 (version (git-version "0.1.0" revision commit))
4273 (source
4274 (origin
4275 (method git-fetch)
4276 (uri (git-reference
4277 (url "https://github.com/fukamachi/quri")
4278 (commit commit)))
4279 (file-name (git-file-name name version))
4280 (sha256
4281 (base32 "0yrcvz5ksfr7x8yx741vp65il0fxxaskppq3iyk9bq895s1jn37w"))))
4282 (build-system asdf-build-system/sbcl)
4283 (arguments
4284 ;; Test system must be loaded before, otherwise tests fail with:
4285 ;; Component QURI-ASD::QURI-TEST not found, required by #<SYSTEM
4286 ;; "quri">.
4287 '(#:asd-systems '("quri-test"
4288 "quri")))
4289 (native-inputs `(("sbcl-prove" ,sbcl-prove)))
4290 (inputs `(("sbcl-babel" ,sbcl-babel)
4291 ("sbcl-split-sequence" ,sbcl-split-sequence)
4292 ("sbcl-cl-utilities" ,sbcl-cl-utilities)
4293 ("sbcl-alexandria" ,sbcl-alexandria)))
4294 (home-page "https://github.com/fukamachi/quri")
4295 (synopsis "Yet another URI library for Common Lisp")
4296 (description
4297 "QURI (pronounced \"Q-ree\") is yet another URI library for Common
4298 Lisp. It is intended to be a replacement of PURI.")
4299 (license license:bsd-3))))
4300
4301 (define-public cl-quri
4302 (sbcl-package->cl-source-package sbcl-quri))
4303
4304 (define-public ecl-quri
4305 (sbcl-package->ecl-package sbcl-quri))
4306
4307 (define-public sbcl-myway
4308 (let ((commit "286230082a11f879c18b93f17ca571c5f676bfb7")
4309 (revision "1"))
4310 (package
4311 (name "sbcl-myway")
4312 (version (git-version "0.1.0" revision commit))
4313 (source
4314 (origin
4315 (method git-fetch)
4316 (uri (git-reference
4317 (url "https://github.com/fukamachi/myway")
4318 (commit commit)))
4319 (file-name (git-file-name "myway" version))
4320 (sha256
4321 (base32 "0briia9bk3lbr0frnx39d1qg6i38dm4j6z9w3yga3d40k6df4a90"))))
4322 (build-system asdf-build-system/sbcl)
4323 (arguments
4324 ;; Tests fail with: Component MYWAY-ASD::MYWAY-TEST not found, required
4325 ;; by #<SYSTEM "myway">. Why?
4326 '(#:tests? #f))
4327 (native-inputs
4328 `(("sbcl-prove" ,sbcl-prove)))
4329 (inputs
4330 `(("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
4331 ("sbcl-quri" ,sbcl-quri)
4332 ("sbcl-map-set" ,sbcl-map-set)))
4333 (home-page "https://github.com/fukamachi/myway")
4334 (synopsis "Sinatra-compatible URL routing library for Common Lisp")
4335 (description "My Way is a Sinatra-compatible URL routing library.")
4336 (license license:llgpl))))
4337
4338 (define-public cl-myway
4339 (sbcl-package->cl-source-package sbcl-myway))
4340
4341 (define-public ecl-myway
4342 (sbcl-package->ecl-package sbcl-myway))
4343
4344 (define-public sbcl-xsubseq
4345 (let ((commit "5ce430b3da5cda3a73b9cf5cee4df2843034422b")
4346 (revision "1"))
4347 (package
4348 (name "sbcl-xsubseq")
4349 (version (git-version "0.0.1" revision commit))
4350 (source
4351 (origin
4352 (method git-fetch)
4353 (uri (git-reference
4354 (url "https://github.com/fukamachi/xsubseq")
4355 (commit commit)))
4356 (file-name (git-file-name name version))
4357 (sha256
4358 (base32 "1xz79q0p2mclf3sqjiwf6izdpb6xrsr350bv4mlmdlm6rg5r99px"))))
4359 (build-system asdf-build-system/sbcl)
4360 (arguments
4361 ;; Tests fail with: Component XSUBSEQ-ASD::XSUBSEQ-TEST not found,
4362 ;; required by #<SYSTEM "xsubseq">. Why?
4363 '(#:tests? #f))
4364 (native-inputs
4365 `(("sbcl-prove" ,sbcl-prove)))
4366 (home-page "https://github.com/fukamachi/xsubseq")
4367 (synopsis "Efficient way to use \"subseq\"s in Common Lisp")
4368 (description
4369 "XSubseq provides functions to be able to handle \"subseq\"s more
4370 effieiently.")
4371 (license license:bsd-2))))
4372
4373 (define-public cl-xsubseq
4374 (sbcl-package->cl-source-package sbcl-xsubseq))
4375
4376 (define-public ecl-xsubseq
4377 (sbcl-package->ecl-package sbcl-xsubseq))
4378
4379 (define-public sbcl-smart-buffer
4380 (let ((commit "09b9a9a0b3abaa37abe9a730f5aac2643dca4e62")
4381 (revision "1"))
4382 (package
4383 (name "sbcl-smart-buffer")
4384 (version (git-version "0.0.1" revision commit))
4385 (source
4386 (origin
4387 (method git-fetch)
4388 (uri (git-reference
4389 (url "https://github.com/fukamachi/smart-buffer")
4390 (commit commit)))
4391 (file-name (git-file-name name version))
4392 (sha256
4393 (base32 "0qz1zzxx0wm5ff7gpgsq550a59p0qj594zfmm2rglj97dahj54l7"))))
4394 (build-system asdf-build-system/sbcl)
4395 (arguments
4396 ;; Tests fail with: Component SMART-BUFFER-ASD::SMART-BUFFER-TEST not
4397 ;; found, required by #<SYSTEM "smart-buffer">. Why?
4398 `(#:tests? #f))
4399 (native-inputs
4400 `(("sbcl-prove" ,sbcl-prove)))
4401 (inputs
4402 `(("sbcl-xsubseq" ,sbcl-xsubseq)
4403 ("sbcl-flexi-streams" ,sbcl-flexi-streams)))
4404 (home-page "https://github.com/fukamachi/smart-buffer")
4405 (synopsis "Smart octets buffer")
4406 (description
4407 "Smart-buffer provides an output buffer which changes the destination
4408 depending on content size.")
4409 (license license:bsd-3))))
4410
4411 (define-public cl-smart-buffer
4412 (sbcl-package->cl-source-package sbcl-smart-buffer))
4413
4414 (define-public ecl-smart-buffer
4415 (sbcl-package->ecl-package sbcl-smart-buffer))
4416
4417 (define-public sbcl-fast-http
4418 (let ((commit "502a37715dcb8544cc8528b78143a942de662c5a")
4419 (revision "2"))
4420 (package
4421 (name "sbcl-fast-http")
4422 (version (git-version "0.2.0" revision commit))
4423 (source
4424 (origin
4425 (method git-fetch)
4426 (uri (git-reference
4427 (url "https://github.com/fukamachi/fast-http")
4428 (commit commit)))
4429 (file-name (git-file-name name version))
4430 (sha256
4431 (base32 "0al2g7g219jjljsf7b23pbilpgacxy5as5gs2nqf76b5qni396mi"))))
4432 (build-system asdf-build-system/sbcl)
4433 (arguments
4434 ;; Tests fail with: Component FAST-HTTP-ASD::FAST-HTTP-TEST not found,
4435 ;; required by #<SYSTEM "fast-http">. Why?
4436 `(#:tests? #f))
4437 (native-inputs
4438 `(("sbcl-prove" ,sbcl-prove)
4439 ("cl-syntax" ,sbcl-cl-syntax)))
4440 (inputs
4441 `(("sbcl-alexandria" ,sbcl-alexandria)
4442 ("sbcl-proc-parse" ,sbcl-proc-parse)
4443 ("sbcl-xsubseq" ,sbcl-xsubseq)
4444 ("sbcl-smart-buffer" ,sbcl-smart-buffer)
4445 ("sbcl-cl-utilities" ,sbcl-cl-utilities)))
4446 (home-page "https://github.com/fukamachi/fast-http")
4447 (synopsis "HTTP request/response parser for Common Lisp")
4448 (description
4449 "@code{fast-http} is a HTTP request/response protocol parser for Common
4450 Lisp.")
4451 ;; Author specified the MIT license
4452 (license license:expat))))
4453
4454 (define-public cl-fast-http
4455 (sbcl-package->cl-source-package sbcl-fast-http))
4456
4457 (define-public ecl-fast-http
4458 (sbcl-package->ecl-package sbcl-fast-http))
4459
4460 (define-public sbcl-static-vectors
4461 (package
4462 (name "sbcl-static-vectors")
4463 (version "1.8.6")
4464 (source
4465 (origin
4466 (method git-fetch)
4467 (uri (git-reference
4468 (url "https://github.com/sionescu/static-vectors")
4469 (commit (string-append "v" version))))
4470 (file-name (git-file-name name version))
4471 (sha256
4472 (base32 "01hwxzhyjkhsd3949g70120g7msw01byf0ia0pbj319q1a3cq7j9"))))
4473 (native-inputs
4474 `(("sbcl-fiveam" ,sbcl-fiveam)))
4475 (inputs
4476 `(("sbcl-alexandria" ,sbcl-alexandria)
4477 ("sbcl-cffi" ,sbcl-cffi)))
4478 (build-system asdf-build-system/sbcl)
4479 (home-page "https://github.com/sionescu/static-vectors")
4480 (synopsis "Allocate SIMPLE-ARRAYs in static memory")
4481 (description
4482 "With @code{static-vectors}, you can create vectors allocated in static
4483 memory.")
4484 (license license:expat)))
4485
4486 (define-public cl-static-vectors
4487 (sbcl-package->cl-source-package sbcl-static-vectors))
4488
4489 (define-public ecl-static-vectors
4490 (sbcl-package->ecl-package sbcl-static-vectors))
4491
4492 (define-public sbcl-marshal
4493 (let ((commit "eff1b15f2b0af2f26f71ad6a4dd5c4beab9299ec")
4494 (revision "1"))
4495 (package
4496 (name "sbcl-marshal")
4497 (version (git-version "1.3.0" revision commit))
4498 (source
4499 (origin
4500 (method git-fetch)
4501 (uri (git-reference
4502 (url "https://github.com/wlbr/cl-marshal")
4503 (commit commit)))
4504 (file-name (git-file-name name version))
4505 (sha256
4506 (base32 "08qs6fhk38xpkkjkpcj92mxx0lgy4ygrbbzrmnivdx281syr0gwh"))))
4507 (build-system asdf-build-system/sbcl)
4508 (home-page "https://github.com/wlbr/cl-marshal")
4509 (synopsis "Simple (de)serialization of Lisp datastructures")
4510 (description
4511 "Simple and fast marshalling of Lisp datastructures. Convert any object
4512 into a string representation, put it on a stream an revive it from there.
4513 Only minimal changes required to make your CLOS objects serializable.")
4514 (license license:expat))))
4515
4516 (define-public cl-marshal
4517 (sbcl-package->cl-source-package sbcl-marshal))
4518
4519 (define-public ecl-marshal
4520 (sbcl-package->ecl-package sbcl-marshal))
4521
4522 (define-public sbcl-checkl
4523 (let ((commit "80328800d047fef9b6e32dfe6bdc98396aee3cc9")
4524 (revision "1"))
4525 (package
4526 (name "sbcl-checkl")
4527 (version (git-version "0.0.0" revision commit))
4528 (source
4529 (origin
4530 (method git-fetch)
4531 (uri (git-reference
4532 (url "https://github.com/rpav/CheckL")
4533 (commit commit)))
4534 (file-name (git-file-name name version))
4535 (sha256
4536 (base32 "0bpisihx1gay44xmyr1dmhlwh00j0zzi04rp9fy35i95l2r4xdlx"))))
4537 (build-system asdf-build-system/sbcl)
4538 (arguments
4539 ;; Error while trying to load definition for system checkl-test from
4540 ;; pathname [...]/checkl-test.asd: The function CHECKL:DEFINE-TEST-OP
4541 ;; is undefined.
4542 '(#:asd-files '("checkl.asd")
4543 #:tests? #f))
4544 (native-inputs
4545 `(("sbcl-fiveam" ,sbcl-fiveam)))
4546 (inputs
4547 `(("sbcl-marshal" ,sbcl-marshal)))
4548 (home-page "https://github.com/rpav/CheckL/")
4549 (synopsis "Dynamic testing for Common Lisp")
4550 (description
4551 "CheckL lets you write tests dynamically, it checks resulting values
4552 against the last run.")
4553 ;; The author specifies both LLGPL and "BSD", but the "BSD" license
4554 ;; isn't specified anywhere, so I don't know which kind. LLGPL is the
4555 ;; stronger of the two and so I think only listing this should suffice.
4556 (license license:llgpl))))
4557
4558 (define-public cl-checkl
4559 (sbcl-package->cl-source-package sbcl-checkl))
4560
4561 (define-public ecl-checkl
4562 (sbcl-package->ecl-package sbcl-checkl))
4563
4564 (define-public sbcl-fast-io
4565 (let ((commit "603f4903dd74fb221859da7058ae6ca3853fe64b")
4566 (revision "2"))
4567 (package
4568 (name "sbcl-fast-io")
4569 (version (git-version "1.0.0" revision commit))
4570 (source
4571 (origin
4572 (method git-fetch)
4573 (uri (git-reference
4574 (url "https://github.com/rpav/fast-io")
4575 (commit commit)))
4576 (file-name (git-file-name name version))
4577 (sha256
4578 (base32 "00agvc0xx4w715i6ach05p995zpcpghn04xc06zyci06q677vw3n"))))
4579 (build-system asdf-build-system/sbcl)
4580 (arguments
4581 ;; Error while trying to load definition for system fast-io-test from
4582 ;; pathname [...]/fast-io-test.asd: The function CHECKL:DEFINE-TEST-OP
4583 ;; is undefined.
4584 '(#:tests? #f
4585 #:asd-files '("fast-io.asd")))
4586 (native-inputs
4587 `(("sbcl-fiveam" ,sbcl-fiveam)
4588 ("sbcl-checkl" ,sbcl-checkl)))
4589 (inputs
4590 `(("sbcl-alexandria" ,sbcl-alexandria)
4591 ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)
4592 ("sbcl-static-vectors" ,sbcl-static-vectors)))
4593 (home-page "https://github.com/rpav/fast-io")
4594 (synopsis "Fast octet-vector/stream I/O for Common Lisp")
4595 (description
4596 "Fast-io is about improving performance to octet-vectors and octet
4597 streams (though primarily the former, while wrapping the latter).")
4598 ;; Author specifies this as NewBSD which is an alias
4599 (license license:bsd-3))))
4600
4601 (define-public cl-fast-io
4602 (sbcl-package->cl-source-package sbcl-fast-io))
4603
4604 (define-public ecl-fast-io
4605 (sbcl-package->ecl-package sbcl-fast-io))
4606
4607 (define-public sbcl-jonathan
4608 (let ((commit "1f448b4f7ac8265e56e1c02b32ce383e65316300")
4609 (revision "1"))
4610 (package
4611 (name "sbcl-jonathan")
4612 (version (git-version "0.1.0" revision commit))
4613 (source
4614 (origin
4615 (method git-fetch)
4616 (uri (git-reference
4617 (url "https://github.com/Rudolph-Miller/jonathan")
4618 (commit commit)))
4619 (file-name (git-file-name name version))
4620 (sha256
4621 (base32 "14x4iwz3mbag5jzzzr4sb6ai0m9r4q4kyypbq32jmsk2dx1hi807"))))
4622 (build-system asdf-build-system/sbcl)
4623 (arguments
4624 ;; Tests fail with: Component JONATHAN-ASD::JONATHAN-TEST not found,
4625 ;; required by #<SYSTEM "jonathan">. Why?
4626 `(#:tests? #f))
4627 (native-inputs
4628 `(("sbcl-prove" ,sbcl-prove)))
4629 (inputs
4630 `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
4631 ("sbcl-fast-io" ,sbcl-fast-io)
4632 ("sbcl-proc-parse" ,sbcl-proc-parse)
4633 ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)))
4634 (home-page "https://rudolph-miller.github.io/jonathan/overview.html")
4635 (synopsis "JSON encoder and decoder")
4636 (description
4637 "High performance JSON encoder and decoder. Currently support: SBCL,
4638 CCL.")
4639 ;; Author specifies the MIT license
4640 (license license:expat))))
4641
4642 (define-public cl-jonathan
4643 (sbcl-package->cl-source-package sbcl-jonathan))
4644
4645 (define-public ecl-jonathan
4646 (sbcl-package->ecl-package sbcl-jonathan))
4647
4648 (define-public sbcl-http-body
4649 (let ((commit "dd01dc4f5842e3d29728552e5163acce8386eb73")
4650 (revision "1"))
4651 (package
4652 (name "sbcl-http-body")
4653 (version (git-version "0.1.0" revision commit))
4654 (source
4655 (origin
4656 (method git-fetch)
4657 (uri (git-reference
4658 (url "https://github.com/fukamachi/http-body")
4659 (commit commit)))
4660 (file-name (git-file-name name version))
4661 (sha256
4662 (base32 "1jd06snjvxcprhapgfq8sx0y5lrldkvhf206ix6d5a23dd6zcmr0"))))
4663 (build-system asdf-build-system/sbcl)
4664 (arguments
4665 ;; Tests fail with: Component HTTP-BODY-ASD::HTTP-BODY-TEST not
4666 ;; found, required by #<SYSTEM "http-body">. Why?
4667 `(#:tests? #f))
4668 (native-inputs
4669 `(("sbcl-prove" ,sbcl-prove)))
4670 (inputs
4671 `(("sbcl-fast-http" ,sbcl-fast-http)
4672 ("sbcl-jonathan" ,sbcl-jonathan)
4673 ("sbcl-quri" ,sbcl-quri)))
4674 (home-page "https://github.com/fukamachi/http-body")
4675 (synopsis "HTTP POST data parser")
4676 (description
4677 "HTTP-Body parses HTTP POST data and returns POST parameters. It
4678 supports application/x-www-form-urlencoded, application/json, and
4679 multipart/form-data.")
4680 (license license:bsd-2))))
4681
4682 (define-public cl-http-body
4683 (sbcl-package->cl-source-package sbcl-http-body))
4684
4685 (define-public ecl-http-body
4686 (sbcl-package->ecl-package sbcl-http-body))
4687
4688 (define-public sbcl-circular-streams
4689 (let ((commit "e770bade1919c5e8533dd2078c93c3d3bbeb38df")
4690 (revision "1"))
4691 (package
4692 (name "sbcl-circular-streams")
4693 (version (git-version "0.1.0" revision commit))
4694 (source
4695 (origin
4696 (method git-fetch)
4697 (uri (git-reference
4698 (url "https://github.com/fukamachi/circular-streams")
4699 (commit commit)))
4700 (file-name (git-file-name name version))
4701 (sha256
4702 (base32 "1wpw6d5cciyqcf92f7mvihak52pd5s47kk4qq6f0r2z2as68p5rs"))))
4703 (build-system asdf-build-system/sbcl)
4704 (arguments
4705 ;; The tests depend on cl-test-more which is now prove. Prove
4706 ;; tests aren't working for some reason.
4707 `(#:tests? #f))
4708 (inputs
4709 `(("sbcl-fast-io" ,sbcl-fast-io)
4710 ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)))
4711 (home-page "https://github.com/fukamachi/circular-streams")
4712 (synopsis "Circularly readable streams for Common Lisp")
4713 (description
4714 "Circular-Streams allows you to read streams circularly by wrapping real
4715 streams. Once you reach end-of-file of a stream, it's file position will be
4716 reset to 0 and you're able to read it again.")
4717 (license license:llgpl))))
4718
4719 (define-public cl-circular-streams
4720 (sbcl-package->cl-source-package sbcl-circular-streams))
4721
4722 (define-public ecl-circular-streams
4723 (sbcl-package->ecl-package sbcl-circular-streams))
4724
4725 (define-public sbcl-lack
4726 (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
4727 (revision "1"))
4728 (package
4729 (name "sbcl-lack")
4730 (version (git-version "0.1.0" revision commit))
4731 (source
4732 (origin
4733 (method git-fetch)
4734 (uri (git-reference
4735 (url "https://github.com/fukamachi/lack")
4736 (commit commit)))
4737 (file-name (git-file-name "lack" version))
4738 (sha256
4739 (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
4740 (build-system asdf-build-system/sbcl)
4741 (native-inputs
4742 `(("prove" ,sbcl-prove)))
4743 (inputs
4744 `(("circular-streams" ,sbcl-circular-streams)
4745 ("http-body" ,sbcl-http-body)
4746 ("ironclad" ,sbcl-ironclad)
4747 ("local-time" ,sbcl-local-time)
4748 ("quri" ,sbcl-quri)
4749 ("trivial-mimes" ,sbcl-trivial-mimes)))
4750 (arguments
4751 '(#:asd-systems '("lack"
4752 "lack-request"
4753 "lack-response"
4754 "lack-component"
4755 "lack-util"
4756 "lack-middleware-backtrace"
4757 "lack-middleware-static")
4758 #:test-asd-file "t-lack.asd"
4759 ;; XXX: Component :CLACK not found
4760 #:tests? #f))
4761 (home-page "https://github.com/fukamachi/lack")
4762 (synopsis "Lack, the core of Clack")
4763 (description
4764 "Lack is a Common Lisp library which allows web applications to be
4765 constructed of modular components. It was originally a part of Clack, however
4766 it's going to be rewritten as an individual project since Clack v2 with
4767 performance and simplicity in mind.")
4768 (license license:llgpl))))
4769
4770 (define-public cl-lack
4771 (sbcl-package->cl-source-package sbcl-lack))
4772
4773 (define-public ecl-lack
4774 (sbcl-package->ecl-package sbcl-lack))
4775
4776 (define-public sbcl-local-time
4777 (let ((commit "a177eb911c0e8116e2bfceb79049265a884b701b")
4778 (revision "2"))
4779 (package
4780 (name "sbcl-local-time")
4781 (version (git-version "1.0.6" revision commit))
4782 (source
4783 (origin
4784 (method git-fetch)
4785 (uri (git-reference
4786 (url "https://github.com/dlowe-net/local-time")
4787 (commit commit)))
4788 (file-name (git-file-name name version))
4789 (sha256
4790 (base32 "0wld28xx20k0ysgg6akic5lg4vkjd0iyhv86m388xfrv8xh87wii"))))
4791 (build-system asdf-build-system/sbcl)
4792 (native-inputs
4793 `(("hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
4794 (home-page "https://common-lisp.net/project/local-time/")
4795 (synopsis "Time manipulation library for Common Lisp")
4796 (description
4797 "The LOCAL-TIME library is a Common Lisp library for the manipulation of
4798 dates and times. It is based almost entirely upon Erik Naggum's paper \"The
4799 Long Painful History of Time\".")
4800 (license license:expat))))
4801
4802 (define-public cl-local-time
4803 (sbcl-package->cl-source-package sbcl-local-time))
4804
4805 (define-public ecl-local-time
4806 (sbcl-package->ecl-package sbcl-local-time))
4807
4808 (define-public sbcl-trivial-mimes
4809 (let ((commit "a741fc2f567a4f86b853fd4677d75e62c03e51d9")
4810 (revision "2"))
4811 (package
4812 (name "sbcl-trivial-mimes")
4813 (version (git-version "1.1.0" revision commit))
4814 (source
4815 (origin
4816 (method git-fetch)
4817 (uri (git-reference
4818 (url "https://github.com/Shinmera/trivial-mimes")
4819 (commit commit)))
4820 (file-name (git-file-name name version))
4821 (sha256
4822 (base32 "00kcm17q5plpzdj1qwg83ldhxksilgpcdkf3m9azxcdr968xs9di"))))
4823 (build-system asdf-build-system/sbcl)
4824 (native-inputs
4825 `(("stefil" ,sbcl-hu.dwim.stefil)))
4826 (inputs
4827 `(("sbcl-cl-fad" ,sbcl-cl-fad)))
4828 (home-page "https://shinmera.github.io/trivial-mimes/")
4829 (synopsis "Tiny Common Lisp library to detect mime types in files")
4830 (description
4831 "This is a teensy library that provides some functions to determine the
4832 mime-type of a file.")
4833 (license license:zlib))))
4834
4835 (define-public cl-trivial-mimes
4836 (sbcl-package->cl-source-package sbcl-trivial-mimes))
4837
4838 (define-public ecl-trivial-mimes
4839 (sbcl-package->ecl-package sbcl-trivial-mimes))
4840
4841 (define-public sbcl-ningle
4842 (let ((commit "50bd4f09b5a03a7249bd4d78265d6451563b25ad")
4843 (revision "1"))
4844 (package
4845 (name "sbcl-ningle")
4846 (version (git-version "0.3.0" revision commit))
4847 (source
4848 (origin
4849 (method git-fetch)
4850 (uri (git-reference
4851 (url "https://github.com/fukamachi/ningle")
4852 (commit commit)))
4853 (file-name (git-file-name name version))
4854 (sha256
4855 (base32 "1bsl8cnxhacb8p92z9n89vhk1ikmij5zavk0m2zvmj7iqm79jzgw"))))
4856 (build-system asdf-build-system/sbcl)
4857 (arguments
4858 ;; TODO: pull in clack-test
4859 '(#:tests? #f
4860 #:phases
4861 (modify-phases %standard-phases
4862 (delete 'cleanup-files)
4863 (delete 'cleanup)
4864 (add-before 'cleanup 'combine-fasls
4865 (lambda* (#:key outputs #:allow-other-keys)
4866 (let* ((out (assoc-ref outputs "out"))
4867 (lib (string-append out "/lib/sbcl"))
4868 (ningle-path (string-append lib "/ningle"))
4869 (fasl-files (find-files out "\\.fasl$")))
4870 (mkdir-p ningle-path)
4871 (let ((fasl-path (lambda (name)
4872 (string-append ningle-path
4873 "/"
4874 (basename name)
4875 "--system.fasl"))))
4876 (for-each (lambda (file)
4877 (rename-file file
4878 (fasl-path
4879 (basename file ".fasl"))))
4880 fasl-files))
4881 fasl-files)
4882 #t)))))
4883 (native-inputs
4884 `(("sbcl-prove" ,sbcl-prove)))
4885 (inputs
4886 `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
4887 ("sbcl-myway" ,sbcl-myway)
4888 ("sbcl-lack" ,sbcl-lack)
4889 ("sbcl-alexandria" ,sbcl-alexandria)
4890 ("sbcl-babel" ,sbcl-babel)))
4891 (home-page "https://8arrow.org/ningle/")
4892 (synopsis "Super micro framework for Common Lisp")
4893 (description
4894 "Ningle is a lightweight web application framework for Common Lisp.")
4895 (license license:llgpl))))
4896
4897 (define-public cl-ningle
4898 (sbcl-package->cl-source-package sbcl-ningle))
4899
4900 (define-public ecl-ningle
4901 (sbcl-package->ecl-package sbcl-ningle))
4902
4903 (define-public sbcl-cl-fastcgi
4904 (let ((commit "de8b49b26de9863996ec18db28af8ab7e8ac4e20")
4905 (revision "2"))
4906 (package
4907 (name "sbcl-cl-fastcgi")
4908 (version (git-version "0.2" revision commit))
4909 (source
4910 (origin
4911 (method git-fetch)
4912 (uri (git-reference
4913 (url "https://github.com/KDr2/cl-fastcgi/")
4914 (commit commit)))
4915 (file-name (git-file-name name version))
4916 (sha256
4917 (base32 "0xgmhx766q4nmrvn5z7ag3ikpr9phlh8ypi8b14azshq9lqbq0m7"))))
4918 (build-system asdf-build-system/sbcl)
4919 (inputs
4920 `(("usocket" ,sbcl-usocket)
4921 ("cffi" ,sbcl-cffi)
4922 ("fcgi" ,fcgi)))
4923 (arguments
4924 `(#:phases
4925 (modify-phases %standard-phases
4926 (add-after 'unpack 'fix-paths
4927 (lambda* (#:key inputs #:allow-other-keys)
4928 (substitute* "cl-fastcgi.lisp"
4929 (("\"libfcgi.so\"")
4930 (string-append
4931 "\""
4932 (assoc-ref inputs "fcgi") "/lib/libfcgi.so\""))))))))
4933 (home-page "https://kdr2.com/project/cl-fastcgi.html")
4934 (synopsis "FastCGI wrapper for Common Lisp")
4935 (description
4936 "CL-FastCGI is a generic version of SB-FastCGI, targeting to run on
4937 mostly Common Lisp implementation.")
4938 (license license:bsd-2))))
4939
4940 (define-public cl-fastcgi
4941 (sbcl-package->cl-source-package sbcl-cl-fastcgi))
4942
4943 (define-public ecl-cl-fastcgi
4944 (sbcl-package->ecl-package sbcl-cl-fastcgi))
4945
4946 (define-public sbcl-clack
4947 (let ((commit "e3e032843bb1220ab96263c411aa7f2feb4746e0")
4948 (revision "1"))
4949 (package
4950 (name "sbcl-clack")
4951 (version (git-version "2.0.0" revision commit))
4952 (source
4953 (origin
4954 (method git-fetch)
4955 (uri (git-reference
4956 (url "https://github.com/fukamachi/clack")
4957 (commit commit)))
4958 (file-name (git-file-name name version))
4959 (sha256
4960 (base32 "1ymzs6qyrwhlj6cgqsnpyn6g5cbp7a3s1vgxwna20y2q7y4iacy0"))))
4961 (build-system asdf-build-system/sbcl)
4962 (inputs
4963 `(("alexandria" ,sbcl-alexandria)
4964 ("bordeaux-threads" ,sbcl-bordeaux-threads)
4965 ("cl-fastcgi" ,sbcl-cl-fastcgi)
4966 ("flexi-streams" ,sbcl-flexi-streams)
4967 ("hunchentoot" ,sbcl-hunchentoot)
4968 ("lack" ,sbcl-lack)
4969 ("split-sequence" ,sbcl-split-sequence)
4970 ("usocket" ,sbcl-usocket)
4971 ("quri" ,sbcl-quri)))
4972 (arguments
4973 '(#:asd-systems '("clack"
4974 "clack-handler-fcgi"
4975 "clack-socket"
4976 "clack-handler-hunchentoot")))
4977 (home-page "https://github.com/fukamachi/clack")
4978 (synopsis "Web Application Environment for Common Lisp")
4979 (description
4980 "Clack is a web application environment for Common Lisp inspired by
4981 Python's WSGI and Ruby's Rack.")
4982 (license license:llgpl))))
4983
4984 (define-public cl-clack
4985 (sbcl-package->cl-source-package sbcl-clack))
4986
4987 (define-public ecl-clack
4988 (sbcl-package->ecl-package sbcl-clack))
4989
4990 (define-public sbcl-cl-log
4991 (let ((commit "8f4b766d51e02245c310526cf1e4534ce634f837")
4992 (revision "1"))
4993 (package
4994 (name "sbcl-cl-log")
4995 (version "1.0.1")
4996 (source
4997 (origin
4998 (method git-fetch)
4999 (uri (git-reference
5000 (url "https://github.com/nicklevine/cl-log")
5001 (commit commit)))
5002 (sha256
5003 (base32 "1r3z9swy1b59swvaa5b97is9ysrfmjvjjhhw56p7p5hqg93b92ak"))
5004 (file-name (git-file-name "cl-log" version))))
5005 (build-system asdf-build-system/sbcl)
5006 (synopsis "Common Lisp general purpose logging utility")
5007 (description "CL-LOG is a general purpose logging utility, loosely modelled
5008 in some respects after Gary King's Log5. Its features include: logging to
5009 several destinations at once, via \"messengers\", each messenger is tailored to
5010 accept some log messages and reject others, and this tailoring can be changed
5011 on-the-fly, very rapid processing of messages which are rejected by all
5012 messengers, fully independent use of the utility by several different
5013 sub-systems in an application, support for messengers which cl:format text to a
5014 stream, support for messengers which do not invoke cl:format, timestamps in
5015 theory accurate to internal-time-units-per-second.")
5016 (home-page "https://github.com/nicklevine/cl-log")
5017 (license license:expat))))
5018
5019 (define-public cl-log
5020 (sbcl-package->cl-source-package sbcl-cl-log))
5021
5022 (define-public ecl-cl-log
5023 (sbcl-package->ecl-package sbcl-cl-log))
5024
5025 (define-public sbcl-log4cl
5026 (let ((commit "8c48d6f41d3a1475d0a91eed0638b9eecc398e35")
5027 (revision "1"))
5028 (package
5029 (name "sbcl-log4cl")
5030 (version (git-version "1.1.3" revision commit))
5031 (source
5032 (origin
5033 (method git-fetch)
5034 (uri (git-reference
5035 (url "https://github.com/sharplispers/log4cl")
5036 (commit commit)))
5037 (file-name (git-file-name "log4cl" version))
5038 (sha256
5039 (base32 "0166d9aip366pbpdk5gsi2f6xad6q61lssxgbrypa8zslwjn8736"))))
5040 (build-system asdf-build-system/sbcl)
5041 (native-inputs
5042 `(("stefil" ,sbcl-stefil)))
5043 (inputs
5044 `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
5045 (home-page "https://github.com/7max/log4cl")
5046 (synopsis "Common Lisp logging framework, modeled after Log4J")
5047 (description
5048 "This is a Common Lisp logging framework that can log at various levels
5049 and mix text with expressions.")
5050 (license license:asl2.0))))
5051
5052 (define-public cl-log4cl
5053 (sbcl-package->cl-source-package sbcl-log4cl))
5054
5055 (define-public ecl-log4cl
5056 (sbcl-package->ecl-package sbcl-log4cl))
5057
5058 (define-public sbcl-printv
5059 (let ((commit "646d31978dbbb460fffb160fd65bb2be9a5a434e")
5060 (revision "1"))
5061 (package
5062 (name "sbcl-printv")
5063 (version (git-version "0.1.0" revision commit))
5064 (source
5065 (origin
5066 (method git-fetch)
5067 (uri (git-reference
5068 (url "https://github.com/danlentz/printv")
5069 (commit commit)))
5070 (file-name (git-file-name "printv" version))
5071 (sha256
5072 (base32 "08jvy82abm7qi3wrxh6gvmwg9gy0zzhg4cfqajdwrggbah8mj5a6"))))
5073 (build-system asdf-build-system/sbcl)
5074 (home-page "https://github.com/danlentz/printv")
5075 (synopsis "Common Lisp tracing and debug-logging macro")
5076 (description
5077 "@code{PRINTV} is a \"batteries-included\" tracing and debug-logging
5078 macro for Common Lisp.")
5079 (license license:asl2.0))))
5080
5081 (define-public ecl-printv
5082 (sbcl-package->ecl-package sbcl-printv))
5083
5084 (define-public cl-printv
5085 (sbcl-package->cl-source-package sbcl-printv))
5086
5087 (define-public sbcl-verbose
5088 (let ((commit "c5b7ecd465be61b35af17ef57564697b88397174")
5089 (revision "1"))
5090 (package
5091 (name "sbcl-verbose")
5092 (version (git-version "2.0.0" revision commit))
5093 (source
5094 (origin
5095 (method git-fetch)
5096 (uri (git-reference
5097 (url "https://github.com/Shinmera/verbose/")
5098 (commit commit)))
5099 (file-name (git-file-name "verbose" version))
5100 (sha256
5101 (base32 "0r51ydj5v7afi2jrlscbhxprv13d9vzg5316g1yzwaxc1kzsdsw6"))))
5102 (build-system asdf-build-system/sbcl)
5103 (inputs
5104 `(("bordeaux-threads" ,sbcl-bordeaux-threads)
5105 ("dissect" ,sbcl-dissect)
5106 ("documentation-utils" ,sbcl-documentation-utils)
5107 ("local-time" ,sbcl-local-time)
5108 ("piping" ,sbcl-piping)))
5109 (home-page "https://shinmera.github.io/verbose/")
5110 (synopsis "Logging framework using the piping library")
5111 (description
5112 "This is a Common Lisp library providing logging faciltiy similar to
5113 @code{CL-LOG} and @code{LOG4CL}.")
5114 (license license:zlib))))
5115
5116 (define-public ecl-verbose
5117 (sbcl-package->ecl-package sbcl-verbose))
5118
5119 (define-public cl-verbose
5120 (sbcl-package->cl-source-package sbcl-verbose))
5121
5122 (define-public sbcl-find-port
5123 (let ((commit "00c96a25af93a0f8681d34ec548861f2d7485478")
5124 (revision "1"))
5125 (package
5126 (name "sbcl-find-port")
5127 (build-system asdf-build-system/sbcl)
5128 (version "0.1")
5129 (home-page "https://github.com/eudoxia0/find-port")
5130 (source
5131 (origin
5132 (method git-fetch)
5133 (uri (git-reference
5134 (url home-page)
5135 (commit commit)))
5136 (file-name (git-file-name name version))
5137 (sha256
5138 (base32
5139 "0d6dzbb45jh0rx90wgs6v020k2xa87mvzas3mvfzvivjvqqlpryq"))))
5140 (native-inputs
5141 `(("fiveam" ,sbcl-fiveam)))
5142 (inputs
5143 `(("sbcl-usocket" ,sbcl-usocket)))
5144 (synopsis "Find open ports programmatically in Common Lisp")
5145 (description "This is a small Common Lisp library that finds an open
5146 port within a range.")
5147 (license license:expat))))
5148
5149 (define-public cl-find-port
5150 (sbcl-package->cl-source-package sbcl-find-port))
5151
5152 (define-public ecl-find-port
5153 (sbcl-package->ecl-package sbcl-find-port))
5154
5155 (define-public sbcl-clunit
5156 (let ((commit "6f6d72873f0e1207f037470105969384f8380628")
5157 (revision "1"))
5158 (package
5159 (name "sbcl-clunit")
5160 (version (git-version "0.2.3" revision commit))
5161 (source
5162 (origin
5163 (method git-fetch)
5164 (uri (git-reference
5165 (url "https://github.com/tgutu/clunit")
5166 (commit commit)))
5167 (file-name (git-file-name name version))
5168 (sha256
5169 (base32
5170 "1idf2xnqzlhi8rbrqmzpmb3i1l6pbdzhhajkmhwbp6qjkmxa4h85"))))
5171 (build-system asdf-build-system/sbcl)
5172 (synopsis "CLUnit is a Common Lisp unit testing framework")
5173 (description
5174 "CLUnit is a Common Lisp unit testing framework. It is designed
5175 to be easy to use so that you can quickly start testing. CLUnit
5176 provides a rich set of features aimed at improving your unit testing
5177 experience.")
5178 (home-page "https://tgutu.github.io/clunit/")
5179 ;; MIT License
5180 (license license:expat))))
5181
5182 (define-public cl-clunit
5183 (sbcl-package->cl-source-package sbcl-clunit))
5184
5185 (define-public ecl-clunit
5186 (sbcl-package->ecl-package sbcl-clunit))
5187
5188 (define-public sbcl-py4cl
5189 (let ((commit "4c8a2b0814fd311f978964f825ce012290f60136")
5190 (revision "1"))
5191 (package
5192 (name "sbcl-py4cl")
5193 (version (git-version "0.0.0" revision commit))
5194 (source
5195 (origin
5196 (method git-fetch)
5197 (uri (git-reference
5198 (url "https://github.com/bendudson/py4cl")
5199 (commit commit)))
5200 (file-name (git-file-name name version))
5201 (sha256
5202 (base32
5203 "15mk7qdqjkj56gdnbyrdyz6r7m1h26ldvn6ch96pmvg5vmr1m45r"))
5204 (modules '((guix build utils)))))
5205 (build-system asdf-build-system/sbcl)
5206 (native-inputs
5207 `(("sbcl-clunit" ,sbcl-clunit)))
5208 (inputs
5209 `(("sbcl-trivial-garbage" ,sbcl-trivial-garbage)))
5210 (propagated-inputs
5211 ;; This package doesn't do anything without python available
5212 `(("python" ,python)
5213 ;; For multi-dimensional array support
5214 ("python-numpy" ,python-numpy)))
5215 (arguments
5216 '(#:phases
5217 (modify-phases %standard-phases
5218 (add-after 'unpack 'replace-*base-directory*-var
5219 (lambda* (#:key outputs #:allow-other-keys)
5220 ;; In the ASD, the author makes an attempt to
5221 ;; programatically determine the location of the
5222 ;; source-code so lisp can call into "py4cl.py". We can
5223 ;; hard-code this since we know where this file will
5224 ;; reside.
5225 (substitute* "src/callpython.lisp"
5226 (("py4cl/config:\\*base-directory\\*")
5227 (string-append
5228 "\""
5229 (assoc-ref outputs "out")
5230 "/share/common-lisp/sbcl-source/py4cl/"
5231 "\""))))))))
5232 (synopsis "Call python from Common Lisp")
5233 (description
5234 "Py4CL is a bridge between Common Lisp and Python, which enables Common
5235 Lisp to interact with Python code. It uses streams to communicate with a
5236 separate python process, the approach taken by cl4py. This is different to
5237 the CFFI approach used by burgled-batteries, but has the same goal.")
5238 (home-page "https://github.com/bendudson/py4cl")
5239 ;; MIT License
5240 (license license:expat))))
5241
5242 (define-public cl-py4cl
5243 (sbcl-package->cl-source-package sbcl-py4cl))
5244
5245 (define-public ecl-py4cl
5246 (sbcl-package->ecl-package sbcl-py4cl))
5247
5248 (define-public sbcl-parse-declarations
5249 (let ((commit "549aebbfb9403a7fe948654126b9c814f443f4f2")
5250 (revision "1"))
5251 (package
5252 (name "sbcl-parse-declarations")
5253 (version (git-version "1.0.0" revision commit))
5254 (source
5255 (origin
5256 (method git-fetch)
5257 (uri (git-reference
5258 (url (string-append
5259 "https://gitlab.common-lisp.net/parse-declarations/"
5260 "parse-declarations.git"))
5261 (commit commit)))
5262 (file-name (git-file-name name version))
5263 (sha256
5264 (base32 "03g5qks4c59nmxa48pbslxkfh77h8hn8566jddp6m9pl15dzzpxd"))))
5265 (build-system asdf-build-system/sbcl)
5266 (arguments
5267 `(#:asd-systems '("parse-declarations-1.0")))
5268 (home-page "https://common-lisp.net/project/parse-declarations/")
5269 (synopsis "Parse, filter, and build declarations")
5270 (description
5271 "Parse-Declarations is a Common Lisp library to help writing
5272 macros which establish bindings. To be semantically correct, such
5273 macros must take user declarations into account, as these may affect
5274 the bindings they establish. Yet the ANSI standard of Common Lisp does
5275 not provide any operators to work with declarations in a convenient,
5276 high-level way. This library provides such operators.")
5277 ;; MIT License
5278 (license license:expat))))
5279
5280 (define-public cl-parse-declarations
5281 (sbcl-package->cl-source-package sbcl-parse-declarations))
5282
5283 (define-public ecl-parse-declarations
5284 (sbcl-package->ecl-package sbcl-parse-declarations))
5285
5286 (define-public sbcl-cl-quickcheck
5287 (let ((commit "807b2792a30c883a2fbecea8e7db355b50ba662f")
5288 (revision "1"))
5289 (package
5290 (name "sbcl-cl-quickcheck")
5291 (version (git-version "0.0.4" revision commit))
5292 (source
5293 (origin
5294 (method git-fetch)
5295 (uri (git-reference
5296 (url "https://github.com/mcandre/cl-quickcheck")
5297 (commit commit)))
5298 (file-name (git-file-name name version))
5299 (sha256
5300 (base32
5301 "165lhypq5xkcys6hvzb3jq7ywnmqvzaflda29qk2cbs3ggas4767"))))
5302 (build-system asdf-build-system/sbcl)
5303 (synopsis
5304 "Common Lisp port of the QuickCheck unit test framework")
5305 (description
5306 "Common Lisp port of the QuickCheck unit test framework")
5307 (home-page "https://github.com/mcandre/cl-quickcheck")
5308 ;; MIT
5309 (license license:expat))))
5310
5311 (define-public cl-quickcheck
5312 (sbcl-package->cl-source-package sbcl-cl-quickcheck))
5313
5314 (define-public ecl-cl-quickcheck
5315 (sbcl-package->ecl-package sbcl-cl-quickcheck))
5316
5317 (define-public sbcl-burgled-batteries3
5318 (let ((commit "f65f454d13bb6c40e17e9ec62e41eb5069e09760")
5319 (revision "2"))
5320 (package
5321 (name "sbcl-burgled-batteries3")
5322 (version (git-version "0.0.0" revision commit))
5323 (source
5324 (origin
5325 (method git-fetch)
5326 (uri (git-reference
5327 (url "https://github.com/snmsts/burgled-batteries3")
5328 (commit commit)))
5329 (file-name (git-file-name name version))
5330 (sha256
5331 (base32
5332 "1nzn7jawrfajyzwfnzrg2cmn9xxadcqh4szbpg0jggkhdkdzz4wa"))))
5333 (build-system asdf-build-system/sbcl)
5334 (arguments
5335 `(#:tests? #f
5336 #:modules (((guix build python-build-system) #:select (python-version))
5337 ,@%asdf-build-system-modules)
5338 #:imported-modules ((guix build python-build-system)
5339 ,@%asdf-build-system-modules)
5340 #:phases
5341 (modify-phases (@ (guix build asdf-build-system) %standard-phases)
5342 (add-after 'unpack 'set-*cpython-include-dir*-var
5343 (lambda* (#:key inputs #:allow-other-keys)
5344 (let ((python (assoc-ref inputs "python")))
5345 (setenv "BB_PYTHON3_INCLUDE_DIR"
5346 (string-append python "/include/python"
5347 (python-version python)))
5348 (setenv "BB_PYTHON3_DYLIB"
5349 (string-append python "/lib/libpython3.so"))
5350 #t)))
5351 (add-after 'unpack 'adjust-for-python-3.8
5352 (lambda _
5353 ;; This method is no longer part of the public API.
5354 (substitute* "ffi-interface.lisp"
5355 ((".*PyEval_ReInitThreads.*")
5356 ""))
5357 #t)))))
5358 (native-inputs
5359 `(("sbcl-cl-fad" ,sbcl-cl-fad)
5360 ("sbcl-lift" ,sbcl-lift)
5361 ("sbcl-cl-quickcheck" ,sbcl-cl-quickcheck)))
5362 (inputs
5363 `(("python" ,python)
5364 ("sbcl-cffi" ,sbcl-cffi)
5365 ("sbcl-alexandria" , sbcl-alexandria)
5366 ("sbcl-parse-declarations-1.0" ,sbcl-parse-declarations)
5367 ("sbcl-trivial-garbage" ,sbcl-trivial-garbage)))
5368 (synopsis "Bridge between Python and Lisp (FFI bindings, etc.)")
5369 (description
5370 "This package provides a shim between Python3 (specifically, the
5371 CPython implementation of Python) and Common Lisp.")
5372 (home-page "https://github.com/snmsts/burgled-batteries3")
5373 (license license:expat))))
5374
5375 (define-public cl-burgled-batteries3
5376 (sbcl-package->cl-source-package sbcl-burgled-batteries3))
5377
5378 (define-public ecl-burgled-batteries3
5379 (sbcl-package->ecl-package sbcl-burgled-batteries3))
5380
5381 (define-public sbcl-metabang-bind
5382 (let ((commit "c93b7f7e1c18c954c2283efd6a7fdab36746ab5e")
5383 (revision "1"))
5384 (package
5385 (name "sbcl-metabang-bind")
5386 (version (git-version "0.8.0" revision commit))
5387 (source
5388 (origin
5389 (method git-fetch)
5390 (uri (git-reference
5391 (url "https://github.com/gwkkwg/metabang-bind")
5392 (commit commit)))
5393 (file-name (git-file-name name version))
5394 (sha256
5395 (base32
5396 "0hd0kr91795v77akpbcyqiss9p0p7ypa9dznrllincnmgvsxlmf0"))))
5397 (build-system asdf-build-system/sbcl)
5398 (native-inputs
5399 `(("sbcl-lift" ,sbcl-lift)))
5400 (synopsis "Macro that generalizes @code{multiple-value-bind} etc.")
5401 (description
5402 "Bind extends the idea of of let and destructing to provide a uniform
5403 syntax for all your accessor needs. It combines @code{let},
5404 @code{destructuring-bind}, @code{with-slots}, @code{with-accessors}, structure
5405 editing, property or association-lists, and @code{multiple-value-bind} and a
5406 whole lot more into a single form.")
5407 (home-page "https://common-lisp.net/project/metabang-bind/")
5408 ;; MIT License
5409 (license license:expat))))
5410
5411 (define-public cl-metabang-bind
5412 (sbcl-package->cl-source-package sbcl-metabang-bind))
5413
5414 (define-public ecl-metabang-bind
5415 (sbcl-package->ecl-package sbcl-metabang-bind))
5416
5417 (define-public sbcl-fare-utils
5418 (let ((commit "66e9c6f1499140bc00ccc22febf2aa528cbb5724")
5419 (revision "1"))
5420 (package
5421 (name "sbcl-fare-utils")
5422 (version (git-version "1.0.0.5" revision commit))
5423 (source
5424 (origin
5425 (method git-fetch)
5426 (uri
5427 (git-reference
5428 (url
5429 "https://gitlab.common-lisp.net/frideau/fare-utils.git")
5430 (commit commit)))
5431 (file-name (git-file-name name version))
5432 (sha256
5433 (base32
5434 "01wsr1aap3jdzhn4hrqjbhsjx6qci9dbd3gh4gayv1p49rbg8aqr"))))
5435 (build-system asdf-build-system/sbcl)
5436 (arguments
5437 `(#:test-asd-file "test/fare-utils-test.asd"))
5438 (native-inputs
5439 `(("sbcl-hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
5440 (synopsis "Collection of utilities and data structures")
5441 (description
5442 "fare-utils is a small collection of utilities. It contains a lot of
5443 basic everyday functions and macros.")
5444 (home-page "https://gitlab.common-lisp.net/frideau/fare-utils")
5445 ;; MIT License
5446 (license license:expat))))
5447
5448 (define-public cl-fare-utils
5449 (sbcl-package->cl-source-package sbcl-fare-utils))
5450
5451 (define-public ecl-fare-utils
5452 (sbcl-package->ecl-package sbcl-fare-utils))
5453
5454 (define-public sbcl-trivial-utf-8
5455 (let ((commit "4d427cfbb1c452436a0efb71c3205c9da67f718f")
5456 (revision "1"))
5457 (package
5458 (name "sbcl-trivial-utf-8")
5459 (version (git-version "0.0.0" revision commit))
5460 (source
5461 (origin
5462 (method git-fetch)
5463 (uri
5464 (git-reference
5465 (url (string-append "https://gitlab.common-lisp.net/"
5466 "trivial-utf-8/trivial-utf-8.git"))
5467 (commit commit)))
5468 (file-name (git-file-name name version))
5469 (sha256
5470 (base32
5471 "1jz27gz8gvqdmvp3k9bxschs6d5b3qgk94qp2bj6nv1d0jc3m1l1"))))
5472 (arguments
5473 ;; Guix incorrectly assumes the "8" is part of the version
5474 ;; number and lobs it off.
5475 `(#:asd-systems '("trivial-utf-8")))
5476 (build-system asdf-build-system/sbcl)
5477 (synopsis "UTF-8 input/output library")
5478 (description
5479 "The Babel library solves a similar problem while understanding more
5480 encodings. Trivial UTF-8 was written before Babel existed, but for new
5481 projects you might be better off going with Babel. The one plus that Trivial
5482 UTF-8 has is that it doesn't depend on any other libraries.")
5483 (home-page "https://common-lisp.net/project/trivial-utf-8/")
5484 (license license:bsd-3))))
5485
5486 (define-public cl-trivial-utf-8
5487 (sbcl-package->cl-source-package sbcl-trivial-utf-8))
5488
5489 (define-public ecl-trivial-utf-8
5490 (sbcl-package->ecl-package sbcl-trivial-utf-8))
5491
5492 (define-public sbcl-idna
5493 (package
5494 (name "sbcl-idna")
5495 (build-system asdf-build-system/sbcl)
5496 (version "0.2.2")
5497 (home-page "https://github.com/antifuchs/idna")
5498 (source
5499 (origin
5500 (method git-fetch)
5501 (uri (git-reference
5502 (url home-page)
5503 (commit version)))
5504 (file-name (git-file-name name version))
5505 (sha256
5506 (base32
5507 "00nbr3mffxhlq14gg9d16pa6691s4qh35inyw76v906s77khm5a2"))))
5508 (inputs
5509 `(("split-sequence" ,sbcl-split-sequence)))
5510 (synopsis "IDNA string encoding and decoding routines for Common Lisp")
5511 (description "This Common Lisp library provides string encoding and
5512 decoding routines for IDNA, the International Domain Names in Applications.")
5513 (license license:expat)))
5514
5515 (define-public cl-idna
5516 (sbcl-package->cl-source-package sbcl-idna))
5517
5518 (define-public ecl-idna
5519 (sbcl-package->ecl-package sbcl-idna))
5520
5521 (define-public sbcl-swap-bytes
5522 (package
5523 (name "sbcl-swap-bytes")
5524 (build-system asdf-build-system/sbcl)
5525 (version "1.2")
5526 (home-page "https://github.com/sionescu/swap-bytes")
5527 (source
5528 (origin
5529 (method git-fetch)
5530 (uri (git-reference
5531 (url home-page)
5532 (commit (string-append "v" version))))
5533 (file-name (git-file-name name version))
5534 (sha256
5535 (base32
5536 "1hw1v1lw26rifyznpnj1csphha9jgzwpiic16ni3pvs6hcsni9rz"))))
5537 (inputs
5538 `(("trivial-features" ,sbcl-trivial-features)))
5539 (native-inputs
5540 `(("fiveam" ,sbcl-fiveam)))
5541 (synopsis "Efficient endianness conversion for Common Lisp")
5542 (description "This Common Lisp library provides optimized byte-swapping
5543 primitives. The library can change endianness of unsigned integers of length
5544 1/2/4/8. Very useful in implementing various network protocols and file
5545 formats.")
5546 (license license:expat)))
5547
5548 (define-public cl-swap-bytes
5549 (sbcl-package->cl-source-package sbcl-swap-bytes))
5550
5551 (define-public ecl-swap-bytes
5552 (sbcl-package->ecl-package sbcl-swap-bytes))
5553
5554 (define-public sbcl-iolib
5555 ;; Latest release is from June 2017.
5556 (let ((commit "7f5ea3a8457a29d224b24653c2b3657fb1898021")
5557 (revision "2"))
5558 (package
5559 (name "sbcl-iolib")
5560 (version (git-version "0.8.3" revision commit))
5561 (home-page "https://github.com/sionescu/iolib")
5562 (source
5563 (origin
5564 (method git-fetch)
5565 (uri (git-reference
5566 (url home-page)
5567 (commit commit)))
5568 (file-name (git-file-name name version))
5569 (sha256
5570 (base32
5571 "1bg5w7lm61hqk4b0svmri8a590q36z76jfa0sdgzb39r98c04w12"))))
5572 (build-system asdf-build-system/sbcl)
5573 (inputs
5574 `(("alexandria" ,sbcl-alexandria)
5575 ("bordeaux-threads" ,sbcl-bordeaux-threads)
5576 ("cffi" ,sbcl-cffi)
5577 ("idna" ,sbcl-idna)
5578 ("libfixposix" ,libfixposix)
5579 ("split-sequence" ,sbcl-split-sequence)
5580 ("swap-bytes" ,sbcl-swap-bytes)))
5581 (arguments
5582 '(#:asd-files '("iolib.asdf.asd"
5583 "iolib.conf.asd"
5584 "iolib.common-lisp.asd"
5585 "iolib.base.asd"
5586 "iolib.asd")
5587 #:phases
5588 (modify-phases %standard-phases
5589 (add-after 'unpack 'fix-paths
5590 (lambda* (#:key inputs #:allow-other-keys)
5591 (substitute* "src/syscalls/ffi-functions-unix.lisp"
5592 (("\\(:default \"libfixposix\"\\)")
5593 (string-append
5594 "(:default \""
5595 (assoc-ref inputs "libfixposix") "/lib/libfixposix\")")))
5596 ;; Socket tests need Internet access, disable them.
5597 (substitute* "iolib.asd"
5598 (("\\(:file \"sockets\" :depends-on \\(\"pkgdcl\" \"defsuites\"\\)\\)")
5599 "")))))))
5600 (synopsis "Common Lisp I/O library")
5601 (description "IOlib is to be a better and more modern I/O library than
5602 the standard Common Lisp library. It contains a socket library, a DNS
5603 resolver, an I/O multiplexer(which supports @code{select(2)}, @code{epoll(4)}
5604 and @code{kqueue(2)}), a pathname library and file-system utilities.")
5605 (license license:expat))))
5606
5607 (define-public cl-iolib
5608 (let ((parent (sbcl-package->cl-source-package sbcl-iolib)))
5609 (package
5610 (inherit parent)
5611 (propagated-inputs
5612 ;; Need header to compile.
5613 `(("libfixposix" ,libfixposix)
5614 ,@(package-propagated-inputs parent))))))
5615
5616 (define-public ecl-iolib
5617 (sbcl-package->ecl-package sbcl-iolib))
5618
5619 (define-public sbcl-ieee-floats
5620 (let ((commit "566b51a005e81ff618554b9b2f0b795d3b29398d")
5621 (revision "1"))
5622 (package
5623 (name "sbcl-ieee-floats")
5624 (build-system asdf-build-system/sbcl)
5625 (version (git-version "20170924" revision commit))
5626 (home-page "https://github.com/marijnh/ieee-floats/")
5627 (source
5628 (origin
5629 (method git-fetch)
5630 (uri (git-reference
5631 (url home-page)
5632 (commit commit)))
5633 (file-name (git-file-name name version))
5634 (sha256
5635 (base32
5636 "1xyj49j9x3lc84cv3dhbf9ja34ywjk1c46dklx425fxw9mkwm83m"))))
5637 (native-inputs
5638 `(("fiveam" ,sbcl-fiveam)))
5639 (synopsis "IEEE 754 binary representation for floats in Common Lisp")
5640 (description "This is a Common Lisp library that converts
5641 floating point values to IEEE 754 binary representation.")
5642 (license license:bsd-3))))
5643
5644 (define-public cl-ieee-floats
5645 (sbcl-package->cl-source-package sbcl-ieee-floats))
5646
5647 (define-public ecl-ieee-floats
5648 (sbcl-package->ecl-package sbcl-ieee-floats))
5649
5650 (define sbcl-closure-common
5651 (let ((commit "e3c5f5f454b72b01b89115e581c3c52a7e201e5c")
5652 (revision "1"))
5653 (package
5654 (name "sbcl-closure-common")
5655 (build-system asdf-build-system/sbcl)
5656 (version (git-version "20101006" revision commit))
5657 (home-page "https://common-lisp.net/project/cxml/")
5658 (source
5659 (origin
5660 (method git-fetch)
5661 (uri (git-reference
5662 (url "https://github.com/sharplispers/closure-common")
5663 (commit commit)))
5664 (file-name (git-file-name name version))
5665 (sha256
5666 (base32
5667 "0k5r2qxn122pxi301ijir3nayi9sg4d7yiy276l36qmzwhp4mg5n"))))
5668 (inputs
5669 `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)
5670 ("babel" ,sbcl-babel)))
5671 (synopsis "Support Common Lisp library for CXML")
5672 (description "Closure-common is an internal helper library. The name
5673 Closure is a reference to the web browser it was originally written for.")
5674 ;; TODO: License?
5675 (license #f))))
5676
5677 (define-public sbcl-cxml
5678 (let ((commit "00b22bf4c4cf11c993d5866fae284f95ab18e6bf")
5679 (revision "1"))
5680 (package
5681 (name "sbcl-cxml")
5682 (version (git-version "0.0.0" revision commit))
5683 (source
5684 (origin
5685 (method git-fetch)
5686 (uri (git-reference
5687 (url "https://github.com/sharplispers/cxml")
5688 (commit commit)))
5689 (file-name (git-file-name name version))
5690 (sha256
5691 (base32
5692 "13kif7rf3gqdycsk9zq0d7y0g9y81krkl0z87k0p2fkbjfgrph37"))))
5693 (build-system asdf-build-system/sbcl)
5694 (inputs
5695 `(("closure-common" ,sbcl-closure-common)
5696 ("puri" ,sbcl-puri)
5697 ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
5698 (synopsis "Common Lisp XML parser")
5699 (description "CXML implements a namespace-aware, validating XML 1.0
5700 parser as well as the DOM Level 2 Core interfaces. Two parser interfaces are
5701 offered, one SAX-like, the other similar to StAX.")
5702 (home-page "https://common-lisp.net/project/cxml/")
5703 (license license:llgpl))))
5704
5705 (define-public cl-cxml
5706 (sbcl-package->cl-source-package sbcl-cxml))
5707
5708 (define-public ecl-cxml
5709 (sbcl-package->ecl-package sbcl-cxml))
5710
5711 (define-public sbcl-cl-reexport
5712 (let ((commit "312f3661bbe187b5f28536cd7ec2956e91366c3b")
5713 (revision "1"))
5714 (package
5715 (name "sbcl-cl-reexport")
5716 (build-system asdf-build-system/sbcl)
5717 (version (git-version "0.1" revision commit))
5718 (home-page "https://github.com/takagi/cl-reexport")
5719 (source
5720 (origin
5721 (method git-fetch)
5722 (uri (git-reference
5723 (url home-page)
5724 (commit commit)))
5725 (file-name (git-file-name name version))
5726 (sha256
5727 (base32
5728 "1cwpn1m3wrl0fl9plznn7p464db646gnfc8zkyk97dyxski2aq0x"))))
5729 (inputs
5730 `(("alexandria" ,sbcl-alexandria)))
5731 (arguments
5732 ;; TODO: Tests fail because cl-test-more is missing, but I can't find it online.
5733 `(#:tests? #f))
5734 (synopsis "HTTP cookie manager for Common Lisp")
5735 (description "cl-cookie is a Common Lisp library featuring parsing of
5736 cookie headers, cookie creation, cookie jar creation and more.")
5737 (license license:llgpl))))
5738
5739 (define-public cl-reexport
5740 (sbcl-package->cl-source-package sbcl-cl-reexport))
5741
5742 (define-public ecl-cl-reexport
5743 (sbcl-package->ecl-package sbcl-cl-reexport))
5744
5745 (define-public sbcl-cl-cookie
5746 (let ((commit "cea55aed8b9ad25fafd13defbcb9fe8f41b29546")
5747 (revision "1"))
5748 (package
5749 (name "sbcl-cl-cookie")
5750 (build-system asdf-build-system/sbcl)
5751 (version (git-version "0.9.10" revision commit))
5752 (home-page "https://github.com/fukamachi/cl-cookie")
5753 (source
5754 (origin
5755 (method git-fetch)
5756 (uri (git-reference
5757 (url home-page)
5758 (commit commit)))
5759 (file-name (git-file-name name version))
5760 (sha256
5761 (base32
5762 "090g7z75h98zvc1ldx0vh4jn4086dhjm2w30jcwkq553qmyxwl8h"))))
5763 (inputs
5764 `(("proc-parse" ,sbcl-proc-parse)
5765 ("alexandria" ,sbcl-alexandria)
5766 ("quri" ,sbcl-quri)
5767 ("cl-ppcre" ,sbcl-cl-ppcre)
5768 ("local-time" ,sbcl-local-time)))
5769 (native-inputs
5770 `(("prove" ,sbcl-prove)))
5771 (arguments
5772 ;; TODO: Tests fail because cl-cookie depends on cl-cookie-test.
5773 `(#:tests? #f))
5774 (synopsis "HTTP cookie manager for Common Lisp")
5775 (description "cl-cookie is a Common Lisp library featuring parsing of
5776 cookie headers, cookie creation, cookie jar creation and more.")
5777 (license license:bsd-2))))
5778
5779 (define-public cl-cookie
5780 (sbcl-package->cl-source-package sbcl-cl-cookie))
5781
5782 (define-public ecl-cl-cookie
5783 (sbcl-package->ecl-package sbcl-cl-cookie))
5784
5785 (define-public sbcl-dexador
5786 (let ((commit "953090f04c4d1a9ee6632b90133cdc297b68badc")
5787 (revision "1"))
5788 (package
5789 (name "sbcl-dexador")
5790 (build-system asdf-build-system/sbcl)
5791 (version "0.9.14" )
5792 (home-page "https://github.com/fukamachi/dexador")
5793 (source
5794 (origin
5795 (method git-fetch)
5796 (uri (git-reference
5797 (url home-page)
5798 (commit commit)))
5799 (file-name (git-file-name name version))
5800 (sha256
5801 (base32
5802 "0w18fz3301rpmwc3kwb810czcd24mbf7r1z8vdyc0v5crjfpw3mn"))))
5803 (inputs
5804 `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)
5805 ("babel" ,sbcl-babel)
5806 ("usocket" ,sbcl-usocket)
5807 ("fast-http" ,sbcl-fast-http)
5808 ("quri" ,sbcl-quri)
5809 ("fast-io" ,sbcl-fast-io)
5810 ("chunga" ,sbcl-chunga)
5811 ("cl-ppcre" ,sbcl-cl-ppcre)
5812 ("cl-cookie" ,sbcl-cl-cookie)
5813 ("trivial-mimes" ,sbcl-trivial-mimes)
5814 ("chipz" ,sbcl-chipz)
5815 ("cl-base64" ,sbcl-cl-base64)
5816 ("cl-reexport" ,sbcl-cl-reexport)
5817 ("cl+ssl" ,sbcl-cl+ssl)
5818 ("bordeaux-threads" ,sbcl-bordeaux-threads)
5819 ("alexandria" ,sbcl-alexandria)))
5820 (native-inputs
5821 `(("prove" ,sbcl-prove)
5822 ("lack" ,sbcl-lack)
5823 ("clack" ,sbcl-clack)
5824 ("babel" ,sbcl-babel)
5825 ("alexandria" ,sbcl-alexandria)
5826 ("cl-ppcre" ,sbcl-cl-ppcre)
5827 ("local-time" ,sbcl-local-time)
5828 ("trivial-features" ,sbcl-trivial-features)))
5829 (arguments
5830 ;; TODO: Circular dependency: tests depend on clack-test which depends on dexador.
5831 `(#:tests? #f
5832 #:phases
5833 (modify-phases %standard-phases
5834 (add-after 'unpack 'fix-permissions
5835 (lambda _ (make-file-writable "t/data/test.gz") #t)))))
5836 (synopsis "Yet another HTTP client for Common Lisp")
5837 (description "Dexador is yet another HTTP client for Common Lisp with
5838 neat APIs and connection-pooling. It is meant to supersede Drakma.")
5839 (license license:expat))))
5840
5841 (define-public cl-dexador
5842 (package
5843 (inherit (sbcl-package->cl-source-package sbcl-dexador))
5844 (arguments
5845 `(#:phases
5846 ;; asdf-build-system/source has its own phases and does not inherit
5847 ;; from asdf-build-system/sbcl phases.
5848 (modify-phases %standard-phases/source
5849 ;; Already done in SBCL package.
5850 (delete 'reset-gzip-timestamps))))))
5851
5852 (define-public ecl-dexador
5853 (sbcl-package->ecl-package sbcl-dexador))
5854
5855 (define-public sbcl-lisp-namespace
5856 (let ((commit "28107cafe34e4c1c67490fde60c7f92dc610b2e0")
5857 (revision "1"))
5858 (package
5859 (name "sbcl-lisp-namespace")
5860 (build-system asdf-build-system/sbcl)
5861 (version (git-version "0.1" revision commit))
5862 (home-page "https://github.com/guicho271828/lisp-namespace")
5863 (source
5864 (origin
5865 (method git-fetch)
5866 (uri (git-reference
5867 (url home-page)
5868 (commit commit)))
5869 (file-name (git-file-name name version))
5870 (sha256
5871 (base32
5872 "1jw2wykp06z2afb9nm1lgfzll5cjlj36pnknjx614057zkkxq4iy"))))
5873 (inputs
5874 `(("alexandria" ,sbcl-alexandria)))
5875 (native-inputs
5876 `(("fiveam" ,sbcl-fiveam)))
5877 (arguments
5878 `(#:test-asd-file "lisp-namespace.test.asd"
5879 ;; XXX: Component LISP-NAMESPACE-ASD::LISP-NAMESPACE.TEST not found
5880 #:tests? #f))
5881 (synopsis "LISP-N, or extensible namespaces in Common Lisp")
5882 (description "Common Lisp already has major 2 namespaces, function
5883 namespace and value namespace (or variable namespace), but there are actually
5884 more — e.g., class namespace.
5885 This library offers macros to deal with symbols from any namespace.")
5886 (license license:llgpl))))
5887
5888 (define-public cl-lisp-namespace
5889 (sbcl-package->cl-source-package sbcl-lisp-namespace))
5890
5891 (define-public ecl-lisp-namespace
5892 (sbcl-package->ecl-package sbcl-lisp-namespace))
5893
5894 (define-public sbcl-trivial-cltl2
5895 (let ((commit "8a3bda30dc25d2f65fcf514d0eb6e6db75252c61")
5896 (revision "2"))
5897 (package
5898 (name "sbcl-trivial-cltl2")
5899 (build-system asdf-build-system/sbcl)
5900 (version (git-version "0.1.1" revision commit))
5901 (home-page "https://github.com/Zulu-Inuoe/trivial-cltl2")
5902 (source
5903 (origin
5904 (method git-fetch)
5905 (uri (git-reference
5906 (url home-page)
5907 (commit commit)))
5908 (file-name (git-file-name name version))
5909 (sha256
5910 (base32
5911 "08cnzb9rnczn4pn2zpf0587ny4wjy1mjndy885fz9pw7xrlx37ip"))))
5912 (synopsis "Simple CLtL2 compatibility layer for Common Lisp")
5913 (description "This library is a portable compatibility layer around
5914 \"Common Lisp the Language, 2nd
5915 Edition\" (@url{https://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node102.html})
5916 and it exports symbols from implementation-specific packages.")
5917 (license license:llgpl))))
5918
5919 (define-public cl-trivial-cltl2
5920 (sbcl-package->cl-source-package sbcl-trivial-cltl2))
5921
5922 (define-public ecl-trivial-cltl2
5923 (sbcl-package->ecl-package sbcl-trivial-cltl2))
5924
5925 (define-public sbcl-introspect-environment
5926 (let ((commit "fff42f8f8fd0d99db5ad6c5812e53de7d660020b")
5927 (revision "1"))
5928 (package
5929 (name "sbcl-introspect-environment")
5930 (build-system asdf-build-system/sbcl)
5931 (version (git-version "0.1" revision commit))
5932 (home-page "https://github.com/Bike/introspect-environment")
5933 (source
5934 (origin
5935 (method git-fetch)
5936 (uri (git-reference
5937 (url home-page)
5938 (commit commit)))
5939 (file-name (git-file-name name version))
5940 (sha256
5941 (base32
5942 "1i305n0wfmpac63ni4i3vixnnkl8daw5ncxy0k3dv92krgx6qzhp"))))
5943 (native-inputs
5944 `(("fiveam" ,sbcl-fiveam)))
5945 (synopsis "Common Lisp environment introspection portability layer")
5946 (description "This library is a small interface to portable but
5947 nonstandard introspection of Common Lisp environments. It is intended to
5948 allow a bit more compile-time introspection of environments in Common Lisp.
5949
5950 Quite a bit of information is available at the time a macro or compiler-macro
5951 runs; inlining info, type declarations, that sort of thing. This information
5952 is all standard - any Common Lisp program can @code{(declare (integer x))} and
5953 such.
5954
5955 This info ought to be accessible through the standard @code{&environment}
5956 parameters, but it is not. Several implementations keep the information for
5957 their own purposes but do not make it available to user programs, because
5958 there is no standard mechanism to do so.
5959
5960 This library uses implementation-specific hooks to make information available
5961 to users. This is currently supported on SBCL, CCL, and CMUCL. Other
5962 implementations have implementations of the functions that do as much as they
5963 can and/or provide reasonable defaults.")
5964 (license license:wtfpl2))))
5965
5966 (define-public cl-introspect-environment
5967 (sbcl-package->cl-source-package sbcl-introspect-environment))
5968
5969 (define-public ecl-introspect-environment
5970 (sbcl-package->ecl-package sbcl-introspect-environment))
5971
5972 (define-public sbcl-type-i
5973 (let ((commit "d34440ab4ebf5a46a58deccb35950b15670e3667")
5974 (revision "2"))
5975 (package
5976 (name "sbcl-type-i")
5977 (build-system asdf-build-system/sbcl)
5978 (version (git-version "0.1" revision commit))
5979 (home-page "https://github.com/guicho271828/type-i")
5980 (source
5981 (origin
5982 (method git-fetch)
5983 (uri (git-reference
5984 (url home-page)
5985 (commit commit)))
5986 (file-name (git-file-name name version))
5987 (sha256
5988 (base32
5989 "12wsga0pwjkkr176lnjwkmmlm3ccp0n310sjj9h20lk53iyd0z69"))))
5990 (inputs
5991 `(("alexandria" ,sbcl-alexandria)
5992 ("introspect-environment" ,sbcl-introspect-environment)
5993 ("trivia.trivial" ,sbcl-trivia.trivial)))
5994 (native-inputs
5995 `(("fiveam" ,sbcl-fiveam)))
5996 (arguments
5997 `(#:test-asd-file "type-i.test.asd"))
5998 (synopsis "Type inference utility on unary predicates for Common Lisp")
5999 (description "This library tries to provide a way to detect what kind of
6000 type the given predicate is trying to check. This is different from inferring
6001 the return type of a function.")
6002 (license license:llgpl))))
6003
6004 (define-public cl-type-i
6005 (sbcl-package->cl-source-package sbcl-type-i))
6006
6007 (define-public ecl-type-i
6008 (package
6009 (inherit (sbcl-package->ecl-package sbcl-type-i))
6010 (arguments
6011 ;; The tests get stuck indefinitly
6012 '(#:tests? #f))))
6013
6014 (define-public sbcl-optima
6015 (let ((commit "373b245b928c1a5cce91a6cb5bfe5dd77eb36195")
6016 (revision "1"))
6017 (package
6018 (name "sbcl-optima")
6019 (build-system asdf-build-system/sbcl)
6020 (version (git-version "1.0" revision commit))
6021 (home-page "https://github.com/m2ym/optima")
6022 (source
6023 (origin
6024 (method git-fetch)
6025 (uri (git-reference
6026 (url home-page)
6027 (commit commit)))
6028 (file-name (git-file-name name version))
6029 (sha256
6030 (base32
6031 "1yw4ymq7ms89342kkvb3aqxgv0w38m9kd8ikdqxxzyybnkjhndal"))))
6032 (inputs
6033 `(("alexandria" ,sbcl-alexandria)
6034 ("closer-mop" ,sbcl-closer-mop)))
6035 (native-inputs
6036 `(("eos" ,sbcl-eos)))
6037 (arguments
6038 ;; XXX: Circular dependencies: tests depend on optima.ppcre which depends on optima.
6039 `(#:tests? #f
6040 #:test-asd-file "optima.test.asd"))
6041 (synopsis "Optimized pattern matching library for Common Lisp")
6042 (description "Optima is a fast pattern matching library which uses
6043 optimizing techniques widely used in the functional programming world.")
6044 (license license:expat))))
6045
6046 (define-public cl-optima
6047 (sbcl-package->cl-source-package sbcl-optima))
6048
6049 (define-public ecl-optima
6050 (sbcl-package->ecl-package sbcl-optima))
6051
6052 (define-public sbcl-fare-quasiquote
6053 (let ((commit "640d39a0451094071b3e093c97667b3947f43639")
6054 (revision "1"))
6055 (package
6056 (name "sbcl-fare-quasiquote")
6057 (build-system asdf-build-system/sbcl)
6058 (version (git-version "1.0.1" revision commit))
6059 (home-page "https://gitlab.common-lisp.net/frideau/fare-quasiquote")
6060 (source
6061 (origin
6062 (method git-fetch)
6063 (uri (git-reference
6064 (url (string-append "https://gitlab.common-lisp.net/frideau/"
6065 "fare-quasiquote.git"))
6066 (commit commit)))
6067 (file-name (git-file-name name version))
6068 (sha256
6069 (base32 "1g6q11l50kgija9f55lzqpcwvaq0ljiw8v1j265hnyg6nahjwjvg"))))
6070 (inputs
6071 `(("fare-utils" ,sbcl-fare-utils)
6072 ("named-readtables" ,sbcl-named-readtables)
6073 ("optima" ,sbcl-optima)))
6074 (arguments
6075 ;; XXX: Circular dependencies: Tests depend on subsystems,
6076 ;; which depend on the main systems.
6077 `(#:tests? #f
6078 #:asd-systems '("fare-quasiquote"
6079 "fare-quasiquote-extras")
6080 #:phases
6081 (modify-phases %standard-phases
6082 ;; XXX: Require 1.0.0 version of fare-utils, and we package some
6083 ;; commits after 1.0.0.5, but ASDF fails to read the
6084 ;; "-REVISION-COMMIT" part generated by Guix.
6085 (add-after 'unpack 'patch-requirement
6086 (lambda _
6087 (substitute* "fare-quasiquote.asd"
6088 (("\\(:version \"fare-utils\" \"1.0.0\"\\)")
6089 "\"fare-utils\""))
6090 (substitute* "fare-quasiquote-optima.asd"
6091 (("\\(:version \"optima\" \"1\\.0\"\\)")
6092 "\"optima\""))
6093 #t)))))
6094 (synopsis "Pattern-matching friendly implementation of quasiquote")
6095 (description "The main purpose of this n+2nd reimplementation of
6096 quasiquote is enable matching of quasiquoted patterns, using Optima or
6097 Trivia.")
6098 (license license:expat))))
6099
6100 (define-public cl-fare-quasiquote
6101 (sbcl-package->cl-source-package sbcl-fare-quasiquote))
6102
6103 (define-public ecl-fare-quasiquote
6104 (sbcl-package->ecl-package sbcl-fare-quasiquote))
6105
6106 ;;; Split the trivia package in two to work around the circular dependency
6107 ;;; between guicho271828/trivia and guicho271828/type-i.
6108 (define-public sbcl-trivia.trivial
6109 (let ((commit "7286d5d2a4f685f1cac8370816f95276c0851111")
6110 (revision "3"))
6111 (package
6112 (name "sbcl-trivia.trivial")
6113 (version (git-version "0.0.0" revision commit))
6114 (source
6115 (origin
6116 (method git-fetch)
6117 (uri (git-reference
6118 (url "https://github.com/guicho271828/trivia")
6119 (commit commit)))
6120 (file-name (git-file-name "trivia" version))
6121 (sha256
6122 (base32
6123 "0ln0sj3jry7kzbmxhnin66kpbqan1wp8wwgdbw4k29afbdblkcca"))))
6124 (build-system asdf-build-system/sbcl)
6125 (inputs
6126 `(("alexandria" ,sbcl-alexandria)
6127 ("closer-mop" ,sbcl-closer-mop)
6128 ("lisp-namespace" ,sbcl-lisp-namespace)
6129 ("trivial-cltl2" ,sbcl-trivial-cltl2)))
6130 (arguments
6131 '(#:phases
6132 (modify-phases %standard-phases
6133 (add-after 'unpack 'fix-build
6134 (lambda _
6135 (for-each delete-file
6136 '("trivia.balland2006.asd"
6137 "trivia.ppcre.asd"
6138 "trivia.quasiquote.asd"
6139 "trivia.cffi.asd"
6140 "trivia.asd"
6141 "trivia.test.asd"))
6142 #t)))))
6143 (synopsis "Pattern matching in Common Lisp")
6144 (description "Trivia is a pattern matching compiler that is compatible
6145 with Optima, another pattern matching library for Common Lisp. It is meant to
6146 be faster and more extensible than Optima.")
6147 (home-page "https://github.com/guicho271828/trivia")
6148 (license license:llgpl))))
6149
6150 (define-public cl-trivia.trivial
6151 (sbcl-package->cl-source-package sbcl-trivia.trivial))
6152
6153 (define-public ecl-trivia.trivial
6154 (sbcl-package->ecl-package sbcl-trivia.trivial))
6155
6156 (define-public sbcl-trivia
6157 (package
6158 (inherit sbcl-trivia.trivial)
6159 (name "sbcl-trivia")
6160 (native-inputs
6161 `(("fiveam" ,sbcl-fiveam)
6162 ("optima" ,sbcl-optima)))
6163 (inputs
6164 `(("alexandria" ,sbcl-alexandria)
6165 ("cffi" ,sbcl-cffi)
6166 ("cl-ppcre" ,sbcl-cl-ppcre)
6167 ("fare-quasiquote" ,sbcl-fare-quasiquote)
6168 ("iterate" ,sbcl-iterate)
6169 ("trivia.trivial" ,sbcl-trivia.trivial)
6170 ("type-i" ,sbcl-type-i)))
6171 (arguments
6172 '(#:asd-systems '("trivia"
6173 "trivia.ppcre"
6174 "trivia.quasiquote"
6175 "trivia.cffi")
6176 #:test-asd-file "trivia.test.asd"
6177 #:phases
6178 (modify-phases %standard-phases
6179 (add-after 'unpack 'fix-build
6180 (lambda _
6181 (for-each delete-file
6182 '("trivia.level0.asd"
6183 "trivia.level1.asd"
6184 "trivia.level2.asd"
6185 "trivia.trivial.asd"))
6186 #t)))))))
6187
6188 (define-public cl-trivia
6189 (sbcl-package->cl-source-package sbcl-trivia))
6190
6191 (define-public ecl-trivia
6192 (sbcl-package->ecl-package sbcl-trivia))
6193
6194 (define-public sbcl-mk-string-metrics
6195 (package
6196 (name "sbcl-mk-string-metrics")
6197 (version "0.1.2")
6198 (home-page "https://github.com/cbaggers/mk-string-metrics/")
6199 (source (origin
6200 (method git-fetch)
6201 (uri (git-reference
6202 (url home-page)
6203 (commit version)))
6204 (sha256
6205 (base32 "0bg0bv2mfd4k0g3x72x563hvmrx18xavaffr6xk5rh4if5j7kcf6"))
6206 (file-name (git-file-name name version))))
6207 (build-system asdf-build-system/sbcl)
6208 (synopsis "Calculate various string metrics efficiently in Common Lisp")
6209 (description "This library implements efficient algorithms that calculate
6210 various string metrics in Common Lisp:
6211
6212 @itemize
6213 @item Damerau-Levenshtein distance
6214 @item Hamming distance
6215 @item Jaccard similarity coefficient
6216 @item Jaro distance
6217 @item Jaro-Winkler distance
6218 @item Levenshtein distance
6219 @item Normalized Damerau-Levenshtein distance
6220 @item Normalized Levenshtein distance
6221 @item Overlap coefficient
6222 @end itemize\n")
6223 (license license:x11)))
6224
6225 (define-public cl-mk-string-metrics
6226 (sbcl-package->cl-source-package sbcl-mk-string-metrics))
6227
6228 (define-public ecl-mk-string-metrics
6229 (sbcl-package->ecl-package sbcl-mk-string-metrics))
6230
6231 (define-public sbcl-cl-str
6232 (package
6233 (name "sbcl-cl-str")
6234 (version "0.19")
6235 (home-page "https://github.com/vindarel/cl-str")
6236 (source (origin
6237 (method git-fetch)
6238 (uri (git-reference
6239 (url home-page)
6240 (commit version)))
6241 (sha256
6242 (base32 "1jyza2jhn7w6fl4w87pv0m87z5ia48m6dqw12k0mdh7l3mgjq839"))
6243 (file-name (git-file-name name version))))
6244 (build-system asdf-build-system/sbcl)
6245 (inputs
6246 `(("cl-ppcre" ,sbcl-cl-ppcre)
6247 ("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)
6248 ("cl-change-case" ,sbcl-cl-change-case)))
6249 (native-inputs
6250 `(("prove" ,sbcl-prove)))
6251 (arguments
6252 `(#:asd-systems '("str")
6253 #:test-asd-file "str.test.asd"))
6254 (synopsis "Modern, consistent and terse Common Lisp string manipulation library")
6255 (description "A modern and consistent Common Lisp string manipulation
6256 library that focuses on modernity, simplicity and discoverability:
6257 @code{(str:trim s)} instead of @code{(string-trim '(#\\Space ...) s)}), or
6258 @code{str:concat strings} instead of an unusual format construct; one
6259 discoverable library instead of many; consistency and composability, where
6260 @code{s} is always the last argument, which makes it easier to feed pipes and
6261 arrows.")
6262 (license license:expat)))
6263
6264 (define-public cl-str
6265 (sbcl-package->cl-source-package sbcl-cl-str))
6266
6267 (define-public ecl-cl-str
6268 (sbcl-package->ecl-package sbcl-cl-str))
6269
6270 (define-public sbcl-cl-xmlspam
6271 (let ((commit "ea06abcca2a73a9779bcfb09081e56665f94e22a"))
6272 (package
6273 (name "sbcl-cl-xmlspam")
6274 (build-system asdf-build-system/sbcl)
6275 (version (git-version "0.0.0" "1" commit))
6276 (home-page "https://github.com/rogpeppe/cl-xmlspam")
6277 (source
6278 (origin
6279 (method git-fetch)
6280 (uri (git-reference
6281 (url home-page)
6282 (commit commit)))
6283 (file-name (string-append name "-" version))
6284 (sha256
6285 (base32
6286 "0w4rqvrgdgk3fwfq3kx4r7wwdr2bv3b6n3bdqwsiriw9psqzpz2s"))))
6287 (inputs
6288 `(("cxml" ,sbcl-cxml)
6289 ("cl-ppcre" ,sbcl-cl-ppcre)))
6290 (synopsis "Concise, regexp-like pattern matching on streaming XML for Common Lisp")
6291 (description "CXML does an excellent job at parsing XML elements, but what
6292 do you do when you have a XML file that's larger than you want to fit in
6293 memory, and you want to extract some information from it? Writing code to deal
6294 with SAX events, or even using Klacks, quickly becomes tedious.
6295 @code{cl-xmlspam} (for XML Stream PAttern Matcher) is designed to make it easy
6296 to write code that mirrors the structure of the XML that it's parsing. It
6297 also makes it easy to shift paradigms when necessary - the usual Lisp control
6298 constructs can be used interchangeably with pattern matching, and the full
6299 power of CXML is available when necessary.")
6300 (license license:bsd-3))))
6301
6302 (define-public cl-xmlspam
6303 (sbcl-package->cl-source-package sbcl-cl-xmlspam))
6304
6305 (define-public ecl-cl-xmlspam
6306 (sbcl-package->ecl-package sbcl-cl-xmlspam))
6307
6308 (define-public sbcl-dbus
6309 (let ((commit "24b452df3a45ca5dc95015500f34baad175c981a")
6310 (revision "1"))
6311 (package
6312 (name "sbcl-dbus")
6313 (version (git-version "20190408" revision commit))
6314 (home-page "https://github.com/death/dbus")
6315 (source
6316 (origin
6317 (method git-fetch)
6318 (uri (git-reference
6319 (url home-page)
6320 (commit commit)))
6321 (file-name (git-file-name name version))
6322 (sha256
6323 (base32
6324 "0fw2q866yddbf23nk9pxphm9gsasx35vjyss82xzvndnjmzlqfl5"))))
6325 (build-system asdf-build-system/sbcl)
6326 (inputs
6327 `(("alexandria" ,sbcl-alexandria)
6328 ("trivial-garbage" ,sbcl-trivial-garbage)
6329 ("babel" ,sbcl-babel)
6330 ("iolib" ,sbcl-iolib)
6331 ("ieee-floats" ,sbcl-ieee-floats)
6332 ("flexi-streams" ,sbcl-flexi-streams)
6333 ("cl-xmlspam" ,sbcl-cl-xmlspam)
6334 ("ironclad" ,sbcl-ironclad)))
6335 (synopsis "D-Bus client library for Common Lisp")
6336 (description "This is a Common Lisp library that publishes D-Bus
6337 objects as well as send and notify other objects connected to a bus.")
6338 (license license:bsd-2))))
6339
6340 (define-public cl-dbus
6341 (sbcl-package->cl-source-package sbcl-dbus))
6342
6343 (define-public ecl-dbus
6344 (sbcl-package->ecl-package sbcl-dbus))
6345
6346 (define-public sbcl-cl-hooks
6347 (let ((commit "5b638083f3b4f1221a52631d9c8a0a265565cac7")
6348 (revision "1"))
6349 (package
6350 (name "sbcl-cl-hooks")
6351 (build-system asdf-build-system/sbcl)
6352 (version (git-version "0.2.1" revision commit))
6353 (home-page "https://github.com/scymtym/architecture.hooks")
6354 (source
6355 (origin
6356 (method git-fetch)
6357 (uri (git-reference
6358 (url home-page)
6359 (commit commit)))
6360 (file-name (git-file-name name version))
6361 (sha256
6362 (base32
6363 "0bg3l0a28lw5gqqjp6p6b5nhwqk46sgkb7184w5qbfngw1hk8x9y"))))
6364 (inputs
6365 `(("alexandria" ,sbcl-alexandria)
6366 ("let-plus" ,sbcl-let-plus)
6367 ("trivial-garbage" ,sbcl-trivial-garbage)
6368 ("closer-mop" ,sbcl-closer-mop)))
6369 (native-inputs
6370 `(("fiveam" ,sbcl-fiveam)))
6371 (synopsis "Hooks extension point mechanism (as in Emacs) for Common Lisp")
6372 (description "A hook, in the present context, is a certain kind of
6373 extension point in a program that allows interleaving the execution of
6374 arbitrary code with the execution of a the program without introducing any
6375 coupling between the two. Hooks are used extensively in the extensible editor
6376 Emacs.
6377
6378 In the Common LISP Object System (CLOS), a similar kind of extensibility is
6379 possible using the flexible multi-method dispatch mechanism. It may even seem
6380 that the concept of hooks does not provide any benefits over the possibilities
6381 of CLOS. However, there are some differences:
6382
6383 @itemize
6384
6385 @item There can be only one method for each combination of specializers and
6386 qualifiers. As a result this kind of extension point cannot be used by
6387 multiple extensions independently.
6388 @item Removing code previously attached via a @code{:before}, @code{:after} or
6389 @code{:around} method can be cumbersome.
6390 @item There could be other or even multiple extension points besides @code{:before}
6391 and @code{:after} in a single method.
6392 @item Attaching codes to individual objects using eql specializers can be
6393 cumbersome.
6394 @item Introspection of code attached a particular extension point is
6395 cumbersome since this requires enumerating and inspecting the methods of a
6396 generic function.
6397 @end itemize
6398
6399 This library tries to complement some of these weaknesses of method-based
6400 extension-points via the concept of hooks.")
6401 (license license:llgpl))))
6402
6403 (define-public cl-hooks
6404 (sbcl-package->cl-source-package sbcl-cl-hooks))
6405
6406 (define-public ecl-cl-hooks
6407 (sbcl-package->ecl-package sbcl-cl-hooks))
6408
6409 (define-public sbcl-cl-autowrap
6410 (let ((revision "1")
6411 (commit "ae846d6968fc0d000de0c541638929a157f3009e"))
6412 ;; no taged branches
6413 (package
6414 (name "sbcl-cl-autowrap")
6415 (version (git-version "1.0" revision commit))
6416 (source
6417 (origin
6418 (method git-fetch)
6419 (uri (git-reference
6420 (url "https://github.com/rpav/cl-autowrap")
6421 (commit commit)))
6422 (file-name (git-file-name name version))
6423 (sha256
6424 (base32 "1gisldp2zns92kdcaikghm7c38ldy2d884n8bfg0wcjvbz78p3ar"))))
6425 (build-system asdf-build-system/sbcl)
6426 (inputs
6427 `(("alexandria" ,sbcl-alexandria)
6428 ("cffi" ,sbcl-cffi)
6429 ("cl-json" ,sbcl-cl-json)
6430 ("cl-ppcre" ,sbcl-cl-ppcre)
6431 ("defpackage-plus" ,sbcl-defpackage-plus)
6432 ("trivial-features" ,sbcl-trivial-features)))
6433 (home-page "https://github.com/rpav/cl-autowrap")
6434 (synopsis "FFI wrapper generator for Common Lisp")
6435 (description "This is a c2ffi-based wrapper generator for Common Lisp.")
6436 (license license:bsd-2))))
6437
6438 (define-public cl-autowrap
6439 (sbcl-package->cl-source-package sbcl-cl-autowrap))
6440
6441 (define-public ecl-cl-autowrap
6442 (sbcl-package->ecl-package sbcl-cl-autowrap))
6443
6444 (define-public sbcl-s-sysdeps
6445 ;; No release since 2013.
6446 (let ((commit "9aa23bbdceb24bcdbe0e7c39fa1901858f823106")
6447 (revision "2"))
6448 (package
6449 (name "sbcl-s-sysdeps")
6450 (build-system asdf-build-system/sbcl)
6451 (version (git-version "1" revision commit))
6452 (home-page "https://github.com/svenvc/s-sysdeps")
6453 (source
6454 (origin
6455 (method git-fetch)
6456 (uri (git-reference
6457 (url home-page)
6458 (commit commit)))
6459 (file-name (git-file-name name version))
6460 (sha256
6461 (base32
6462 "1fh8r7kf8s3hvqdg6b71b8p7w3v2kkga9bw8j3qqdxhzr6anpm0b"))))
6463 (inputs
6464 `(("bordeaux-threads" ,sbcl-bordeaux-threads)
6465 ("usocket" ,sbcl-usocket)))
6466 (synopsis "Common Lisp abstraction layer over platform dependent functionality")
6467 (description "@code{s-sysdeps} is an abstraction layer over platform
6468 dependent functionality. This simple package is used as a building block in a
6469 number of other open source projects.
6470
6471 @code{s-sysdeps} abstracts:
6472
6473 @itemize
6474 @item managing processes,
6475 @item implementing a standard TCP/IP server,
6476 @item opening a client TCP/IP socket stream,
6477 @item working with process locks.
6478 @end itemize\n")
6479 (license license:llgpl))))
6480
6481 (define-public cl-s-sysdeps
6482 (sbcl-package->cl-source-package sbcl-s-sysdeps))
6483
6484 (define-public ecl-s-sysdeps
6485 (sbcl-package->ecl-package sbcl-s-sysdeps))
6486
6487 (define-public sbcl-cl-prevalence
6488 (let ((commit "5a76be036092ed6c18cb695a9e03bce87e21b840")
6489 (revision "4"))
6490 (package
6491 (name "sbcl-cl-prevalence")
6492 (build-system asdf-build-system/sbcl)
6493 (version (git-version "5" revision commit))
6494 (home-page "https://github.com/40ants/cl-prevalence")
6495 (source
6496 (origin
6497 (method git-fetch)
6498 (uri (git-reference
6499 (url home-page)
6500 (commit commit)))
6501 (file-name (git-file-name name version))
6502 (sha256
6503 (base32
6504 "050h6hwv8f16b5v6fzba8zmih92hgaaq27i2x9wv1iib41gbia3r"))))
6505 (inputs
6506 `(("s-sysdeps" ,sbcl-s-sysdeps)
6507 ("s-xml" ,sbcl-s-xml)))
6508 (native-inputs
6509 `(("fiveam" ,sbcl-fiveam)))
6510 (synopsis "Implementation of object prevalence for Common Lisp")
6511 (description "This Common Lisp library implements object prevalence (see
6512 @url{https://en.wikipedia.org/wiki/System_prevalence}). It allows
6513 for (de)serializing to and from s-exps as well as XML. Serialization of arbitrary
6514 classes and cyclic data structures are supported.")
6515 (license license:llgpl))))
6516
6517 (define-public cl-prevalence
6518 (sbcl-package->cl-source-package sbcl-cl-prevalence))
6519
6520 (define-public ecl-cl-prevalence
6521 (sbcl-package->ecl-package sbcl-cl-prevalence))
6522
6523 (define-public sbcl-series
6524 (let ((commit "da9061b336119d1e5214aff9117171d494d5a58a")
6525 (revision "1"))
6526 (package
6527 (name "sbcl-series")
6528 (version (git-version "2.2.11" revision commit))
6529 (source
6530 (origin
6531 (method git-fetch)
6532 (uri (git-reference
6533 (url "git://git.code.sf.net/p/series/series")
6534 (commit commit)))
6535 (file-name (git-file-name name version))
6536 (sha256
6537 (base32
6538 "07hk2lhfx42zk018pxqvn4gs77vd4n4g8m4xxbqaxgca76mifwfw"))))
6539 (build-system asdf-build-system/sbcl)
6540 (arguments
6541 ;; Disable the tests, they are apparently buggy and I didn't find
6542 ;; a simple way to make them run and pass.
6543 '(#:tests? #f))
6544 (synopsis "Series data structure for Common Lisp")
6545 (description
6546 "This Common Lisp library provides a series data structure much like
6547 a sequence, with similar kinds of operations. The difference is that in many
6548 situations, operations on series may be composed functionally and yet execute
6549 iteratively, without the need to construct intermediate series values
6550 explicitly. In this manner, series provide both the clarity of a functional
6551 programming style and the efficiency of an iterative programming style.")
6552 (home-page "http://series.sourceforge.net/")
6553 (license license:expat))))
6554
6555 (define-public cl-series
6556 (sbcl-package->cl-source-package sbcl-series))
6557
6558 (define-public ecl-series
6559 (sbcl-package->ecl-package sbcl-series))
6560
6561 (define-public sbcl-periods
6562 (let ((commit "60383dcef88a1ac11f82804ae7a33c361dcd2949")
6563 (revision "2"))
6564 (package
6565 (name "sbcl-periods")
6566 (version (git-version "0.0.2" revision commit))
6567 (source
6568 (origin
6569 (method git-fetch)
6570 (uri (git-reference
6571 (url "https://github.com/jwiegley/periods")
6572 (commit commit)))
6573 (file-name (git-file-name name version))
6574 (sha256
6575 (base32
6576 "1ym2j4an9ig2hl210jg91gpf7xfnp6mlhkw3n9kkdnwiji3ipqlk"))))
6577 (build-system asdf-build-system/sbcl)
6578 (inputs
6579 `(("local-time" ,sbcl-local-time)
6580 ("series" ,sbcl-series)))
6581 (arguments
6582 '(#:asd-systems '("periods"
6583 "periods-series")))
6584 (synopsis "Common Lisp library for manipulating date/time objects")
6585 (description
6586 "Periods is a Common Lisp library providing a set of utilities for
6587 manipulating times, distances between times, and both contiguous and
6588 discontiguous ranges of time.")
6589 (home-page "https://github.com/jwiegley/periods")
6590 (license license:bsd-3))))
6591
6592 (define-public cl-periods
6593 (sbcl-package->cl-source-package sbcl-periods))
6594
6595 (define-public ecl-periods
6596 (sbcl-package->ecl-package sbcl-periods))
6597
6598 (define-public sbcl-metatilities-base
6599 (let ((commit "6eaa9e3ff0939a93a92109dd0fcd218de85417d5")
6600 (revision "1"))
6601 (package
6602 (name "sbcl-metatilities-base")
6603 (version (git-version "0.6.6" revision commit))
6604 (source
6605 (origin
6606 (method git-fetch)
6607 (uri (git-reference
6608 (url "https://github.com/gwkkwg/metatilities-base")
6609 (commit commit)))
6610 (file-name (git-file-name name version))
6611 (sha256
6612 (base32
6613 "0xpa86pdzlnf4v5g64j3ifaplx71sx2ha8b7vvakswi652679ma0"))))
6614 (build-system asdf-build-system/sbcl)
6615 (native-inputs
6616 `(("lift" ,sbcl-lift)))
6617 (synopsis "Core of the metatilities Common Lisp library")
6618 (description
6619 "Metatilities-base is the core of the metatilities Common Lisp library
6620 which implements a set of utilities.")
6621 (home-page "https://common-lisp.net/project/metatilities-base/")
6622 (license license:expat))))
6623
6624 (define-public cl-metatilities-base
6625 (sbcl-package->cl-source-package sbcl-metatilities-base))
6626
6627 (define-public ecl-metatilities-base
6628 (sbcl-package->ecl-package sbcl-metatilities-base))
6629
6630 (define-public sbcl-cl-containers
6631 (let ((commit "3d1df53c22403121bffb5d553cf7acb1503850e7")
6632 (revision "3"))
6633 (package
6634 (name "sbcl-cl-containers")
6635 (version (git-version "0.12.1" revision commit))
6636 (source
6637 (origin
6638 (method git-fetch)
6639 (uri (git-reference
6640 (url "https://github.com/gwkkwg/cl-containers")
6641 (commit commit)))
6642 (file-name (git-file-name name version))
6643 (sha256
6644 (base32
6645 "18s6jfq11n8nv9k4biz32pm1s7y9zl054ry1gmdbcf39nisy377y"))))
6646 (build-system asdf-build-system/sbcl)
6647 (native-inputs
6648 `(("lift" ,sbcl-lift)))
6649 (inputs
6650 `(("metatilities-base" ,sbcl-metatilities-base)))
6651 (arguments
6652 '(#:asd-files '("cl-containers.asd")
6653 #:phases
6654 (modify-phases %standard-phases
6655 (add-after 'unpack 'relax-version-checks
6656 (lambda _
6657 (substitute* "cl-containers.asd"
6658 (("\\(:version \"metatilities-base\" \"0\\.6\\.6\"\\)")
6659 "\"metatilities-base\""))
6660 (substitute* "cl-containers-test.asd"
6661 (("\\(:version \"lift\" \"1\\.7\\.0\"\\)")
6662 "\"lift\""))
6663 #t)))))
6664 (synopsis "Container library for Common Lisp")
6665 (description
6666 "Common Lisp ships with a set of powerful built in data structures
6667 including the venerable list, full featured arrays, and hash-tables.
6668 CL-containers enhances and builds on these structures by adding containers
6669 that are not available in native Lisp (for example: binary search trees,
6670 red-black trees, sparse arrays and so on), and by providing a standard
6671 interface so that they are simpler to use and so that changing design
6672 decisions becomes significantly easier.")
6673 (home-page "https://common-lisp.net/project/cl-containers/")
6674 (license license:expat))))
6675
6676 (define-public cl-containers
6677 (sbcl-package->cl-source-package sbcl-cl-containers))
6678
6679 (define-public ecl-cl-containers
6680 (sbcl-package->ecl-package sbcl-cl-containers))
6681
6682 (define-public sbcl-xlunit
6683 (let ((commit "3805d34b1d8dc77f7e0ee527a2490194292dd0fc")
6684 (revision "1"))
6685 (package
6686 (name "sbcl-xlunit")
6687 (version (git-version "0.6.3" revision commit))
6688 (source
6689 (origin
6690 (method git-fetch)
6691 (uri (git-reference
6692 (url "http://git.kpe.io/xlunit.git")
6693 (commit commit)))
6694 (file-name (git-file-name name version))
6695 (sha256
6696 (base32
6697 "0argfmp9nghs4sihyj3f8ch9qfib2b7ll07v5m9ziajgzsfl5xw3"))))
6698 (build-system asdf-build-system/sbcl)
6699 (arguments
6700 '(#:phases
6701 (modify-phases %standard-phases
6702 (add-after 'unpack 'fix-tests
6703 (lambda _
6704 (substitute* "xlunit.asd"
6705 ((" :force t") ""))
6706 #t)))))
6707 (synopsis "Unit testing package for Common Lisp")
6708 (description
6709 "The XLUnit package is a toolkit for building test suites. It is based
6710 on the XPTest package by Craig Brozensky and the JUnit package by Kent Beck.")
6711 (home-page "http://quickdocs.org/xlunit/")
6712 (license license:bsd-3))))
6713
6714 (define-public cl-xlunit
6715 (sbcl-package->cl-source-package sbcl-xlunit))
6716
6717 (define-public ecl-xlunit
6718 (sbcl-package->ecl-package sbcl-xlunit))
6719
6720 (define-public sbcl-cambl
6721 (let ((commit "7016d1a98215f82605d1c158e7a16504ca1f4636")
6722 (revision "1"))
6723 (package
6724 (name "sbcl-cambl")
6725 (version (git-version "4.0.0" revision commit))
6726 (source
6727 (origin
6728 (method git-fetch)
6729 (uri (git-reference
6730 (url "https://github.com/jwiegley/cambl")
6731 (commit commit)))
6732 (file-name (git-file-name "cambl" version))
6733 (sha256
6734 (base32 "103mry04j2k9vznsxm7wcvccgxkil92cdrv52miwcmxl8daa4jiz"))))
6735 (build-system asdf-build-system/sbcl)
6736 (native-inputs
6737 `(("xlunit" ,sbcl-xlunit)))
6738 (inputs
6739 `(("alexandria" ,sbcl-alexandria)
6740 ("cl-containers" ,sbcl-cl-containers)
6741 ("local-time" ,sbcl-local-time)
6742 ("periods" ,sbcl-periods)))
6743 (arguments
6744 '(#:asd-files '("fprog.asd"
6745 "cambl.asd")))
6746 (synopsis "Commoditized amounts and balances for Common Lisp")
6747 (description
6748 "CAMBL is a Common Lisp library providing a convenient facility for
6749 working with commoditized values. It does not allow compound units (and so is
6750 not suited for scientific operations) but does work rather nicely for the
6751 purpose of financial calculations.")
6752 (home-page "https://github.com/jwiegley/cambl")
6753 (license license:bsd-3))))
6754
6755 (define-public cl-cambl
6756 (sbcl-package->cl-source-package sbcl-cambl))
6757
6758 (define-public ecl-cambl
6759 (sbcl-package->ecl-package sbcl-cambl))
6760
6761 (define-public sbcl-cl-ledger
6762 (let ((commit "08e0be41795e804cd36142e51756ad0b1caa377b")
6763 (revision "1"))
6764 (package
6765 (name "sbcl-cl-ledger")
6766 (version (git-version "4.0.0" revision commit))
6767 (source
6768 (origin
6769 (method git-fetch)
6770 (uri (git-reference
6771 (url "https://github.com/ledger/cl-ledger")
6772 (commit commit)))
6773 (file-name (git-file-name name version))
6774 (sha256
6775 (base32
6776 "1via0qf6wjcyxnfbmfxjvms0ik9j8rqbifgpmnhrzvkhrq9pv8h1"))))
6777 (build-system asdf-build-system/sbcl)
6778 (inputs
6779 `(("cambl" ,sbcl-cambl)
6780 ("cl-ppcre" ,sbcl-cl-ppcre)
6781 ("local-time" ,sbcl-local-time)
6782 ("periods" ,sbcl-periods)))
6783 (arguments
6784 '(#:phases
6785 (modify-phases %standard-phases
6786 (add-after 'unpack 'fix-system-definition
6787 (lambda _
6788 (substitute* "cl-ledger.asd"
6789 ((" :build-operation program-op") "")
6790 ((" :build-pathname \"cl-ledger\"") "")
6791 ((" :entry-point \"ledger::main\"") ""))
6792 #t)))))
6793 (synopsis "Common Lisp port of the Ledger accounting system")
6794 (description
6795 "CL-Ledger is a Common Lisp port of the Ledger double-entry accounting
6796 system.")
6797 (home-page "https://github.com/ledger/cl-ledger")
6798 (license license:bsd-3))))
6799
6800 (define-public cl-ledger
6801 (sbcl-package->cl-source-package sbcl-cl-ledger))
6802
6803 (define-public ecl-cl-ledger
6804 (sbcl-package->ecl-package sbcl-cl-ledger))
6805
6806 (define-public sbcl-bst
6807 (let ((commit "8545aed0d504df2829ad139566feeabe22305388")
6808 (revision "0"))
6809 (package
6810 (name "sbcl-bst")
6811 (version (git-version "2.0" revision commit))
6812 (source
6813 (origin
6814 (method git-fetch)
6815 (uri (git-reference
6816 (url "https://github.com/glv2/bst")
6817 (commit commit)))
6818 (file-name (git-file-name name version))
6819 (sha256
6820 (base32 "18ig7rvxcra69437g0i8sxyv7c5dg26jqnx1rc2f9pxmihdprgk8"))))
6821 (build-system asdf-build-system/sbcl)
6822 (native-inputs
6823 `(("alexandria" ,sbcl-alexandria)
6824 ("fiveam" ,sbcl-fiveam)))
6825 (synopsis "Binary search tree for Common Lisp")
6826 (description
6827 "BST is a Common Lisp library for working with binary search trees that
6828 can contain any kind of values.")
6829 (home-page "https://github.com/glv2/bst")
6830 (license license:gpl3))))
6831
6832 (define-public cl-bst
6833 (sbcl-package->cl-source-package sbcl-bst))
6834
6835 (define-public ecl-bst
6836 (sbcl-package->ecl-package sbcl-bst))
6837
6838 (define-public sbcl-cl-octet-streams
6839 (package
6840 (name "sbcl-cl-octet-streams")
6841 (version "1.2")
6842 (source
6843 (origin
6844 (method git-fetch)
6845 (uri (git-reference
6846 (url "https://github.com/glv2/cl-octet-streams")
6847 (commit (string-append "v" version))))
6848 (file-name (git-file-name name version))
6849 (sha256
6850 (base32 "1hffh98bv4w5yrchagzwqrc43d2p473pvw7ka4kyyvhrr52dk2f8"))))
6851 (build-system asdf-build-system/sbcl)
6852 (native-inputs
6853 `(("fiveam" ,sbcl-fiveam)))
6854 (inputs
6855 `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
6856 (synopsis "In-memory octet streams for Common Lisp")
6857 (description
6858 "CL-octet-streams is a library implementing in-memory octet
6859 streams for Common Lisp. It was inspired by the trivial-octet-streams and
6860 cl-plumbing libraries.")
6861 (home-page "https://github.com/glv2/cl-octet-streams")
6862 (license license:gpl3+)))
6863
6864 (define-public cl-octet-streams
6865 (sbcl-package->cl-source-package sbcl-cl-octet-streams))
6866
6867 (define-public ecl-cl-octet-streams
6868 (sbcl-package->ecl-package sbcl-cl-octet-streams))
6869
6870 (define-public sbcl-lzlib
6871 (let ((commit "cad10f5becbcfebb44b9d311a257563778803452")
6872 (revision "2"))
6873 (package
6874 (name "sbcl-lzlib")
6875 (version (git-version "1.1" revision commit))
6876 (source
6877 (origin
6878 (method git-fetch)
6879 (uri (git-reference
6880 (url "https://github.com/glv2/cl-lzlib")
6881 (commit commit)))
6882 (file-name (git-file-name name version))
6883 (sha256
6884 (base32 "09lp7li35h4jkls0448fj1sh6pjslr1w7ranbc4szjr8g0c2bdry"))))
6885 (build-system asdf-build-system/sbcl)
6886 (native-inputs
6887 `(("fiveam" ,sbcl-fiveam)))
6888 (inputs
6889 `(("cffi" ,sbcl-cffi)
6890 ("cl-octet-streams" ,sbcl-cl-octet-streams)
6891 ("lparallel" ,sbcl-lparallel)
6892 ("lzlib" ,lzlib)))
6893 (arguments
6894 '(#:phases
6895 (modify-phases %standard-phases
6896 (add-after 'unpack 'fix-paths
6897 (lambda* (#:key inputs #:allow-other-keys)
6898 (substitute* "src/lzlib.lisp"
6899 (("liblz\\.so")
6900 (string-append (assoc-ref inputs "lzlib") "/lib/liblz.so")))
6901 #t)))))
6902 (synopsis "Common Lisp library for lzip (de)compression")
6903 (description
6904 "This Common Lisp library provides functions for lzip (LZMA)
6905 compression/decompression using bindings to the lzlib C library.")
6906 (home-page "https://github.com/glv2/cl-lzlib")
6907 (license license:gpl3+))))
6908
6909 (define-public cl-lzlib
6910 (sbcl-package->cl-source-package sbcl-lzlib))
6911
6912 (define-public ecl-lzlib
6913 (sbcl-package->ecl-package sbcl-lzlib))
6914
6915 (define-public sbcl-chanl
6916 (let ((commit "56e90a126c78b39bb621a01585e8d3b985238e8c")
6917 (revision "1"))
6918 (package
6919 (name "sbcl-chanl")
6920 (version (git-version "0.4.1" revision commit))
6921 (source
6922 (origin
6923 (method git-fetch)
6924 (uri (git-reference
6925 (url "https://github.com/zkat/chanl")
6926 (commit commit)))
6927 (file-name (git-file-name name version))
6928 (sha256
6929 (base32
6930 "0b1cf6c12qx5cy1fw2z42jgh566rp3l8nv5qf0qqc569s7bgmrh4"))))
6931 (build-system asdf-build-system/sbcl)
6932 (native-inputs
6933 `(("fiveam" ,sbcl-fiveam)))
6934 (inputs
6935 `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
6936 (synopsis "Portable channel-based concurrency for Common Lisp")
6937 (description "Common Lisp library for channel-based concurrency. In
6938 a nutshell, you create various threads sequentially executing tasks you need
6939 done, and use channel objects to communicate and synchronize the state of these
6940 threads.")
6941 (home-page "https://github.com/zkat/chanl")
6942 (license (list license:expat license:bsd-3)))))
6943
6944 (define-public cl-chanl
6945 (sbcl-package->cl-source-package sbcl-chanl))
6946
6947 (define-public ecl-chanl
6948 (sbcl-package->ecl-package sbcl-chanl))
6949
6950 (define-public sbcl-cl-store
6951 (let ((commit "c787337a16ea8cf8a06227f35933a4ec774746b3")
6952 (revision "1"))
6953 (package
6954 (name "sbcl-cl-store")
6955 (version (git-version "0.8.11" revision commit))
6956 (source
6957 (origin
6958 (method git-fetch)
6959 (uri (git-reference
6960 (url "https://github.com/skypher/cl-store")
6961 (commit commit)))
6962 (file-name (git-file-name name version))
6963 (sha256
6964 (base32
6965 "194srkg8nrym19c6i7zbnkzshc1qhqa82m53qnkirz9fw928bqxr"))))
6966 (build-system asdf-build-system/sbcl)
6967 (native-inputs
6968 `(("rt" ,sbcl-rt)))
6969 (synopsis "Common Lisp library to serialize data")
6970 (description
6971 "CL-STORE is a portable serialization package which should give you the
6972 ability to store all Common Lisp data types into streams.")
6973 (home-page "https://www.common-lisp.net/project/cl-store/")
6974 (license license:expat))))
6975
6976 (define-public cl-store
6977 (sbcl-package->cl-source-package sbcl-cl-store))
6978
6979 (define-public ecl-cl-store
6980 (sbcl-package->ecl-package sbcl-cl-store))
6981
6982 (define-public sbcl-specialization-store
6983 (let ((commit "8d39a866a6f24986aad3cc52349e9cb2653496f3")
6984 (revision "1"))
6985 (package
6986 (name "sbcl-specialization-store")
6987 (version (git-version "0.0.5" revision commit))
6988 (source
6989 (origin
6990 (method git-fetch)
6991 (uri (git-reference
6992 (url "https://github.com/markcox80/specialization-store")
6993 (commit commit)))
6994 (file-name (git-file-name "specialization-store" version))
6995 (sha256
6996 (base32 "0r0bgb46q4gy72l78s7djkxq8ibb4bb3yh9brsry5lih7br8lhi0"))))
6997 (build-system asdf-build-system/sbcl)
6998 (native-inputs
6999 `(("fiveam" ,sbcl-fiveam)))
7000 (inputs
7001 `(("alexandria" ,sbcl-alexandria)
7002 ("introspect-environment" ,sbcl-introspect-environment)))
7003 (home-page "https://github.com/markcox80/specialization-store")
7004 (synopsis "Different type of generic function for Common Lisp")
7005 (description
7006 "SPECIALIZATION-STORE system provides a new kind of function, called
7007 a store function, whose behavior depends on the types of objects passed to the
7008 function.")
7009 (license license:bsd-2))))
7010
7011 (define-public ecl-specialization-store
7012 (package
7013 (inherit (sbcl-package->ecl-package sbcl-specialization-store))
7014 (arguments
7015 ;; TODO: Find why the tests get stuck forever; disable them for now.
7016 `(#:tests? #f))))
7017
7018 (define-public cl-specialization-store
7019 (sbcl-package->cl-source-package sbcl-specialization-store))
7020
7021 (define-public sbcl-cl-gobject-introspection
7022 (let ((commit "d0136c8d9ade2560123af1fc55bbf70d2e3db539")
7023 (revision "1"))
7024 (package
7025 (name "sbcl-cl-gobject-introspection")
7026 (version (git-version "0.3" revision commit))
7027 (home-page "https://github.com/andy128k/cl-gobject-introspection")
7028 (source
7029 (origin
7030 (method git-fetch)
7031 (uri (git-reference
7032 (url home-page)
7033 (commit commit)))
7034 (file-name (git-file-name name version))
7035 (sha256
7036 (base32
7037 "0dz0r73pq7yhz2iq2jnkq977awx2zws2qfxdcy33329sys1ii32p"))))
7038 (build-system asdf-build-system/sbcl)
7039 (inputs
7040 `(("alexandria" ,sbcl-alexandria)
7041 ("cffi" ,sbcl-cffi)
7042 ("iterate" ,sbcl-iterate)
7043 ("trivial-garbage" ,sbcl-trivial-garbage)
7044 ("glib" ,glib)
7045 ("gobject-introspection" ,gobject-introspection)))
7046 (native-inputs
7047 `(("fiveam" ,sbcl-fiveam)))
7048 (arguments
7049 '(#:phases
7050 (modify-phases %standard-phases
7051 (add-after 'unpack 'fix-paths
7052 (lambda* (#:key inputs #:allow-other-keys)
7053 (substitute* "src/init.lisp"
7054 (("libgobject-2\\.0\\.so")
7055 (string-append (assoc-ref inputs "glib") "/lib/libgobject-2.0.so"))
7056 (("libgirepository-1\\.0\\.so")
7057 (string-append (assoc-ref inputs "gobject-introspection")
7058 "/lib/libgirepository-1.0.so")))
7059 #t)))))
7060 (synopsis "Common Lisp bindings to GObject Introspection")
7061 (description
7062 "This library is a bridge between Common Lisp and GObject
7063 Introspection, which enables Common Lisp programs to access the full interface
7064 of C+GObject libraries without the need of writing dedicated bindings.")
7065 (license (list license:bsd-3
7066 ;; Tests are under a different license.
7067 license:llgpl)))))
7068
7069 (define-public cl-gobject-introspection
7070 (sbcl-package->cl-source-package sbcl-cl-gobject-introspection))
7071
7072 (define-public ecl-cl-gobject-introspection
7073 (sbcl-package->ecl-package sbcl-cl-gobject-introspection))
7074
7075 (define-public sbcl-cl-slug
7076 (let ((commit "ffb229d10f0d3f7f54e706791725225e200bf749")
7077 (revision "1"))
7078 (package
7079 (name "sbcl-cl-slug")
7080 (version (git-version "0.4.1" revision commit))
7081 (source
7082 (origin
7083 (method git-fetch)
7084 (uri (git-reference
7085 (url "https://github.com/EuAndreh/cl-slug")
7086 (commit commit)))
7087 (file-name (git-file-name "cl-slug" version))
7088 (sha256
7089 (base32 "1asdq6xllmsvfw5fky9wblqcx9isac9jrrlkfl7vyxcq1wxrnflx"))))
7090 (build-system asdf-build-system/sbcl)
7091 (arguments
7092 `(#:asd-files '("cl-slug-test.asd" "cl-slug.asd")
7093 #:asd-systems '("cl-slug-test" "cl-slug")))
7094 (native-inputs
7095 `(("prove" ,sbcl-prove)))
7096 (inputs
7097 `(("ppcre" ,sbcl-cl-ppcre)))
7098 (home-page "https://github.com/EuAndreh/cl-slug")
7099 (synopsis "Multi-language slug formater")
7100 (description
7101 "This is a small Common Lisp library to make slugs, mainly for URIs,
7102 from english and beyond.")
7103 (license license:llgpl))))
7104
7105 (define-public ecl-cl-slug
7106 (sbcl-package->ecl-package sbcl-cl-slug))
7107
7108 (define-public cl-slug
7109 (sbcl-package->cl-source-package sbcl-cl-slug))
7110
7111 (define-public sbcl-string-case
7112 (let ((commit "718c761e33749e297cd2809c7ba3ade1985c49f7")
7113 (revision "0"))
7114 (package
7115 (name "sbcl-string-case")
7116 (version (git-version "0.0.2" revision commit))
7117 (home-page "https://github.com/pkhuong/string-case")
7118 (source
7119 (origin
7120 (method git-fetch)
7121 (uri (git-reference
7122 (url home-page)
7123 (commit commit)))
7124 (file-name (git-file-name name version))
7125 (sha256
7126 (base32
7127 "1n5i3yh0h5s636rcnwn7jwqy3rjflikra04lymimhpcshhjsk0md"))))
7128 (build-system asdf-build-system/sbcl)
7129 (synopsis "Efficient string= case in Common Lisp")
7130 (description
7131 "@code{string-case} is a Common Lisp macro that generates specialised decision
7132 trees to dispatch on string equality.")
7133 (license license:bsd-3))))
7134
7135 (define-public cl-string-case
7136 (sbcl-package->cl-source-package sbcl-string-case))
7137
7138 (define-public ecl-string-case
7139 (sbcl-package->ecl-package sbcl-string-case))
7140
7141 (define-public sbcl-garbage-pools
7142 (let ((commit "9a7cb7f48b04197c0495df3b6d2e8395ad13f790")
7143 (revision "1"))
7144 (package
7145 (name "sbcl-garbage-pools")
7146 (version (git-version "0.1.2" revision commit))
7147 (source
7148 (origin
7149 (method git-fetch)
7150 (uri (git-reference
7151 (url "https://github.com/archimag/garbage-pools")
7152 (commit commit)))
7153 (file-name (git-file-name name version))
7154 (sha256
7155 (base32 "04jqwr6j138him6wc4nrwjzm4lvyj5j31xqab02nkf8h9hmsf5v1"))))
7156 (build-system asdf-build-system/sbcl)
7157 (home-page "https://github.com/archimag/garbage-pools")
7158 (synopsis "Resource management pools for Common Lisp")
7159 (description "GARBAGE-POOLS is Common Lisp re-implementation of the APR
7160 Pools for resource management.")
7161 (license license:expat))))
7162
7163 (define-public ecl-garbage-pools
7164 (sbcl-package->ecl-package sbcl-garbage-pools))
7165
7166 (define-public cl-garbage-pools
7167 (sbcl-package->cl-source-package sbcl-garbage-pools))
7168
7169 (define-public sbcl-global-vars
7170 (let ((commit "c749f32c9b606a1457daa47d59630708ac0c266e")
7171 (revision "0"))
7172 (package
7173 (name "sbcl-global-vars")
7174 (version (git-version "1.0.0" revision commit))
7175 (home-page "https://github.com/lmj/global-vars")
7176 (source
7177 (origin
7178 (method git-fetch)
7179 (uri (git-reference
7180 (url home-page)
7181 (commit commit)))
7182 (file-name (git-file-name name version))
7183 (sha256
7184 (base32
7185 "06m3xc8l3pgsapl8fvsi9wf6y46zs75cp9zn7zh6dc65v4s5wz3d"))))
7186 (build-system asdf-build-system/sbcl)
7187 (synopsis "Efficient global variables in Common Lisp")
7188 (description
7189 "In Common Lisp, a special variable that is never dynamically bound
7190 typically serves as a stand-in for a global variable. The @code{global-vars}
7191 library provides true global variables that are implemented by some compilers.
7192 An attempt to rebind a global variable properly results in a compiler error.
7193 That is, a global variable cannot be dynamically bound.
7194
7195 Global variables therefore allow us to communicate an intended usage that
7196 differs from special variables. Global variables are also more efficient than
7197 special variables, especially in the presence of threads.")
7198 (license license:expat))))
7199
7200 (define-public cl-global-vars
7201 (sbcl-package->cl-source-package sbcl-global-vars))
7202
7203 (define-public ecl-global-vars
7204 (sbcl-package->ecl-package sbcl-global-vars))
7205
7206 (define-public sbcl-trivial-file-size
7207 (let ((commit "1c1d672a01a446ba0391dbb4ffc40be3b0476f23")
7208 (revision "0"))
7209 (package
7210 (name "sbcl-trivial-file-size")
7211 (version (git-version "0.0.0" revision commit))
7212 (home-page "https://github.com/ruricolist/trivial-file-size")
7213 (source
7214 (origin
7215 (method git-fetch)
7216 (uri (git-reference
7217 (url home-page)
7218 (commit commit)))
7219 (file-name (git-file-name name version))
7220 (sha256
7221 (base32
7222 "17pp86c9zs4y7i1sh7q9gbfw9iqv6655k7fz8qbj9ly1ypgxp4qs"))))
7223 (build-system asdf-build-system/sbcl)
7224 (native-inputs
7225 `(("fiveam" ,sbcl-fiveam)))
7226 (synopsis "Size of a file in bytes in Common Lisp")
7227 (description
7228 "The canonical way to determine the size of a file in bytes, using Common Lisp,
7229 is to open the file with an element type of (unsigned-byte 8) and then
7230 calculate the length of the stream. This is less than ideal. In most cases
7231 it is better to get the size of the file from its metadata, using a system
7232 call.
7233
7234 This library exports a single function, file-size-in-octets. It returns the
7235 size of a file in bytes, using system calls when possible.")
7236 (license license:expat))))
7237
7238 (define-public cl-trivial-file-size
7239 (sbcl-package->cl-source-package sbcl-trivial-file-size))
7240
7241 (define-public ecl-trivial-file-size
7242 (sbcl-package->ecl-package sbcl-trivial-file-size))
7243
7244 (define-public sbcl-trivial-macroexpand-all
7245 (let ((commit "933270ac7107477de1bc92c1fd641fe646a7a8a9")
7246 (revision "0"))
7247 (package
7248 (name "sbcl-trivial-macroexpand-all")
7249 (version (git-version "0.0.0" revision commit))
7250 (home-page "https://github.com/cbaggers/trivial-macroexpand-all")
7251 (source
7252 (origin
7253 (method git-fetch)
7254 (uri (git-reference
7255 (url home-page)
7256 (commit commit)))
7257 (file-name (git-file-name name version))
7258 (sha256
7259 (base32
7260 "191hnn4b5j4i3crydmlzbm231kj0h7l8zj6mzj69r1npbzkas4bd"))))
7261 (build-system asdf-build-system/sbcl)
7262 (native-inputs
7263 `(("fiveam" ,sbcl-fiveam)))
7264 (synopsis "Portable macroexpand-all for Common Lisp")
7265 (description
7266 "This library provides a macroexpand-all function that calls the
7267 implementation specific equivalent.")
7268 (license license:unlicense))))
7269
7270 (define-public cl-trivial-macroexpand-all
7271 (sbcl-package->cl-source-package sbcl-trivial-macroexpand-all))
7272
7273 (define-public ecl-trivial-macroexpand-all
7274 (sbcl-package->ecl-package sbcl-trivial-macroexpand-all))
7275
7276 (define-public sbcl-serapeum
7277 (let ((commit "263f415a350736b44e3878524ff3997e656fca32")
7278 (revision "4"))
7279 (package
7280 (name "sbcl-serapeum")
7281 (version (git-version "0.0.0" revision commit))
7282 (home-page "https://github.com/ruricolist/serapeum")
7283 (source
7284 (origin
7285 (method git-fetch)
7286 (uri (git-reference
7287 (url home-page)
7288 (commit commit)))
7289 (file-name (git-file-name name version))
7290 (sha256
7291 (base32
7292 "1669yidvxq41s3g6hb2jk21bcb5s2bnfsacpyd5b0hdxbmc7knq3"))))
7293 (build-system asdf-build-system/sbcl)
7294 (inputs
7295 `(("alexandria" ,sbcl-alexandria)
7296 ("trivia" ,sbcl-trivia)
7297 ("split-sequence" ,sbcl-split-sequence)
7298 ("string-case" ,sbcl-string-case)
7299 ("parse-number" ,sbcl-parse-number)
7300 ("trivial-garbage" ,sbcl-trivial-garbage)
7301 ("bordeaux-threads" ,sbcl-bordeaux-threads)
7302 ("named-readtables" ,sbcl-named-readtables)
7303 ("fare-quasiquote" ,sbcl-fare-quasiquote)
7304 ("parse-declarations-1.0" ,sbcl-parse-declarations)
7305 ("global-vars" ,sbcl-global-vars)
7306 ("trivial-file-size" ,sbcl-trivial-file-size)
7307 ("trivial-macroexpand-all" ,sbcl-trivial-macroexpand-all)))
7308 (native-inputs
7309 `(("fiveam" ,sbcl-fiveam)
7310 ("local-time" ,sbcl-local-time)))
7311 (arguments
7312 '(#:phases
7313 (modify-phases %standard-phases
7314 (add-after 'unpack 'disable-failing-tests
7315 (lambda* (#:key inputs #:allow-other-keys)
7316 (substitute* "serapeum.asd"
7317 ;; Guix does not have Quicklisp, and probably never will.
7318 (("\\(:file \"quicklisp\"\\)") ""))
7319 #t)))))
7320 (synopsis "Common Lisp utility library beyond Alexandria")
7321 (description
7322 "Serapeum is a conservative library of Common Lisp utilities. It is a
7323 supplement, not a competitor, to Alexandria.")
7324 (license license:expat))))
7325
7326 (define-public cl-serapeum
7327 (sbcl-package->cl-source-package sbcl-serapeum))
7328
7329 (define-public ecl-serapeum
7330 (sbcl-package->ecl-package sbcl-serapeum))
7331
7332 (define-public sbcl-arrows
7333 (let ((commit "df7cf0067e0132d9697ac8b1a4f1b9c88d4f5382")
7334 (revision "0"))
7335 (package
7336 (name "sbcl-arrows")
7337 (version (git-version "0.2.0" revision commit))
7338 (source
7339 (origin
7340 (method git-fetch)
7341 (uri (git-reference
7342 (url "https://gitlab.com/Harleqin/arrows.git")
7343 (commit commit)))
7344 (file-name (git-file-name name version))
7345 (sha256
7346 (base32
7347 "042k9vkssrqx9nhp14wdzm942zgdxvp35mba0p2syz98i75im2yy"))))
7348 (build-system asdf-build-system/sbcl)
7349 (native-inputs
7350 `(("hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
7351 (synopsis "Clojure-like arrow macros for Common Lisp")
7352 (description
7353 "This library implements the @code{->} and @code{->>} macros from
7354 Clojure, as well as several expansions on the idea.")
7355 (home-page "https://gitlab.com/Harleqin/arrows")
7356 (license license:public-domain))))
7357
7358 (define-public cl-arrows
7359 (sbcl-package->cl-source-package sbcl-arrows))
7360
7361 (define-public ecl-arrows
7362 (sbcl-package->ecl-package sbcl-arrows))
7363
7364 (define-public sbcl-simple-parallel-tasks
7365 (let ((commit "ce7b60f788d8f68dfb69b24aac54c0e3b63379a6")
7366 (revision "1"))
7367 (package
7368 (name "sbcl-simple-parallel-tasks")
7369 (version (git-version "1.0" revision commit))
7370 (source
7371 (origin
7372 (method git-fetch)
7373 (uri (git-reference
7374 (url "https://github.com/glv2/simple-parallel-tasks")
7375 (commit commit)))
7376 (file-name (git-file-name name version))
7377 (sha256
7378 (base32 "0gvbpyff4siifp3cp86cpr9ksmakn66fx21f3h0hpn647zl07nj7"))))
7379 (build-system asdf-build-system/sbcl)
7380 (native-inputs
7381 `(("fiveam" ,sbcl-fiveam)))
7382 (inputs
7383 `(("chanl" ,sbcl-chanl)))
7384 (synopsis "Common Lisp library to evaluate some forms in parallel")
7385 (description "This is a simple Common Lisp library to evaluate some
7386 forms in parallel.")
7387 (home-page "https://github.com/glv2/simple-parallel-tasks")
7388 (license license:gpl3))))
7389
7390 (define-public cl-simple-parallel-tasks
7391 (sbcl-package->cl-source-package sbcl-simple-parallel-tasks))
7392
7393 (define-public ecl-simple-parallel-tasks
7394 (sbcl-package->ecl-package sbcl-simple-parallel-tasks))
7395
7396 (define-public sbcl-cl-heap
7397 (package
7398 (name "sbcl-cl-heap")
7399 (version "0.1.6")
7400 (source
7401 (origin
7402 (method url-fetch)
7403 (uri (string-append "https://common-lisp.net/project/cl-heap/releases/"
7404 "cl-heap_" version ".tar.gz"))
7405 (sha256
7406 (base32
7407 "163hb07p2nxz126rpq3cj5dyala24n0by5i5786n2qcr1w0bak4i"))))
7408 (build-system asdf-build-system/sbcl)
7409 (native-inputs
7410 `(("xlunit" ,sbcl-xlunit)))
7411 (arguments
7412 `(#:test-asd-file "cl-heap-tests.asd"))
7413 (synopsis "Heap and priority queue data structures for Common Lisp")
7414 (description
7415 "CL-HEAP provides various implementations of heap data structures (a
7416 binary heap and a Fibonacci heap) as well as an efficient priority queue.")
7417 (home-page "https://common-lisp.net/project/cl-heap/")
7418 (license license:gpl3+)))
7419
7420 (define-public cl-heap
7421 (sbcl-package->cl-source-package sbcl-cl-heap))
7422
7423 (define-public ecl-cl-heap
7424 (sbcl-package->ecl-package sbcl-cl-heap))
7425
7426 (define-public sbcl-curry-compose-reader-macros
7427 (let ((commit "beaa92dedf392726c042184bfd6149fa8d9e6ac2")
7428 (revision "0"))
7429 (package
7430 (name "sbcl-curry-compose-reader-macros")
7431 (version (git-version "1.0.0" revision commit))
7432 (source
7433 (origin
7434 (method git-fetch)
7435 (uri
7436 (git-reference
7437 (url "https://github.com/eschulte/curry-compose-reader-macros")
7438 (commit commit)))
7439 (file-name (git-file-name name version))
7440 (sha256
7441 (base32
7442 "0rv9bl8xrad5wfcg5zs1dazvnpmvqz6297lbn8bywsrcfnlf7h98"))))
7443 (build-system asdf-build-system/sbcl)
7444 (inputs
7445 `(("alexandria" ,sbcl-alexandria)
7446 ("named-readtables" ,sbcl-named-readtables)))
7447 (synopsis "Reader macros for partial application and composition")
7448 (description
7449 "This Common Lisp library provides reader macros for concise expression
7450 of function partial application and composition.")
7451 (home-page "https://eschulte.github.io/curry-compose-reader-macros/")
7452 (license license:public-domain))))
7453
7454 (define-public cl-curry-compose-reader-macros
7455 (sbcl-package->cl-source-package sbcl-curry-compose-reader-macros))
7456
7457 (define-public ecl-curry-compose-reader-macros
7458 (sbcl-package->ecl-package sbcl-curry-compose-reader-macros))
7459
7460 (define-public sbcl-yason
7461 (package
7462 (name "sbcl-yason")
7463 (version "0.7.7")
7464 (source
7465 (origin
7466 (method git-fetch)
7467 (uri (git-reference
7468 (url "https://github.com/phmarek/yason")
7469 (commit (string-append "v" version))))
7470 (file-name (git-file-name name version))
7471 (sha256
7472 (base32
7473 "0479rbjgbj80jpk5bby18inlv1kfp771a82rlcq5psrz65qqa9bj"))))
7474 (build-system asdf-build-system/sbcl)
7475 (inputs
7476 `(("alexandria" ,sbcl-alexandria)
7477 ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
7478 (synopsis "Common Lisp JSON parser/encoder")
7479 (description
7480 "YASON is a Common Lisp library for encoding and decoding data in the
7481 JSON interchange format.")
7482 (home-page "https://github.com/phmarek/yason")
7483 (license license:bsd-3)))
7484
7485 (define-public cl-yason
7486 (sbcl-package->cl-source-package sbcl-yason))
7487
7488 (define-public ecl-yason
7489 (sbcl-package->ecl-package sbcl-yason))
7490
7491 (define-public sbcl-stefil
7492 (let ((commit "0398548ec95dceb50fc2c2c03e5fb0ce49b86c7a")
7493 (revision "0"))
7494 (package
7495 (name "sbcl-stefil")
7496 (version (git-version "0.1" revision commit))
7497 (source
7498 (origin
7499 (method git-fetch)
7500 (uri (git-reference
7501 (url "https://gitlab.common-lisp.net/stefil/stefil.git")
7502 (commit commit)))
7503 (file-name (git-file-name name version))
7504 (sha256
7505 (base32
7506 "0bqz64q2szzhf91zyqyssmvrz7da6442rs01808pf3wrdq28bclh"))))
7507 (build-system asdf-build-system/sbcl)
7508 (inputs
7509 `(("alexandria" ,sbcl-alexandria)
7510 ("iterate" ,sbcl-iterate)
7511 ("metabang-bind" ,sbcl-metabang-bind)
7512 ("swank" ,sbcl-slime-swank)))
7513 (arguments
7514 '(#:phases
7515 (modify-phases %standard-phases
7516 (add-after 'unpack 'drop-unnecessary-dependency
7517 (lambda _
7518 (substitute* "package.lisp"
7519 ((":stefil-system") ""))
7520 #t)))))
7521 (home-page "https://common-lisp.net/project/stefil/index-old.shtml")
7522 (synopsis "Simple test framework")
7523 (description
7524 "Stefil is a simple test framework for Common Lisp, with a focus on
7525 interactive development.")
7526 (license license:public-domain))))
7527
7528 (define-public cl-stefil
7529 (sbcl-package->cl-source-package sbcl-stefil))
7530
7531 (define-public ecl-stefil
7532 (sbcl-package->ecl-package sbcl-stefil))
7533
7534 (define-public sbcl-graph
7535 (let ((commit "78bf9ec930d8eae4f0861b5be76765fb1e45e24f")
7536 (revision "0"))
7537 (package
7538 (name "sbcl-graph")
7539 (version (git-version "0.0.0" revision commit))
7540 (source
7541 (origin
7542 (method git-fetch)
7543 (uri
7544 (git-reference
7545 (url "https://github.com/eschulte/graph")
7546 (commit commit)))
7547 (file-name (git-file-name name version))
7548 (sha256
7549 (base32
7550 "1qpij4xh8bqwc2myahpilcbh916v7vg0acz2fij14d3y0jm02h0g"))))
7551 (build-system asdf-build-system/sbcl)
7552 (native-inputs
7553 `(("stefil" ,sbcl-stefil)))
7554 (inputs
7555 `(("alexandria" ,sbcl-alexandria)
7556 ("cl-heap" ,sbcl-cl-heap)
7557 ("cl-ppcre" ,sbcl-cl-ppcre)
7558 ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
7559 ("metabang-bind" ,sbcl-metabang-bind)
7560 ("named-readtables" ,sbcl-named-readtables)
7561 ("yason" ,sbcl-yason)))
7562 (arguments
7563 '(#:asd-systems '("graph"
7564 "graph/dot"
7565 "graph/json")))
7566 (synopsis "Graph data structure and algorithms for Common Lisp")
7567 (description
7568 "The GRAPH Common Lisp library provides a data structures to represent
7569 graphs, as well as some graph manipulation and analysis algorithms (shortest
7570 path, maximum flow, minimum spanning tree, etc.).")
7571 (home-page "https://eschulte.github.io/graph/")
7572 (license license:gpl3+))))
7573
7574 (define-public cl-graph
7575 (sbcl-package->cl-source-package sbcl-graph))
7576
7577 (define-public ecl-graph
7578 (sbcl-package->ecl-package sbcl-graph))
7579
7580 (define-public sbcl-trivial-indent
7581 (let ((commit "2d016941751647c6cc5bd471751c2cf68861c94a")
7582 (revision "0"))
7583 (package
7584 (name "sbcl-trivial-indent")
7585 (version (git-version "1.0.0" revision commit))
7586 (source
7587 (origin
7588 (method git-fetch)
7589 (uri
7590 (git-reference
7591 (url "https://github.com/Shinmera/trivial-indent")
7592 (commit commit)))
7593 (file-name (git-file-name name version))
7594 (sha256
7595 (base32
7596 "1sj90nqz17w4jq0ixz00gb9g5g6d2s7l8r17zdby27gxxh51w266"))))
7597 (build-system asdf-build-system/sbcl)
7598 (synopsis "Simple Common Lisp library to allow indentation hints for SWANK")
7599 (description
7600 "This library allows you to define custom indentation hints for your
7601 macros if the one recognised by SLIME automatically produces unwanted
7602 results.")
7603 (home-page "https://shinmera.github.io/trivial-indent/")
7604 (license license:zlib))))
7605
7606 (define-public cl-trivial-indent
7607 (sbcl-package->cl-source-package sbcl-trivial-indent))
7608
7609 (define-public ecl-trivial-indent
7610 (sbcl-package->ecl-package sbcl-trivial-indent))
7611
7612 (define-public sbcl-documentation-utils
7613 (let ((commit "98630dd5f7e36ae057fa09da3523f42ccb5d1f55")
7614 (revision "0"))
7615 (package
7616 (name "sbcl-documentation-utils")
7617 (version (git-version "1.2.0" revision commit))
7618 (source
7619 (origin
7620 (method git-fetch)
7621 (uri
7622 (git-reference
7623 (url "https://github.com/Shinmera/documentation-utils")
7624 (commit commit)))
7625 (file-name (git-file-name name version))
7626 (sha256
7627 (base32
7628 "098qhkqskmmrh4wix34mawf7p5c87yql28r51r75yjxj577k5idq"))))
7629 (build-system asdf-build-system/sbcl)
7630 (inputs
7631 `(("trivial-indent" ,sbcl-trivial-indent)))
7632 (synopsis "Few simple tools to document Common Lisp libraries")
7633 (description
7634 "This is a small library to help you with managing the Common Lisp
7635 docstrings for your library.")
7636 (home-page "https://shinmera.github.io/documentation-utils/")
7637 (license license:zlib))))
7638
7639 (define-public cl-documentation-utils
7640 (sbcl-package->cl-source-package sbcl-documentation-utils))
7641
7642 (define-public ecl-documentation-utils
7643 (sbcl-package->ecl-package sbcl-documentation-utils))
7644
7645 (define-public sbcl-documentation-utils-extensions
7646 (let ((commit "f67f8a05d583174662a594b79356b201c1d9d750"))
7647 (package
7648 (name "sbcl-documentation-utils-extensions")
7649 (version (git-version "0.0.0" "1" commit))
7650 (source
7651 (origin
7652 (method git-fetch)
7653 (uri
7654 (git-reference
7655 (url "https://github.com/sirherrbatka/documentation-utils-extensions/")
7656 (commit commit)))
7657 (file-name (git-file-name name version))
7658 (sha256
7659 (base32
7660 "0pn45c9rbxlnhn5nvhqz6kyv0nlirwxpg4j27niwdq80yxzsn51f"))))
7661 (build-system asdf-build-system/sbcl)
7662 (inputs
7663 `(("documentation-utils" ,sbcl-documentation-utils)))
7664 (home-page "https://github.com/sirherrbatka/documentation-utils-extensions")
7665 (synopsis "Set of extensions for documentation-utils")
7666 (description
7667 "Use @code{rich-formatter} to format documentation with sections @code{:syntax},
7668 @code{:arguments}, @code{:examples}, @code{:description}, @code{:returns},
7669 @code{:side-effects}, @code{:thread-safety}, @code{:affected-by},
7670 @code{:see-also} and @code{:notes}. Gather unformatted input by using
7671 @code{rich-aggregating-formatter} and @code{*DOCUMENTATION*} variable. Find
7672 gathered documentation with find-documentation function. Execute code stored
7673 in documentation with @code{execute-documentation}. See the examples in the
7674 @code{src/documentation.lisp} file. See the @code{documentation-utils} system
7675 for more information.")
7676 (license license:expat))))
7677
7678 (define-public cl-documentation-utils-extensions
7679 (sbcl-package->cl-source-package sbcl-documentation-utils-extensions))
7680
7681 (define-public ecl-documentation-utils-extensions
7682 (sbcl-package->ecl-package sbcl-documentation-utils-extensions))
7683
7684 (define-public sbcl-form-fiddle
7685 (let ((commit "e0c23599dbb8cff3e83e012f3d86d0764188ad18")
7686 (revision "0"))
7687 (package
7688 (name "sbcl-form-fiddle")
7689 (version (git-version "1.1.0" revision commit))
7690 (source
7691 (origin
7692 (method git-fetch)
7693 (uri
7694 (git-reference
7695 (url "https://github.com/Shinmera/form-fiddle")
7696 (commit commit)))
7697 (file-name (git-file-name name version))
7698 (sha256
7699 (base32
7700 "041iznc9mpfyrl0sv5893ys9pbb2pvbn9g3clarqi7gsfj483jln"))))
7701 (build-system asdf-build-system/sbcl)
7702 (inputs
7703 `(("documentation-utils" ,sbcl-documentation-utils)))
7704 (synopsis "Utilities to destructure Common Lisp lambda forms")
7705 (description
7706 "Often times we need to destructure a form definition in a Common Lisp
7707 macro. This library provides a set of simple utilities to help with that.")
7708 (home-page "https://shinmera.github.io/form-fiddle/")
7709 (license license:zlib))))
7710
7711 (define-public cl-form-fiddle
7712 (sbcl-package->cl-source-package sbcl-form-fiddle))
7713
7714 (define-public ecl-form-fiddle
7715 (sbcl-package->ecl-package sbcl-form-fiddle))
7716
7717 (define-public sbcl-parachute
7718 (let ((commit "ca04dd8e43010a6dfffa26dbe1d62af86008d666")
7719 (revision "0"))
7720 (package
7721 (name "sbcl-parachute")
7722 (version (git-version "1.1.1" revision commit))
7723 (source
7724 (origin
7725 (method git-fetch)
7726 (uri
7727 (git-reference
7728 (url "https://github.com/Shinmera/parachute")
7729 (commit commit)))
7730 (file-name (git-file-name name version))
7731 (sha256
7732 (base32
7733 "1mvsm3r0r6a2bg75nw0q7n9vlby3ch45qjl7hnb5k1z2n5x5lh60"))))
7734 (build-system asdf-build-system/sbcl)
7735 (inputs
7736 `(("documentation-utils" ,sbcl-documentation-utils)
7737 ("form-fiddle" ,sbcl-form-fiddle)))
7738 (synopsis "Extensible and cross-compatible testing framework for Common Lisp")
7739 (description
7740 "Parachute is a simple-to-use and extensible testing framework.
7741 In Parachute, things are organised as a bunch of named tests within a package.
7742 Each test can contain a bunch of test forms that make up its body.")
7743 (home-page "https://shinmera.github.io/parachute/")
7744 (license license:zlib))))
7745
7746 (define-public cl-parachute
7747 (sbcl-package->cl-source-package sbcl-parachute))
7748
7749 (define-public ecl-parachute
7750 (sbcl-package->ecl-package sbcl-parachute))
7751
7752 (define-public sbcl-array-utils
7753 (let ((commit "f90eb9070d0b2205af51126a35033574725e5c56")
7754 (revision "0"))
7755 (package
7756 (name "sbcl-array-utils")
7757 (version (git-version "1.1.1" revision commit))
7758 (source
7759 (origin
7760 (method git-fetch)
7761 (uri
7762 (git-reference
7763 (url "https://github.com/Shinmera/array-utils")
7764 (commit commit)))
7765 (file-name (git-file-name name version))
7766 (sha256
7767 (base32
7768 "0zhwfbpr53vs1ii4sx75dz2k9yhh1xpwdqqpg8nmfndxkmhpbi3x"))))
7769 (build-system asdf-build-system/sbcl)
7770 (native-inputs
7771 `(("parachute" ,sbcl-parachute)))
7772 (inputs
7773 `(("documentation-utils" ,sbcl-documentation-utils)))
7774 (synopsis "Tiny collection of array and vector utilities for Common Lisp")
7775 (description
7776 "A miniature toolkit that contains some useful shifting/popping/pushing
7777 functions for arrays and vectors. Originally from Plump.")
7778 (home-page "https://shinmera.github.io/array-utils/")
7779 (license license:zlib))))
7780
7781 (define-public cl-array-utils
7782 (sbcl-package->cl-source-package sbcl-array-utils))
7783
7784 (define-public ecl-array-utils
7785 (sbcl-package->ecl-package sbcl-array-utils))
7786
7787 (define-public sbcl-plump
7788 (let ((commit "34f890fe46efdebe7bb70d218f1937e98f632bf9")
7789 (revision "1"))
7790 (package
7791 (name "sbcl-plump")
7792 (version (git-version "2.0.0" revision commit))
7793 (source
7794 (origin
7795 (method git-fetch)
7796 (uri
7797 (git-reference
7798 (url "https://github.com/Shinmera/plump")
7799 (commit commit)))
7800 (file-name (git-file-name name version))
7801 (sha256
7802 (base32
7803 "0a0x8wn6vv1ylxcwck12k18gy0a366kdm6ddxxk7yynl4mwnqgkh"))))
7804 (build-system asdf-build-system/sbcl)
7805 (inputs
7806 `(("array-utils" ,sbcl-array-utils)
7807 ("documentation-utils" ,sbcl-documentation-utils)))
7808 (synopsis "Lenient XML / XHTML / HTML parser for Common Lisp")
7809 (description
7810 "Plump is a parser for HTML/XML-like documents, focusing on being
7811 lenient towards invalid markup. It can handle things like invalid attributes,
7812 bad closing tag order, unencoded entities, inexistent tag types, self-closing
7813 tags and so on. It parses documents to a class representation and offers a
7814 small set of DOM functions to manipulate it. It can be extended to parse to
7815 your own classes.")
7816 (home-page "https://shinmera.github.io/plump/")
7817 (license license:zlib))))
7818
7819 (define-public cl-plump
7820 (sbcl-package->cl-source-package sbcl-plump))
7821
7822 (define-public ecl-plump
7823 (sbcl-package->ecl-package sbcl-plump))
7824
7825 ;;; Split the antik package in two to work around the circular dependency
7826 ;;; between antik/antik and antik/gsll.
7827 (define-public sbcl-antik-base
7828 (let ((commit "e4711a69b3d6bf37b5727af05c3cfd03e8428ba3")
7829 (revision "1"))
7830 (package
7831 (name "sbcl-antik-base")
7832 (version (git-version "0.0.0" revision commit))
7833 (source
7834 (origin
7835 (method git-fetch)
7836 (uri (git-reference
7837 (url "https://gitlab.common-lisp.net/antik/antik.git")
7838 (commit commit)))
7839 (file-name (git-file-name name version))
7840 (sha256
7841 (base32
7842 "047ga2c38par2xbgg4qx6hwv06qhf1c1f67as8xvir6s80lip1km"))))
7843 (build-system asdf-build-system/sbcl)
7844 (inputs
7845 `(("alexandria" ,sbcl-alexandria)
7846 ("cffi" ,sbcl-cffi)
7847 ("cl-ppcre" ,sbcl-cl-ppcre)
7848 ("drakma" ,sbcl-drakma)
7849 ("fare-utils" ,sbcl-fare-utils)
7850 ("iterate" ,sbcl-iterate)
7851 ("metabang-bind" ,sbcl-metabang-bind)
7852 ("named-readtables" ,sbcl-named-readtables)
7853 ("split-sequence" ,sbcl-split-sequence)
7854 ("static-vectors" ,sbcl-static-vectors)
7855 ("trivial-garbage" ,sbcl-trivial-garbage)
7856 ("trivial-utf-8" ,sbcl-trivial-utf-8)))
7857 (native-inputs
7858 `(("lisp-unit" ,sbcl-lisp-unit)))
7859 (arguments
7860 '(#:asd-systems '("antik-base"
7861 "foreign-array")
7862 #:phases
7863 (modify-phases %standard-phases
7864 (add-after 'unpack 'fix-build
7865 (lambda _
7866 (for-each delete-file
7867 '("antik.asd"
7868 "physical-dimension.asd"
7869 "science-data.asd"))
7870 #t)))))
7871 (synopsis "Scientific and engineering computation in Common Lisp")
7872 (description
7873 "Antik provides a foundation for scientific and engineering
7874 computation in Common Lisp. It is designed not only to facilitate
7875 numerical computations, but to permit the use of numerical computation
7876 libraries and the interchange of data and procedures, whether
7877 foreign (non-Lisp) or Lisp libraries. It is named after the
7878 Antikythera mechanism, one of the oldest examples of a scientific
7879 computer known.")
7880 (home-page "https://common-lisp.net/project/antik/")
7881 (license license:gpl3))))
7882
7883 (define-public cl-antik-base
7884 (sbcl-package->cl-source-package sbcl-antik-base))
7885
7886 (define-public ecl-antik-base
7887 (let ((pkg (sbcl-package->ecl-package sbcl-antik-base)))
7888 (package
7889 (inherit pkg)
7890 (arguments
7891 (substitute-keyword-arguments (package-arguments pkg)
7892 ((#:phases phases)
7893 `(modify-phases ,phases
7894 (add-after 'unpack 'fix-readtable
7895 (lambda _
7896 (substitute* "input-output/readtable.lisp"
7897 (("#-ccl")
7898 "#-(or ccl ecl)"))
7899 #t)))))))))
7900
7901 (define-public sbcl-gsll
7902 (let ((commit "1a8ada22f9cf5ed7372d352b2317f4ccdb6ab308")
7903 (revision "1"))
7904 (package
7905 (name "sbcl-gsll")
7906 (version (git-version "0.0.0" revision commit))
7907 (source
7908 (origin
7909 (method git-fetch)
7910 (uri (git-reference
7911 (url "https://gitlab.common-lisp.net/antik/gsll.git")
7912 (commit commit)))
7913 (file-name (git-file-name name version))
7914 (sha256
7915 (base32
7916 "0z5nypfk26hxihb08p085644afawicrgb4xvadh3lmrn46qbjfn4"))))
7917 (build-system asdf-build-system/sbcl)
7918 (native-inputs
7919 `(("lisp-unit" ,sbcl-lisp-unit)))
7920 (inputs
7921 `(("alexandria" ,sbcl-alexandria)
7922 ("antik-base" ,sbcl-antik-base)
7923 ("cffi" ,sbcl-cffi)
7924 ("gsl" ,gsl)
7925 ("metabang-bind" ,sbcl-metabang-bind)
7926 ("trivial-features" ,sbcl-trivial-features)
7927 ("trivial-garbage" ,sbcl-trivial-garbage)))
7928 (arguments
7929 `(#:tests? #f
7930 #:phases
7931 (modify-phases %standard-phases
7932 (add-after 'unpack 'fix-cffi-paths
7933 (lambda* (#:key inputs #:allow-other-keys)
7934 (substitute* "gsll.asd"
7935 ((":depends-on \\(#:foreign-array")
7936 ":depends-on (#:foreign-array #:cffi-libffi"))
7937 (substitute* "init/init.lisp"
7938 (("libgslcblas.so" all)
7939 (string-append
7940 (assoc-ref inputs "gsl") "/lib/" all)))
7941 (substitute* "init/init.lisp"
7942 (("libgsl.so" all)
7943 (string-append
7944 (assoc-ref inputs "gsl") "/lib/" all))))))))
7945 (synopsis "GNU Scientific Library for Lisp")
7946 (description
7947 "The GNU Scientific Library for Lisp (GSLL) allows the use of the
7948 GNU Scientific Library (GSL) from Common Lisp. This library provides a
7949 full range of common mathematical operations useful to scientific and
7950 engineering applications. The design of the GSLL interface is such
7951 that access to most of the GSL library is possible in a Lisp-natural
7952 way; the intent is that the user not be hampered by the restrictions
7953 of the C language in which GSL has been written. GSLL thus provides
7954 interactive use of GSL for getting quick answers, even for someone not
7955 intending to program in Lisp.")
7956 (home-page "https://common-lisp.net/project/gsll/")
7957 (license license:gpl3))))
7958
7959 (define-public cl-gsll
7960 (sbcl-package->cl-source-package sbcl-gsll))
7961
7962 (define-public ecl-gsll
7963 (sbcl-package->ecl-package sbcl-gsll))
7964
7965 (define-public sbcl-antik
7966 (package
7967 (inherit sbcl-antik-base)
7968 (name "sbcl-antik")
7969 (inputs
7970 `(("antik-base" ,sbcl-antik-base)
7971 ("gsll" ,sbcl-gsll)))
7972 (arguments
7973 '(#:asd-systems '("antik"
7974 "science-data")
7975 #:phases
7976 (modify-phases %standard-phases
7977 (add-after 'unpack 'fix-build
7978 (lambda _
7979 (for-each delete-file
7980 '("antik-base.asd"
7981 "foreign-array.asd"))
7982 #t)))))))
7983
7984 (define-public cl-antik
7985 (sbcl-package->cl-source-package sbcl-antik))
7986
7987 (define-public sbcl-cl-interpol
7988 (let ((commit "1fd288d861db85bc4677cff3cdd6af75fda1afb4")
7989 (revision "1"))
7990 (package
7991 (name "sbcl-cl-interpol")
7992 (version (git-version "0.2.6" revision commit))
7993 (source
7994 (origin
7995 (method git-fetch)
7996 (uri (git-reference
7997 (url "https://github.com/edicl/cl-interpol")
7998 (commit commit)))
7999 (file-name (git-file-name name version))
8000 (sha256
8001 (base32
8002 "1hnikak52hmcq1r5f616m6qq1108qnkw80pja950nv1fq5p0ppjn"))))
8003 (build-system asdf-build-system/sbcl)
8004 (inputs
8005 `(("cl-unicode" ,sbcl-cl-unicode)
8006 ("named-readtables" ,sbcl-named-readtables)))
8007 (native-inputs
8008 `(("flexi-streams" ,sbcl-flexi-streams)))
8009 (synopsis "String interpolation for Common Lisp")
8010 (description
8011 "CL-INTERPOL is a library for Common Lisp which modifies the
8012 reader so that you can have interpolation within strings similar to
8013 Perl or Unix Shell scripts. It also provides various ways to insert
8014 arbitrary characters into literal strings even if your editor/IDE
8015 doesn't support them.")
8016 (home-page "https://edicl.github.io/cl-interpol/")
8017 (license license:bsd-3))))
8018
8019 (define-public cl-interpol
8020 (sbcl-package->cl-source-package sbcl-cl-interpol))
8021
8022 (define-public ecl-cl-interpol
8023 (sbcl-package->ecl-package sbcl-cl-interpol))
8024
8025 (define-public sbcl-symbol-munger
8026 (let ((commit "97598d4c3c53fd5da72ab78908fbd5d8c7a13416")
8027 (revision "1"))
8028 (package
8029 (name "sbcl-symbol-munger")
8030 (version (git-version "0.0.1" revision commit))
8031 (source
8032 (origin
8033 (method git-fetch)
8034 (uri (git-reference
8035 (url "https://github.com/AccelerationNet/symbol-munger")
8036 (commit commit)))
8037 (file-name (git-file-name name version))
8038 (sha256
8039 (base32
8040 "0y8jywjy0ldyhp7bxf16fdvdd2qgqnd7nlhlqfpfnzxcqk4xy1km"))))
8041 (build-system asdf-build-system/sbcl)
8042 (inputs
8043 `(("alexandria" ,sbcl-alexandria)
8044 ("iterate" ,sbcl-iterate)))
8045 (arguments
8046 ;; There is a cyclical dependency between symbol-munger and lisp-unit2.
8047 ;; See https://github.com/AccelerationNet/symbol-munger/issues/4
8048 '(#:tests? #f))
8049 (synopsis
8050 "Capitalization and spacing conversion functions for Common Lisp")
8051 (description
8052 "This is a Common Lisp library to change the capitalization and spacing
8053 of a string or a symbol. It can convert to and from Lisp, english, underscore
8054 and camel-case rules.")
8055 (home-page "https://github.com/AccelerationNet/symbol-munger")
8056 ;; The package declares a BSD license, but all of the license
8057 ;; text is MIT.
8058 ;; See https://github.com/AccelerationNet/symbol-munger/issues/5
8059 (license license:expat))))
8060
8061 (define-public cl-symbol-munger
8062 (sbcl-package->cl-source-package sbcl-symbol-munger))
8063
8064 (define-public ecl-symbol-munger
8065 (sbcl-package->ecl-package sbcl-symbol-munger))
8066
8067 (define-public sbcl-lisp-unit2
8068 ;; There is a cyclical dependency between symbol-munger and lisp-unit2.
8069 ;; See https://github.com/AccelerationNet/symbol-munger/issues/4
8070 (let ((commit "fb9721524d1e4e73abb223ee036d74ce14a5505c")
8071 (revision "1"))
8072 (package
8073 (name "sbcl-lisp-unit2")
8074 (version (git-version "0.2.0" revision commit))
8075 (source
8076 (origin
8077 (method git-fetch)
8078 (uri (git-reference
8079 (url "https://github.com/AccelerationNet/lisp-unit2")
8080 (commit commit)))
8081 (file-name (git-file-name name version))
8082 (sha256
8083 (base32
8084 "1rsqy8y0jqll6xn9a593848f5wvd5ribv4csry1ly0hmdhfnqzlp"))))
8085 (build-system asdf-build-system/sbcl)
8086 (inputs
8087 `(("alexandria" ,sbcl-alexandria)
8088 ("cl-interpol" ,sbcl-cl-interpol)
8089 ("iterate" ,sbcl-iterate)
8090 ("symbol-munger" ,sbcl-symbol-munger)))
8091 (synopsis "Test Framework for Common Lisp")
8092 (description
8093 "LISP-UNIT2 is a Common Lisp library that supports unit testing in the
8094 style of JUnit for Java. It is a new version of the lisp-unit library written
8095 by Chris Riesbeck.")
8096 (home-page "https://github.com/AccelerationNet/lisp-unit2")
8097 (license license:expat))))
8098
8099 (define-public cl-lisp-unit2
8100 (sbcl-package->cl-source-package sbcl-lisp-unit2))
8101
8102 (define-public ecl-lisp-unit2
8103 (sbcl-package->ecl-package sbcl-lisp-unit2))
8104
8105 (define-public sbcl-cl-csv
8106 (let ((commit "68ecb5d816545677513d7f6308d9e5e8d2265651")
8107 (revision "2"))
8108 (package
8109 (name "sbcl-cl-csv")
8110 (version (git-version "1.0.6" revision commit))
8111 (source
8112 (origin
8113 (method git-fetch)
8114 (uri (git-reference
8115 (url "https://github.com/AccelerationNet/cl-csv")
8116 (commit commit)))
8117 (file-name (git-file-name name version))
8118 (sha256
8119 (base32
8120 "0gcmlbwx5m3kwgk12qi80w08ak8fgdnvyia429fz6gnxmhg0k54x"))))
8121 (build-system asdf-build-system/sbcl)
8122 (arguments
8123 ;; See: https://github.com/AccelerationNet/cl-csv/pull/34
8124 `(#:tests? #f))
8125 (inputs
8126 `(("alexandria" ,sbcl-alexandria)
8127 ("cl-interpol" ,sbcl-cl-interpol)
8128 ("iterate" ,sbcl-iterate)))
8129 (native-inputs
8130 `(("lisp-unit2" ,sbcl-lisp-unit2)))
8131 (synopsis "Common lisp library for comma-separated values")
8132 (description
8133 "This is a Common Lisp library providing functions to read/write CSV
8134 from/to strings, streams and files.")
8135 (home-page "https://github.com/AccelerationNet/cl-csv")
8136 (license license:bsd-3))))
8137
8138 (define-public cl-csv
8139 (sbcl-package->cl-source-package sbcl-cl-csv))
8140
8141 (define-public ecl-cl-csv
8142 (sbcl-package->ecl-package sbcl-cl-csv))
8143
8144 (define-public sbcl-external-program
8145 (let ((commit "5888b8f1fd3953feeeacecbba4384ddda584a749")
8146 (revision "1"))
8147 (package
8148 (name "sbcl-external-program")
8149 (version (git-version "0.0.6" revision commit))
8150 (source
8151 (origin
8152 (method git-fetch)
8153 (uri (git-reference
8154 (url "https://github.com/sellout/external-program")
8155 (commit commit)))
8156 (file-name (git-file-name name version))
8157 (sha256
8158 (base32
8159 "0vww1x3yilb3bjwg6k184vaj4vxyxw4vralhnlm6lk4xac67kc9z"))))
8160 (build-system asdf-build-system/sbcl)
8161 (inputs
8162 `(("trivial-features" ,sbcl-trivial-features)))
8163 (native-inputs
8164 `(("fiveam" ,sbcl-fiveam)))
8165 (synopsis "Common Lisp library for running external programs")
8166 (description
8167 "EXTERNAL-PROGRAM enables running programs outside the Lisp
8168 process. It is an attempt to make the RUN-PROGRAM functionality in
8169 implementations like SBCL and CCL as portable as possible without
8170 sacrificing much in the way of power.")
8171 (home-page "https://github.com/sellout/external-program")
8172 (license license:llgpl))))
8173
8174 (define-public cl-external-program
8175 (sbcl-package->cl-source-package sbcl-external-program))
8176
8177 (define-public ecl-external-program
8178 (sbcl-package->ecl-package sbcl-external-program))
8179
8180 (define-public sbcl-cl-ana
8181 (let ((commit "fa7cee4c50aa1c859652813049ba0da7c18a0df9")
8182 (revision "1"))
8183 (package
8184 (name "sbcl-cl-ana")
8185 (version (git-version "0.0.0" revision commit))
8186 (source
8187 (origin
8188 (method git-fetch)
8189 (uri (git-reference
8190 (url "https://github.com/ghollisjr/cl-ana")
8191 (commit commit)))
8192 (file-name (git-file-name name version))
8193 (sha256
8194 (base32 "0mr47l57m276dbpap7irr4fcnk5fgknhf6mgv4043s8h73amk5qh"))))
8195 (build-system asdf-build-system/sbcl)
8196 (native-inputs
8197 `(("cl-fad" ,sbcl-cl-fad)))
8198 (inputs
8199 `(("alexandria" ,sbcl-alexandria)
8200 ("antik" ,sbcl-antik)
8201 ("cffi" ,sbcl-cffi)
8202 ("cl-csv" ,sbcl-cl-csv)
8203 ("closer-mop" ,sbcl-closer-mop)
8204 ("external-program" ,sbcl-external-program)
8205 ("gsl" ,gsl)
8206 ("gsll" ,sbcl-gsll)
8207 ("hdf5" ,hdf5-parallel-openmpi)
8208 ("iterate" ,sbcl-iterate)
8209 ("libffi" ,libffi)
8210 ("split-sequence" ,sbcl-split-sequence)))
8211 (arguments
8212 `(#:phases
8213 (modify-phases %standard-phases
8214 (add-after 'unpack 'fix-paths
8215 (lambda* (#:key inputs #:allow-other-keys)
8216 (substitute* "hdf-cffi/hdf-cffi.lisp"
8217 (("/usr/lib/i386-linux-gnu/hdf5/serial/libhdf5.so")
8218 (string-append (assoc-ref inputs "hdf5")
8219 "/lib/libhdf5.so")))
8220 (substitute* "gsl-cffi/gsl-cffi.lisp"
8221 (("define-foreign-library gsl-cffi" all)
8222 (string-append all " (:unix "
8223 (assoc-ref inputs "gsl")
8224 "/lib/libgsl.so)")))
8225 #t)))))
8226 (synopsis "Common Lisp data analysis library")
8227 (description
8228 "CL-ANA is a data analysis library in Common Lisp providing tabular and
8229 binned data analysis along with nonlinear least squares fitting and
8230 visualization.")
8231 (home-page "https://github.com/ghollisjr/cl-ana")
8232 (license license:gpl3))))
8233
8234 (define-public cl-ana
8235 (sbcl-package->cl-source-package sbcl-cl-ana))
8236
8237 (define-public sbcl-archive
8238 (let ((commit "631271c091ed02994bec3980cb288a2cf32c7cdc")
8239 (revision "1"))
8240 (package
8241 (name "sbcl-archive")
8242 (version (git-version "0.9" revision commit))
8243 (source (origin
8244 (method git-fetch)
8245 (uri (git-reference
8246 (url "https://github.com/sharplispers/archive")
8247 (commit commit)))
8248 (file-name (git-file-name name version))
8249 (sha256
8250 (base32
8251 "0pvsc9fmybx7rxd0kmzq4shi6hszdpwdc1sfy7jwyfxf8n3hnv4p"))))
8252 (build-system asdf-build-system/sbcl)
8253 (inputs
8254 `(("cl-fad" ,sbcl-cl-fad)
8255 ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
8256 (synopsis "Common Lisp library for tar and cpio archives")
8257 (description
8258 "This is a Common Lisp library to read and write disk-based file
8259 archives such as those generated by the tar and cpio programs on Unix.")
8260 (home-page "https://github.com/sharplispers/archive")
8261 (license license:bsd-3))))
8262
8263 (define-public cl-archive
8264 (sbcl-package->cl-source-package sbcl-archive))
8265
8266 (define-public ecl-archive
8267 (sbcl-package->ecl-package sbcl-archive))
8268
8269 (define-public sbcl-misc-extensions
8270 (let ((commit "101c05112bf2f1e1bbf527396822d2f50ca6327a")
8271 (revision "1"))
8272 (package
8273 (name "sbcl-misc-extensions")
8274 (version (git-version "3.3" revision commit))
8275 (source
8276 (origin
8277 (method git-fetch)
8278 (uri (git-reference
8279 (url "https://gitlab.common-lisp.net/misc-extensions/devel.git")
8280 (commit commit)))
8281 (file-name (git-file-name name version))
8282 (sha256
8283 (base32
8284 "0gz5f4p70qzilnxsnf5lih2n9m4wjcw8hlw4w8mpn9jyhyppyyv0"))))
8285 (build-system asdf-build-system/sbcl)
8286 (synopsis "Collection of small macros and extensions for Common Lisp")
8287 (description
8288 "This project is intended as a catchall for small, general-purpose
8289 extensions to Common Lisp. It contains:
8290
8291 @itemize
8292 @item @code{new-let}, a macro that combines and generalizes @code{let},
8293 @code{let*} and @code{multiple-value-bind},
8294 @item @code{gmap}, an iteration macro that generalizes @code{map}.
8295 @end itemize\n")
8296 (home-page "https://common-lisp.net/project/misc-extensions/")
8297 (license license:public-domain))))
8298
8299 (define-public cl-misc-extensions
8300 (sbcl-package->cl-source-package sbcl-misc-extensions))
8301
8302 (define-public ecl-misc-extensions
8303 (sbcl-package->ecl-package sbcl-misc-extensions))
8304
8305 (define-public sbcl-mt19937
8306 (package
8307 (name "sbcl-mt19937")
8308 (version "1.1")
8309 (source
8310 (origin
8311 (method url-fetch)
8312 (uri (string-append "https://common-lisp.net/project/asdf-packaging/"
8313 "mt19937-latest.tar.gz"))
8314 (sha256
8315 (base32
8316 "1iw636b0iw5ygkv02y8i41lh7xj0acglv0hg5agryn0zzi2nf1xv"))))
8317 (build-system asdf-build-system/sbcl)
8318 (synopsis "Mersenne Twister pseudo-random number generator")
8319 (description
8320 "MT19937 is a portable Mersenne Twister pseudo-random number generator
8321 for Common Lisp.")
8322 (home-page "https://www.cliki.net/mt19937")
8323 (license license:public-domain)))
8324
8325 (define-public cl-mt19937
8326 (sbcl-package->cl-source-package sbcl-mt19937))
8327
8328 (define-public ecl-mt19937
8329 (sbcl-package->ecl-package sbcl-mt19937))
8330
8331 (define-public sbcl-fset
8332 (let ((commit "6d2f9ded8934d2b42f2571a0ba5bda091037d852")
8333 (revision "1"))
8334 (package
8335 (name "sbcl-fset")
8336 (version (git-version "1.3.2" revision commit))
8337 (source
8338 (origin
8339 (method git-fetch)
8340 (uri (git-reference
8341 (url "https://github.com/slburson/fset")
8342 (commit commit)))
8343 (file-name (git-file-name name version))
8344 (sha256
8345 (base32
8346 "127acblwrbqicx47h6sgvknz1cqyfn8p4xkhkn1m7hxh8w5gk1zy"))
8347 (snippet '(begin
8348 ;; Remove obsolete copy of system definition.
8349 (delete-file "Code/fset.asd")
8350 #t))))
8351 (build-system asdf-build-system/sbcl)
8352 (inputs
8353 `(("misc-extensions" ,sbcl-misc-extensions)
8354 ("mt19937" ,sbcl-mt19937)
8355 ("named-readtables" ,sbcl-named-readtables)))
8356 (synopsis "Functional set-theoretic collections library")
8357 (description
8358 "FSet is a functional set-theoretic collections library for Common Lisp.
8359 Functional means that all update operations return a new collection rather than
8360 modifying an existing one in place. Set-theoretic means that collections may
8361 be nested arbitrarily with no additional programmer effort; for instance, sets
8362 may contain sets, maps may be keyed by sets, etc.")
8363 (home-page "https://common-lisp.net/project/fset/Site/index.html")
8364 (license license:llgpl))))
8365
8366 (define-public cl-fset
8367 (sbcl-package->cl-source-package sbcl-fset))
8368
8369 (define-public ecl-fset
8370 (package
8371 (inherit (sbcl-package->ecl-package sbcl-fset))
8372 (arguments
8373 ;; Tests fails on ECL with "The function FSET::MAKE-CHAR is undefined".
8374 '(#:tests? #f))))
8375
8376 (define-public sbcl-cl-cont
8377 (let ((commit "fc1fa7e6eb64894fdca13e688e6015fad5290d2a")
8378 (revision "1"))
8379 (package
8380 (name "sbcl-cl-cont")
8381 (version (git-version "0.3.8" revision commit))
8382 (source
8383 (origin
8384 (method git-fetch)
8385 (uri (git-reference
8386 (url "https://gitlab.common-lisp.net/cl-cont/cl-cont.git")
8387 (commit commit)))
8388 (file-name (git-file-name name version))
8389 (sha256
8390 (base32
8391 "1zf8zvb0i6jm3hhfks4w74hibm6avgc6f9s1qwgjrn2bcik8lrvz"))))
8392 (build-system asdf-build-system/sbcl)
8393 (inputs
8394 `(("alexandria" ,sbcl-alexandria)
8395 ("closer-mop" ,sbcl-closer-mop)))
8396 (native-inputs
8397 `(("rt" ,sbcl-rt)))
8398 (synopsis "Delimited continuations for Common Lisp")
8399 (description
8400 "This is a library that implements delimited continuations by
8401 transforming Common Lisp code to continuation passing style.")
8402 (home-page "https://common-lisp.net/project/cl-cont/")
8403 (license license:llgpl))))
8404
8405 (define-public cl-cont
8406 (sbcl-package->cl-source-package sbcl-cl-cont))
8407
8408 (define-public ecl-cl-cont
8409 (sbcl-package->ecl-package sbcl-cl-cont))
8410
8411 (define-public sbcl-cl-coroutine
8412 (let ((commit "de098f8d5debd8b14ef6864b5bdcbbf5ddbcfd72")
8413 (revision "1"))
8414 (package
8415 (name "sbcl-cl-coroutine")
8416 (version (git-version "0.1" revision commit))
8417 (source
8418 (origin
8419 (method git-fetch)
8420 (uri (git-reference
8421 (url "https://github.com/takagi/cl-coroutine")
8422 (commit commit)))
8423 (file-name (git-file-name name version))
8424 (sha256
8425 (base32
8426 "1cqdhdjxffgfs116l1swjlsmcbly0xgcgrckvaajd566idj9yj4l"))))
8427 (build-system asdf-build-system/sbcl)
8428 (inputs
8429 `(("alexandria" ,sbcl-alexandria)
8430 ("cl-cont" ,sbcl-cl-cont)))
8431 (native-inputs
8432 `(("prove" ,sbcl-prove)))
8433 (arguments
8434 `(;; TODO: Fix the tests. They fail with:
8435 ;; "Component CL-COROUTINE-ASD::CL-COROUTINE-TEST not found"
8436 #:tests? #f
8437 #:phases
8438 (modify-phases %standard-phases
8439 (add-after 'unpack 'fix-tests
8440 (lambda _
8441 (substitute* "cl-coroutine-test.asd"
8442 (("cl-test-more")
8443 "prove"))
8444 #t)))))
8445 (synopsis "Coroutine library for Common Lisp")
8446 (description
8447 "This is a coroutine library for Common Lisp implemented using the
8448 continuations of the @code{cl-cont} library.")
8449 (home-page "https://github.com/takagi/cl-coroutine")
8450 (license license:llgpl))))
8451
8452 (define-public cl-coroutine
8453 (sbcl-package->cl-source-package sbcl-cl-coroutine))
8454
8455 (define-public ecl-cl-coroutine
8456 (sbcl-package->ecl-package sbcl-cl-coroutine))
8457
8458 (define-public sbcl-vas-string-metrics
8459 (let ((commit "f2e4500b180316123fbd549bd51c751ee2d6ba0f")
8460 (revision "1"))
8461 (package
8462 (name "sbcl-vas-string-metrics")
8463 (version (git-version "0.0.0" revision commit))
8464 (source
8465 (origin
8466 (method git-fetch)
8467 (uri (git-reference
8468 (url "https://github.com/vsedach/vas-string-metrics")
8469 (commit commit)))
8470 (file-name (git-file-name "vas-string-metrics" version))
8471 (sha256
8472 (base32 "11fcnd03ybzz37rkg3z0wsb727yqgcd9gn70sccfb34l89ia279k"))))
8473 (build-system asdf-build-system/sbcl)
8474 (arguments
8475 `(#:test-asd-file "test.vas-string-metrics.asd"))
8476 (home-page "https://github.com/vsedach/vas-string-metrics")
8477 (synopsis "String distance algorithms for Common Lisp")
8478 (description
8479 "VAS-STRING-METRICS provides the Jaro, Jaro-Winkler, Soerensen-Dice,
8480 Levenshtein, and normalized Levenshtein string distance/similarity metrics
8481 algorithms.")
8482 (license license:lgpl3+))))
8483
8484 (define-public ecl-vas-string-metrics
8485 (sbcl-package->ecl-package sbcl-vas-string-metrics))
8486
8487 (define-public cl-vas-string-metrics
8488 (sbcl-package->cl-source-package sbcl-vas-string-metrics))
8489
8490 (define-public sbcl-vom
8491 (let ((commit "1aeafeb5b74c53741b79497e0ef4acf85c92ff24")
8492 (revision "1"))
8493 (package
8494 (name "sbcl-vom")
8495 (version (git-version "0.1.4" revision commit))
8496 (source
8497 (origin
8498 (method git-fetch)
8499 (uri (git-reference
8500 (url "https://github.com/orthecreedence/vom")
8501 (commit commit)))
8502 (file-name (git-file-name name version))
8503 (sha256
8504 (base32
8505 "0536kppj76ax4lrxhv42npkfjsmx45km2g439vf9jmw3apinz9cy"))))
8506 (build-system asdf-build-system/sbcl)
8507 (synopsis "Tiny logging utility for Common Lisp")
8508 (description
8509 "Vom is a logging library for Common Lisp. It's goal is to be useful
8510 and small. It does not provide a lot of features as other loggers do, but
8511 has a small codebase that's easy to understand and use.")
8512 (home-page "https://github.com/orthecreedence/vom")
8513 (license license:expat))))
8514
8515 (define-public cl-vom
8516 (sbcl-package->cl-source-package sbcl-vom))
8517
8518 (define-public ecl-vom
8519 (sbcl-package->ecl-package sbcl-vom))
8520
8521 (define-public sbcl-cl-libuv
8522 (let ((commit "32100c023c518038d0670a103eaa4d50dd785d29")
8523 (revision "1"))
8524 (package
8525 (name "sbcl-cl-libuv")
8526 (version (git-version "0.1.6" revision commit))
8527 (source
8528 (origin
8529 (method git-fetch)
8530 (uri (git-reference
8531 (url "https://github.com/orthecreedence/cl-libuv")
8532 (commit commit)))
8533 (file-name (git-file-name name version))
8534 (sha256
8535 (base32
8536 "1kwix4si8a8hza34ab2k7whrh7z0yrmx39v2wc3qblv9m244jkh1"))))
8537 (build-system asdf-build-system/sbcl)
8538 (inputs
8539 `(("alexandria" ,sbcl-alexandria)
8540 ("cffi" ,sbcl-cffi)
8541 ("libuv" ,libuv)))
8542 (arguments
8543 `(#:phases
8544 (modify-phases %standard-phases
8545 (add-after 'unpack 'fix-paths
8546 (lambda* (#:key inputs #:allow-other-keys)
8547 (substitute* "lib.lisp"
8548 (("/usr/lib/libuv.so")
8549 (string-append (assoc-ref inputs "libuv")
8550 "/lib/libuv.so")))
8551 #t))
8552 (add-after 'fix-paths 'fix-system-definition
8553 (lambda _
8554 (substitute* "cl-libuv.asd"
8555 (("#:cffi #:alexandria")
8556 "#:cffi #:cffi-grovel #:alexandria"))
8557 #t)))))
8558 (synopsis "Common Lisp bindings to libuv")
8559 (description
8560 "This library provides low-level libuv bindings for Common Lisp.")
8561 (home-page "https://github.com/orthecreedence/cl-libuv")
8562 (license license:expat))))
8563
8564 (define-public cl-libuv
8565 (sbcl-package->cl-source-package sbcl-cl-libuv))
8566
8567 (define-public ecl-cl-libuv
8568 (sbcl-package->ecl-package sbcl-cl-libuv))
8569
8570 (define-public sbcl-cl-async
8571 (let ((commit "f6423e44404a44434d803605e0d2e17199158e28")
8572 (revision "1"))
8573 (package
8574 (name "sbcl-cl-async")
8575 (version (git-version "0.6.1" revision commit))
8576 (source
8577 (origin
8578 (method git-fetch)
8579 (uri (git-reference
8580 (url "https://github.com/orthecreedence/cl-async")
8581 (commit commit)))
8582 (file-name (git-file-name name version))
8583 (sha256
8584 (base32
8585 "11xi9dxb8mjgwzrkj88i0xkgk26z9w9ddxzbv6xsvfc1d4x5cf4x"))))
8586 (build-system asdf-build-system/sbcl)
8587 (inputs
8588 `(("babel" ,sbcl-babel)
8589 ("bordeaux-threads" ,sbcl-bordeaux-threads)
8590 ("cffi" ,sbcl-cffi)
8591 ("cl-libuv" ,sbcl-cl-libuv)
8592 ("cl-ppcre" ,sbcl-cl-ppcre)
8593 ("fast-io" ,sbcl-fast-io)
8594 ("openssl" ,openssl)
8595 ("static-vectors" ,sbcl-static-vectors)
8596 ("trivial-features" ,sbcl-trivial-features)
8597 ("trivial-gray-streams" ,sbcl-trivial-gray-streams)
8598 ("vom" ,sbcl-vom)))
8599 (arguments
8600 `(#:asd-systems '("cl-async"
8601 "cl-async-repl"
8602 "cl-async-ssl")
8603 #:phases
8604 (modify-phases %standard-phases
8605 (add-after 'unpack 'fix-paths
8606 (lambda* (#:key inputs #:allow-other-keys)
8607 (substitute* "src/ssl/package.lisp"
8608 (("libcrypto\\.so")
8609 (string-append (assoc-ref inputs "openssl")
8610 "/lib/libcrypto.so"))
8611 (("libssl\\.so")
8612 (string-append (assoc-ref inputs "openssl")
8613 "/lib/libssl.so")))
8614 #t)))))
8615 (synopsis "Asynchronous operations for Common Lisp")
8616 (description
8617 "Cl-async is a library for general purpose, non-blocking programming in
8618 Common Lisp. It uses the libuv library as backend.")
8619 (home-page "https://orthecreedence.github.io/cl-async/")
8620 (license license:expat))))
8621
8622 (define-public cl-async
8623 (sbcl-package->cl-source-package sbcl-cl-async))
8624
8625 (define-public ecl-cl-async
8626 (sbcl-package->ecl-package sbcl-cl-async))
8627
8628 (define-public sbcl-blackbird
8629 (let ((commit "d361f81c1411dec07f6c2dcb11c78f7aea9aaca8")
8630 (revision "1"))
8631 (package
8632 (name "sbcl-blackbird")
8633 (version (git-version "0.5.2" revision commit))
8634 (source
8635 (origin
8636 (method git-fetch)
8637 (uri (git-reference
8638 (url "https://github.com/orthecreedence/blackbird")
8639 (commit commit)))
8640 (file-name (git-file-name name version))
8641 (sha256
8642 (base32
8643 "0xfds5yaya64arzr7w1x38karyz11swzbhxx1afldpradj9dh19c"))))
8644 (build-system asdf-build-system/sbcl)
8645 (inputs
8646 `(("vom" ,sbcl-vom)))
8647 (native-inputs
8648 `(("cl-async" ,sbcl-cl-async)
8649 ("fiveam" ,sbcl-fiveam)))
8650 (synopsis "Promise implementation for Common Lisp")
8651 (description
8652 "This is a standalone promise implementation for Common Lisp. It is
8653 the successor to the now-deprecated cl-async-future project.")
8654 (home-page "https://orthecreedence.github.io/blackbird/")
8655 (license license:expat))))
8656
8657 (define-public cl-blackbird
8658 (sbcl-package->cl-source-package sbcl-blackbird))
8659
8660 (define-public ecl-blackbird
8661 (sbcl-package->ecl-package sbcl-blackbird))
8662
8663 (define-public sbcl-cl-async-future
8664 (let ((commit "ee36c22a69a9516407458d2ed8b475f1fc473959")
8665 (revision "1"))
8666 (package
8667 (name "sbcl-cl-async-future")
8668 (version (git-version "0.4.4.1" revision commit))
8669 (source
8670 (origin
8671 (method git-fetch)
8672 (uri (git-reference
8673 (url "https://github.com/orthecreedence/cl-async-future")
8674 (commit commit)))
8675 (file-name (git-file-name name version))
8676 (sha256
8677 (base32
8678 "0z0sc7qlzzxk99f4l26zp6rai9kv0kj0f599sxai5s44p17zbbvh"))))
8679 (build-system asdf-build-system/sbcl)
8680 (inputs
8681 `(("blackbird" ,sbcl-blackbird)))
8682 (native-inputs
8683 `(("cl-async" ,sbcl-cl-async)
8684 ("eos" ,sbcl-eos)))
8685 (synopsis "Futures implementation for Common Lisp")
8686 (description
8687 "This is futures implementation for Common Lisp. It plugs in nicely
8688 to cl-async.")
8689 (home-page "https://orthecreedence.github.io/cl-async/future")
8690 (license license:expat))))
8691
8692 (define-public cl-async-future
8693 (sbcl-package->cl-source-package sbcl-cl-async-future))
8694
8695 (define-public ecl-cl-async-future
8696 (sbcl-package->ecl-package sbcl-cl-async-future))
8697
8698 (define-public sbcl-green-threads
8699 (let ((commit "fff5ebecb441a37e5c511773716aafd84a3c5840")
8700 (revision "1"))
8701 (package
8702 (name "sbcl-green-threads")
8703 (version (git-version "0.3" revision commit))
8704 (source
8705 (origin
8706 (method git-fetch)
8707 (uri (git-reference
8708 (url "https://github.com/thezerobit/green-threads")
8709 (commit commit)))
8710 (file-name (git-file-name name version))
8711 (sha256
8712 (base32
8713 "1czw7nr0dwfps76h8hjvglk1wdh53yqbfbvv30whwbgqx33iippz"))))
8714 (build-system asdf-build-system/sbcl)
8715 (inputs
8716 `(("cl-async-future" ,sbcl-cl-async-future)
8717 ("cl-cont" ,sbcl-cl-cont)))
8718 (native-inputs
8719 `(("prove" ,sbcl-prove)))
8720 (arguments
8721 `(;; TODO: Fix the tests. They fail with:
8722 ;; "The function BLACKBIRD::PROMISE-VALUES is undefined"
8723 #:tests? #f
8724 #:phases
8725 (modify-phases %standard-phases
8726 (add-after 'unpack 'fix-tests
8727 (lambda _
8728 (substitute* "green-threads-test.asd"
8729 (("cl-test-more")
8730 "prove"))
8731 #t)))))
8732 (synopsis "Cooperative multitasking library for Common Lisp")
8733 (description
8734 "This library allows for cooperative multitasking with help of cl-cont
8735 for continuations. It tries to mimic the API of bordeaux-threads as much as
8736 possible.")
8737 (home-page "https://github.com/thezerobit/green-threads")
8738 (license license:bsd-3))))
8739
8740 (define-public cl-green-threads
8741 (sbcl-package->cl-source-package sbcl-green-threads))
8742
8743 (define-public ecl-green-threads
8744 (sbcl-package->ecl-package sbcl-green-threads))
8745
8746 (define-public sbcl-cl-base32
8747 (let ((commit "8cdee06fab397f7b0a19583b57e7f0c98405be85")
8748 (revision "1"))
8749 (package
8750 (name "sbcl-cl-base32")
8751 (version (git-version "0.1" revision commit))
8752 (source
8753 (origin
8754 (method git-fetch)
8755 (uri (git-reference
8756 (url "https://github.com/hargettp/cl-base32")
8757 (commit commit)))
8758 (file-name (git-file-name name version))
8759 (sha256
8760 (base32 "17jrng8jb05d64ggyd11hp308c2fl5drvf9g175blgrkkl8l4mf8"))))
8761 (build-system asdf-build-system/sbcl)
8762 (native-inputs
8763 `(("lisp-unit" ,sbcl-lisp-unit)))
8764 (synopsis "Common Lisp library for base32 encoding and decoding")
8765 (description
8766 "This package provides functions for base32 encoding and decoding as
8767 defined in RFC4648.")
8768 (home-page "https://github.com/hargettp/cl-base32")
8769 (license license:expat))))
8770
8771 (define-public cl-base32
8772 (sbcl-package->cl-source-package sbcl-cl-base32))
8773
8774 (define-public ecl-cl-base32
8775 (sbcl-package->ecl-package sbcl-cl-base32))
8776
8777 (define-public sbcl-cl-z85
8778 (let ((commit "85b3951a9cfa2603acb6aee15567684f9a108098")
8779 (revision "1"))
8780 (package
8781 (name "sbcl-cl-z85")
8782 (version (git-version "1.0" revision commit))
8783 (source
8784 (origin
8785 (method git-fetch)
8786 (uri (git-reference
8787 (url "https://github.com/glv2/cl-z85")
8788 (commit commit)))
8789 (file-name (git-file-name name version))
8790 (sha256
8791 (base32 "0r27pidjaxbm7k1rr90nnajwl5xm2kp65g1fv0fva17lzy45z1mp"))))
8792 (build-system asdf-build-system/sbcl)
8793 (native-inputs
8794 `(("cl-octet-streams" ,sbcl-cl-octet-streams)
8795 ("fiveam" ,sbcl-fiveam)))
8796 (synopsis "Common Lisp library for Z85 encoding and decoding")
8797 (description
8798 "This package provides functions to encode or decode byte vectors or
8799 byte streams using the Z85 format, which is a base-85 encoding used by
8800 ZeroMQ.")
8801 (home-page "https://github.com/glv2/cl-z85")
8802 (license license:gpl3+))))
8803
8804 (define-public cl-z85
8805 (sbcl-package->cl-source-package sbcl-cl-z85))
8806
8807 (define-public ecl-cl-z85
8808 (sbcl-package->ecl-package sbcl-cl-z85))
8809
8810 (define-public sbcl-ltk
8811 (package
8812 (name "sbcl-ltk")
8813 (version "0.992")
8814 (source
8815 (origin
8816 (method git-fetch)
8817 (uri (git-reference
8818 (url "https://github.com/herth/ltk")
8819 (commit version)))
8820 (file-name (git-file-name name version))
8821 (sha256
8822 (base32 "13l2q4mskzilya9xh5wy2xvy30lwn104bd8wrq6ifds56r82iy3x"))))
8823 (build-system asdf-build-system/sbcl)
8824 (inputs
8825 `(("imagemagick" ,imagemagick)
8826 ("tk" ,tk)))
8827 (arguments
8828 `(#:asd-systems '("ltk"
8829 "ltk-mw"
8830 "ltk-remote")
8831 #:tests? #f
8832 #:phases
8833 (modify-phases %standard-phases
8834 (add-after 'unpack 'fix-paths
8835 (lambda* (#:key inputs #:allow-other-keys)
8836 (substitute* "ltk/ltk.lisp"
8837 (("#-freebsd \"wish\"")
8838 (string-append "#-freebsd \""
8839 (assoc-ref inputs "tk")
8840 "/bin/wish\""))
8841 (("do-execute \"convert\"")
8842 (string-append "do-execute \""
8843 (assoc-ref inputs "imagemagick")
8844 "/bin/convert\"")))
8845 #t))
8846 (add-after 'unpack 'fix-build
8847 (lambda _
8848 (substitute* "ltk/ltk-remote.lisp"
8849 (("\\(:export")
8850 "(:shadow #:raise) (:export"))
8851 #t)))))
8852 (synopsis "Common Lisp bindings for the Tk GUI toolkit")
8853 (description
8854 "LTK is a Common Lisp binding for the Tk graphics toolkit. It is written
8855 in pure Common Lisp and does not require any Tk knowledge for its usage.")
8856 (home-page "http://www.peter-herth.de/ltk/")
8857 (license license:llgpl)))
8858
8859 (define-public cl-ltk
8860 (sbcl-package->cl-source-package sbcl-ltk))
8861
8862 (define-public ecl-ltk
8863 (sbcl-package->ecl-package sbcl-ltk))
8864
8865 (define-public sbcl-cl-lex
8866 (let ((commit "f2dbbe25ef553005fb402d9a6203180c3fa1093b")
8867 (revision "1"))
8868 (package
8869 (name "sbcl-cl-lex")
8870 (version (git-version "1.1.3" revision commit))
8871 (source
8872 (origin
8873 (method git-fetch)
8874 (uri (git-reference
8875 (url "https://github.com/djr7C4/cl-lex")
8876 (commit commit)))
8877 (file-name (git-file-name name version))
8878 (sha256
8879 (base32 "1kg50f76bfpfxcv4dfivq1n9a0xlsra2ajb0vd68lxwgbidgyc2y"))))
8880 (build-system asdf-build-system/sbcl)
8881 (inputs
8882 `(("cl-ppcre" ,sbcl-cl-ppcre)))
8883 (synopsis "Common Lisp macros for generating lexical analyzers")
8884 (description
8885 "This is a Common Lisp library providing a set of macros for generating
8886 lexical analyzers automatically. The lexers generated using @code{cl-lex} can
8887 be used with @code{cl-yacc}.")
8888 (home-page "https://github.com/djr7C4/cl-lex")
8889 (license license:gpl3))))
8890
8891 (define-public cl-lex
8892 (sbcl-package->cl-source-package sbcl-cl-lex))
8893
8894 (define-public ecl-cl-lex
8895 (sbcl-package->ecl-package sbcl-cl-lex))
8896
8897 (define-public sbcl-clunit2
8898 (let ((commit "5e28343734eb9b7aee39306a614af92c1062d50b")
8899 (revision "1"))
8900 (package
8901 (name "sbcl-clunit2")
8902 (version (git-version "0.2.4" revision commit))
8903 (source
8904 (origin
8905 (method git-fetch)
8906 (uri (git-reference
8907 (url "https://notabug.org/cage/clunit2.git")
8908 (commit commit)))
8909 (file-name (git-file-name name version))
8910 (sha256
8911 (base32 "1ngiapfki6nm8a555mzhb5p7ch79i3w665za5bmb5j7q34fy80vw"))))
8912 (build-system asdf-build-system/sbcl)
8913 (synopsis "Unit testing framework for Common Lisp")
8914 (description
8915 "CLUnit is a Common Lisp unit testing framework. It is designed to be
8916 easy to use so that you can quickly start testing.")
8917 (home-page "https://notabug.org/cage/clunit2")
8918 (license license:expat))))
8919
8920 (define-public cl-clunit2
8921 (sbcl-package->cl-source-package sbcl-clunit2))
8922
8923 (define-public ecl-clunit2
8924 (sbcl-package->ecl-package sbcl-clunit2))
8925
8926 (define-public sbcl-cl-colors2
8927 (let ((commit "795aedee593b095fecde574bd999b520dd03ed24")
8928 (revision "1"))
8929 (package
8930 (name "sbcl-cl-colors2")
8931 (version (git-version "0.2.1" revision commit))
8932 (source
8933 (origin
8934 (method git-fetch)
8935 (uri (git-reference
8936 (url "https://notabug.org/cage/cl-colors2.git")
8937 (commit commit)))
8938 (file-name (git-file-name name version))
8939 (sha256
8940 (base32 "0hlyf4h5chkjdp9armla5w4kw5acikk159sym7y8c4jbjp9x47ih"))))
8941 (build-system asdf-build-system/sbcl)
8942 (native-inputs
8943 `(("clunit2" ,sbcl-clunit2)))
8944 (inputs
8945 `(("alexandria" ,sbcl-alexandria)
8946 ("cl-ppcre" ,sbcl-cl-ppcre)))
8947 (synopsis "Color library for Common Lisp")
8948 (description
8949 "This is a very simple color library for Common Lisp, providing:
8950
8951 @itemize
8952 @item Types for representing colors in HSV and RGB spaces.
8953 @item Simple conversion functions between the above types (and also
8954 hexadecimal representation for RGB).
8955 @item Some predefined colors (currently X11 color names -- of course
8956 the library does not depend on X11).
8957 @end itemize\n")
8958 (home-page "https://notabug.org/cage/cl-colors2")
8959 (license license:boost1.0))))
8960
8961 (define-public cl-colors2
8962 (sbcl-package->cl-source-package sbcl-cl-colors2))
8963
8964 (define-public ecl-cl-colors2
8965 (sbcl-package->ecl-package sbcl-cl-colors2))
8966
8967 (define-public sbcl-cl-jpeg
8968 (let ((commit "ec557038128df6895fbfb743bfe8faf8ec2534af")
8969 (revision "1"))
8970 (package
8971 (name "sbcl-cl-jpeg")
8972 (version (git-version "2.8" revision commit))
8973 (source
8974 (origin
8975 (method git-fetch)
8976 (uri (git-reference
8977 (url "https://github.com/sharplispers/cl-jpeg")
8978 (commit commit)))
8979 (file-name (git-file-name name version))
8980 (sha256
8981 (base32 "1bkkiqz8fqldlj1wbmrccjsvxcwj98h6s4b6gslr3cg2wmdv5xmy"))))
8982 (build-system asdf-build-system/sbcl)
8983 (synopsis "JPEG image library for Common Lisp")
8984 (description
8985 "This is a baseline JPEG codec written in Common Lisp. It can be used
8986 for reading and writing JPEG image files.")
8987 (home-page "https://github.com/sharplispers/cl-jpeg")
8988 (license license:bsd-3))))
8989
8990 (define-public cl-jpeg
8991 (sbcl-package->cl-source-package sbcl-cl-jpeg))
8992
8993 (define-public ecl-cl-jpeg
8994 (sbcl-package->ecl-package sbcl-cl-jpeg))
8995
8996 (define-public sbcl-nodgui
8997 (let ((commit "bc59ed9b787dfc9e68ae3bd7f7e8507c5c619212")
8998 (revision "1"))
8999 (package
9000 (name "sbcl-nodgui")
9001 (version (git-version "0.0.5" revision commit))
9002 (source
9003 (origin
9004 (method git-fetch)
9005 (uri (git-reference
9006 (url "https://notabug.org/cage/nodgui.git")
9007 (commit commit)))
9008 (file-name (git-file-name name version))
9009 (sha256
9010 (base32 "0xx0dk54d882i598ydnwmy7mnfk0b7vib3ddsgpqxhjck1rwq8l8"))))
9011 (build-system asdf-build-system/sbcl)
9012 (inputs
9013 `(("alexandria" ,sbcl-alexandria)
9014 ("bordeaux-threads" ,sbcl-bordeaux-threads)
9015 ("cl-colors2" ,sbcl-cl-colors2)
9016 ("cl-jpeg" ,sbcl-cl-jpeg)
9017 ("cl-lex" ,sbcl-cl-lex)
9018 ("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)
9019 ("cl-unicode" ,sbcl-cl-unicode)
9020 ("cl-yacc" ,sbcl-cl-yacc)
9021 ("clunit2" ,sbcl-clunit2)
9022 ("named-readtables" ,sbcl-named-readtables)
9023 ("parse-number" ,sbcl-parse-number)
9024 ("tk" ,tk)))
9025 (arguments
9026 `(#:phases (modify-phases %standard-phases
9027 (add-after 'unpack 'fix-paths
9028 (lambda* (#:key inputs #:allow-other-keys)
9029 (substitute* "src/wish-communication.lisp"
9030 (("#-freebsd \"wish\"")
9031 (string-append "#-freebsd \""
9032 (assoc-ref inputs "tk")
9033 "/bin/wish\"")))
9034 #t)))))
9035 (synopsis "Common Lisp bindings for the Tk GUI toolkit")
9036 (description
9037 "Nodgui (@emph{No Drama GUI}) is a Common Lisp binding for the Tk GUI
9038 toolkit. It also provides a few additional widgets more than the standard Tk
9039 ones.")
9040 (home-page "https://www.autistici.org/interzona/nodgui.html")
9041 (license license:llgpl))))
9042
9043 (define-public cl-nodgui
9044 (sbcl-package->cl-source-package sbcl-nodgui))
9045
9046 (define-public ecl-nodgui
9047 (sbcl-package->ecl-package sbcl-nodgui))
9048
9049 (define-public sbcl-salza2
9050 (package
9051 (name "sbcl-salza2")
9052 (version "2.0.9")
9053 (source
9054 (origin
9055 (method git-fetch)
9056 (uri (git-reference
9057 (url "https://github.com/xach/salza2")
9058 (commit (string-append "release-" version))))
9059 (file-name (git-file-name name version))
9060 (sha256
9061 (base32 "0p38rj4gq7j5k807php7hrz7l2zyyfshv8i9yms7i8lkgg3433ki"))))
9062 (build-system asdf-build-system/sbcl)
9063 (synopsis "Common Lisp library for zlib, deflate and gzip compression")
9064 (description
9065 "Salza2 is a Common Lisp library for creating compressed data in the zlib,
9066 deflate, or gzip data formats, described in RFC 1950, RFC 1951, and RFC 1952,
9067 respectively.")
9068 (home-page "https://www.xach.com/lisp/salza2/")
9069 (license license:bsd-2)))
9070
9071 (define-public cl-salza2
9072 (sbcl-package->cl-source-package sbcl-salza2))
9073
9074 (define-public ecl-salza2
9075 (sbcl-package->ecl-package sbcl-salza2))
9076
9077 (define-public sbcl-origin
9078 (let ((commit "d646134302456408d6d43580bb05299f1695ab8e")
9079 (revision "1"))
9080 (package
9081 (name "sbcl-origin")
9082 (version (git-version "2.0.0" revision commit))
9083 (source
9084 (origin
9085 (method git-fetch)
9086 (uri (git-reference
9087 (url "https://git.mfiano.net/mfiano/origin")
9088 (commit commit)))
9089 (file-name (git-file-name "origin" version))
9090 (sha256
9091 (base32 "1n9aszaif3yh8prs5r8v51fbj4r5jd1a048mivd5yij3hplkm82b"))))
9092 (build-system asdf-build-system/sbcl)
9093 (native-inputs
9094 `(("parachute" ,sbcl-parachute)))
9095 (inputs
9096 `(("golden-utils" ,sbcl-golden-utils)
9097 ("specialization-store" ,sbcl-specialization-store)))
9098 (home-page "https://git.mfiano.net/mfiano/origin")
9099 (synopsis "Common Lisp graphics math library")
9100 (description
9101 "This is a native Common Lisp graphics math library with an emphasis on
9102 performance and correctness.")
9103 (license license:expat))))
9104
9105 (define-public ecl-origin
9106 (sbcl-package->ecl-package sbcl-origin))
9107
9108 (define-public cl-origin
9109 (sbcl-package->cl-source-package sbcl-origin))
9110
9111 (define-public sbcl-png-read
9112 (let ((commit "ec29f38a689972b9f1373f13bbbcd6b05deada88")
9113 (revision "1"))
9114 (package
9115 (name "sbcl-png-read")
9116 (version (git-version "0.3.1" revision commit))
9117 (source
9118 (origin
9119 (method git-fetch)
9120 (uri (git-reference
9121 (url "https://github.com/Ramarren/png-read")
9122 (commit commit)))
9123 (file-name (git-file-name name version))
9124 (sha256
9125 (base32 "0vyczbcwskrygrf1hgrsnk0jil8skmvf1kiaalw5jps4fjrfdkw0"))))
9126 (build-system asdf-build-system/sbcl)
9127 (inputs
9128 `(("babel" ,sbcl-babel)
9129 ("chipz" ,sbcl-chipz)
9130 ("iterate" ,sbcl-iterate)))
9131 (synopsis "PNG decoder for Common Lisp")
9132 (description "This is a Common Lisp library for reading PNG images.")
9133 (home-page "https://github.com/Ramarren/png-read")
9134 (license license:bsd-3))))
9135
9136 (define-public cl-png-read
9137 (sbcl-package->cl-source-package sbcl-png-read))
9138
9139 (define-public ecl-png-read
9140 (sbcl-package->ecl-package sbcl-png-read))
9141
9142 (define-public sbcl-3b-bmfont
9143 (let ((commit "d1b5bec0de580c2d08ec947a93c56b1400f2a37a")
9144 (revision "1"))
9145 (package
9146 (name "sbcl-3b-bmfont")
9147 (version (git-version "0.0.1" revision commit))
9148 (source
9149 (origin
9150 (method git-fetch)
9151 (uri (git-reference
9152 (url "https://github.com/3b/3b-bmfont/")
9153 (commit commit)))
9154 (file-name (git-file-name "3b-bmfont" version))
9155 (sha256
9156 (base32 "12sgf7m0h6fqzhvkas7vmci6mprj3j3fnz778jlbqbsydln6v2yc"))))
9157 (build-system asdf-build-system/sbcl)
9158 (arguments
9159 `(#:asd-systems
9160 '("3b-bmfont"
9161 "3b-bmfont/text"
9162 "3b-bmfont/common"
9163 "3b-bmfont/xml"
9164 "3b-bmfont/json")))
9165 (inputs
9166 `(("alexandria" ,sbcl-alexandria)
9167 ("cxml" ,sbcl-cxml)
9168 ("flexi-streams" ,sbcl-flexi-streams)
9169 ("jsown" ,sbcl-jsown)
9170 ("split-sequence" ,sbcl-split-sequence)))
9171 (home-page "https://github.com/3b/3b-bmfont/")
9172 (synopsis "Read/write bmfont metadata files")
9173 (description
9174 "This is a Common Lisp library which provides functionality to
9175 read/write Bit Map Font (BMF) into text, JSON and XML.")
9176 (license license:expat))))
9177
9178 (define-public ecl-3b-bmfont
9179 (sbcl-package->ecl-package sbcl-3b-bmfont))
9180
9181 (define-public cl-3b-bmfont
9182 (sbcl-package->cl-source-package sbcl-3b-bmfont))
9183
9184 (define-public sbcl-zpng
9185 (package
9186 (name "sbcl-zpng")
9187 (version "1.2.2")
9188 (source
9189 (origin
9190 (method git-fetch)
9191 (uri (git-reference
9192 (url "https://github.com/xach/zpng")
9193 (commit (string-append "release-" version))))
9194 (file-name (git-file-name name version))
9195 (sha256
9196 (base32 "0b3ag3jhl3z7kdls3ahdsdxsfhhw5qrizk769984f4wkxhb69rcm"))))
9197 (build-system asdf-build-system/sbcl)
9198 (inputs
9199 `(("salza2" ,sbcl-salza2)))
9200 (synopsis "PNG encoder for Common Lisp")
9201 (description "This is a Common Lisp library for creating PNG images.")
9202 (home-page "https://www.xach.com/lisp/zpng/")
9203 (license license:bsd-2)))
9204
9205 (define-public cl-zpng
9206 (sbcl-package->cl-source-package sbcl-zpng))
9207
9208 (define-public ecl-zpng
9209 (sbcl-package->ecl-package sbcl-zpng))
9210
9211 (define-public sbcl-cl-qrencode
9212 (package
9213 (name "sbcl-cl-qrencode")
9214 (version "0.1.2")
9215 (source
9216 (origin
9217 (method git-fetch)
9218 (uri (git-reference
9219 (url "https://github.com/jnjcc/cl-qrencode")
9220 (commit (string-append "v" version))))
9221 (file-name (git-file-name name version))
9222 (sha256
9223 (base32 "1l5k131dchbf6cj8a8xqa731790p01p3qa1kdy2wa9dawy3ymkxr"))))
9224 (build-system asdf-build-system/sbcl)
9225 (native-inputs
9226 `(("lisp-unit" ,sbcl-lisp-unit)))
9227 (inputs
9228 `(("zpng" ,sbcl-zpng)))
9229 (synopsis "QR code encoder for Common Lisp")
9230 (description
9231 "This Common Lisp library provides function to make QR codes and to save
9232 them as PNG files.")
9233 (home-page "https://github.com/jnjcc/cl-qrencode")
9234 (license license:gpl2+)))
9235
9236 (define-public cl-qrencode
9237 (sbcl-package->cl-source-package sbcl-cl-qrencode))
9238
9239 (define-public ecl-cl-qrencode
9240 (sbcl-package->ecl-package sbcl-cl-qrencode))
9241
9242 (define-public sbcl-hdf5-cffi
9243 (let ((commit "5b5c88f191e470e4fe96b462334e3ce0806eed5c")
9244 (revision "1"))
9245 (package
9246 (name "sbcl-hdf5-cffi")
9247 (version (git-version "1.8.18" revision commit))
9248 (source
9249 (origin
9250 (method git-fetch)
9251 (uri (git-reference
9252 (url "https://github.com/hdfgroup/hdf5-cffi")
9253 (commit commit)))
9254 (file-name (git-file-name name version))
9255 (sha256
9256 (base32
9257 "0vda3075423xz83qky998lpac5b04dwfv7bwgh9jq8cs5v0zrxjf"))))
9258 (build-system asdf-build-system/sbcl)
9259 (synopsis "Common Lisp bindings for the HDF5 library")
9260 (description
9261 "@code{hdf5-cffi} is a CFFI wrapper for the HDF5 library.")
9262 (home-page "https://github.com/hdfgroup/hdf5-cffi")
9263 (license (license:non-copyleft
9264 (string-append "https://github.com/HDFGroup/hdf5-cffi/raw/"
9265 commit
9266 "/LICENSE")))
9267 (inputs
9268 `(("cffi" ,sbcl-cffi)
9269 ("hdf5" ,hdf5-1.10)))
9270 (native-inputs
9271 `(("fiveam" ,sbcl-fiveam)))
9272 (arguments
9273 `(#:test-asd-file "hdf5-cffi.test.asd"
9274 ;; Tests depend on hdf5-cffi.examples.asd in addition to hdf5-cffi.asd,
9275 ;; I don't know if there is a way to tell asdf-build-system to load
9276 ;; an additional system first, so tests are disabled.
9277 #:tests? #f
9278 #:phases
9279 (modify-phases %standard-phases
9280 (add-after 'unpack 'fix-paths
9281 (lambda* (#:key inputs #:allow-other-keys)
9282 (substitute* "src/library.lisp"
9283 (("libhdf5.so")
9284 (string-append
9285 (assoc-ref inputs "hdf5")
9286 "/lib/libhdf5.so")))))
9287 (add-after 'unpack 'fix-dependencies
9288 (lambda* (#:key inputs #:allow-other-keys)
9289 (substitute* "hdf5-cffi.asd"
9290 ((":depends-on \\(:cffi\\)")
9291 ":depends-on (:cffi :cffi-grovel)"))
9292 (substitute* "hdf5-cffi.test.asd"
9293 ((":depends-on \\(:cffi :hdf5-cffi")
9294 ":depends-on (:cffi :cffi-grovel :hdf5-cffi"))))))))))
9295
9296 (define-public cl-hdf5-cffi
9297 (sbcl-package->cl-source-package sbcl-hdf5-cffi))
9298
9299 (define-public ecl-hdf5-cffi
9300 (sbcl-package->ecl-package sbcl-hdf5-cffi))
9301
9302 (define-public sbcl-cl-randist
9303 (package
9304 (name "sbcl-cl-randist")
9305 (version "0.4.2")
9306 (source
9307 (origin
9308 (method git-fetch)
9309 (uri (git-reference
9310 (url "https://github.com/lvaruzza/cl-randist")
9311 (commit "f088a54b540a7adefab7c04094a6103f9edda3d0")))
9312 (file-name (git-file-name name version))
9313 (sha256
9314 (base32
9315 "0l8hyd6nbxb7f50vyxz3rbbm7kgr1fnadc40jywy4xj5vi5kpj5g"))))
9316 (build-system asdf-build-system/sbcl)
9317 (synopsis "Random distributions for Common Lisp")
9318 (description
9319 "Manual translation from C to Common Lisp of some random number
9320 generation functions from the GSL library.")
9321 (home-page "https://github.com/lvaruzza/cl-randist")
9322 (license license:bsd-2)
9323 (arguments
9324 `(#:tests? #f))))
9325
9326 (define-public cl-randist
9327 (sbcl-package->cl-source-package sbcl-cl-randist))
9328
9329 (define-public ecl-cl-randist
9330 (sbcl-package->ecl-package sbcl-cl-randist))
9331
9332 (define-public sbcl-float-features
9333 (package
9334 (name "sbcl-float-features")
9335 (version "1.0.0")
9336 (source
9337 (origin
9338 (method git-fetch)
9339 (uri (git-reference
9340 (url "https://github.com/Shinmera/float-features")
9341 (commit "d3ef60181635b0849aa28cfc238053b7ca4644b0")))
9342 (file-name (git-file-name name version))
9343 (sha256
9344 (base32
9345 "0yj419k7n59x6rh3grwr6frgwwyria2il6f7wxpfazm8cskv4lzr"))))
9346 (build-system asdf-build-system/sbcl)
9347 (synopsis "Common Lisp IEEE float portability library")
9348 (description
9349 "Portability library for IEEE float features that are not
9350 covered by the Common Lisp standard.")
9351 (home-page "https://github.com/Shinmera/float-features")
9352 (license license:zlib)
9353 (inputs
9354 `(("documentation-utils" ,sbcl-documentation-utils)))
9355 (arguments
9356 `(#:tests? #f))))
9357
9358 (define-public cl-float-features
9359 (sbcl-package->cl-source-package sbcl-float-features))
9360
9361 (define-public ecl-float-features
9362 (sbcl-package->ecl-package sbcl-float-features))
9363
9364 (define-public sbcl-function-cache
9365 (package
9366 (name "sbcl-function-cache")
9367 (version "1.0.3")
9368 (source
9369 (origin
9370 (method git-fetch)
9371 (uri (git-reference
9372 (url "https://github.com/AccelerationNet/function-cache")
9373 (commit "6a5ada401e57da2c8abf046f582029926e61fce8")))
9374 (file-name (git-file-name name version))
9375 (sha256
9376 (base32
9377 "000vmd3f5rx5hs9nvphfric0gkzaadns31c6mxaslpv0k7pkrmc6"))))
9378 (build-system asdf-build-system/sbcl)
9379 (synopsis "Function caching / memoization library for Common Lisp")
9380 (description
9381 "A common lisp library that provides extensible function result
9382 caching based on arguments (an expanded form of memoization).")
9383 (home-page "https://github.com/AccelerationNet/function-cache")
9384 (license
9385 (license:non-copyleft
9386 "https://github.com/AccelerationNet/function-cache/blob/master/README.md"))
9387 (inputs
9388 `(("alexandria" ,sbcl-alexandria)
9389 ("cl-interpol" ,sbcl-cl-interpol)
9390 ("iterate" ,sbcl-iterate)
9391 ("symbol-munger" ,sbcl-symbol-munger)
9392 ("closer-mop" ,sbcl-closer-mop)))
9393 (arguments
9394 `(#:tests? #f))))
9395
9396 (define-public cl-function-cache
9397 (sbcl-package->cl-source-package sbcl-function-cache))
9398
9399 (define-public ecl-function-cache
9400 (sbcl-package->ecl-package sbcl-function-cache))
9401
9402 (define-public sbcl-type-r
9403 (let ((commit "83c89e38f2f7a7b16f1012777ecaf878cfa6a267")
9404 (revision "1"))
9405 (package
9406 (name "sbcl-type-r")
9407 (version (git-version "0.0.0" revision commit))
9408 (source
9409 (origin
9410 (method git-fetch)
9411 (uri (git-reference
9412 (url "https://github.com/guicho271828/type-r")
9413 (commit commit)))
9414 (file-name (git-file-name name version))
9415 (sha256
9416 (base32
9417 "1arsxc2539rg8vbrdirz4xxj1b06mc6g6rqndz7a02g127qvk2sm"))))
9418 (build-system asdf-build-system/sbcl)
9419 (synopsis "Parser interface for Common Lisp built-in compound types")
9420 (description
9421 "Collections of accessor functions and patterns to access
9422 the elements in compound type specifier, e.g. @code{dimensions} in
9423 @code{(array element-type dimensions)}")
9424 (home-page "https://github.com/guicho271828/type-r")
9425 (license license:lgpl3+)
9426 (inputs
9427 `(("trivia" ,sbcl-trivia)
9428 ("alexandria" ,sbcl-alexandria)))
9429 (native-inputs
9430 `(("fiveam" ,sbcl-fiveam)))
9431 (arguments
9432 `(#:test-asd-file "type-r.test.asd")))))
9433
9434 (define-public cl-type-r
9435 (sbcl-package->cl-source-package sbcl-type-r))
9436
9437 (define-public ecl-type-r
9438 (sbcl-package->ecl-package sbcl-type-r))
9439
9440 (define-public sbcl-trivialib-type-unify
9441 (let ((commit "62492ebf04db567dcf435ae84c50b7b8202ecf99")
9442 (revision "1"))
9443 (package
9444 (name "sbcl-trivialib-type-unify")
9445 (version (git-version "0.1" revision commit))
9446 (source
9447 (origin
9448 (method git-fetch)
9449 (uri (git-reference
9450 (url "https://github.com/guicho271828/trivialib.type-unify")
9451 (commit commit)))
9452 (file-name (git-file-name name version))
9453 (sha256
9454 (base32
9455 "1bkyfzbwv75p50zp8n1n9rh2r29pw3vgz91gmn2gzzkyq3khj1vh"))))
9456 (build-system asdf-build-system/sbcl)
9457 (synopsis "Common Lisp type unification")
9458 (description
9459 "Unifies a parametrized type specifier against an actual type specifier.
9460 Importantly, it handles complicated array-subtypes and number-related types
9461 correctly.")
9462 (home-page "https://github.com/guicho271828/trivialib.type-unify")
9463 (license license:lgpl3+)
9464 (inputs
9465 `(("alexandria" ,sbcl-alexandria)
9466 ("trivia" ,sbcl-trivia)
9467 ("introspect-environment" ,sbcl-introspect-environment)
9468 ("type-r" ,sbcl-type-r)))
9469 (native-inputs
9470 `(("fiveam" ,sbcl-fiveam)))
9471 (arguments
9472 `(#:asd-systems '("trivialib.type-unify")
9473 #:test-asd-file "trivialib.type-unify.test.asd")))))
9474
9475 (define-public cl-trivialib-type-unify
9476 (sbcl-package->cl-source-package sbcl-trivialib-type-unify))
9477
9478 (define-public ecl-trivialib-type-unify
9479 (sbcl-package->ecl-package sbcl-trivialib-type-unify))
9480
9481 (define-public sbcl-specialized-function
9482 (let ((commit "dee56d2d2b6ecd10500ad291c56217698604ec35")
9483 (revision "2"))
9484 (package
9485 (name "sbcl-specialized-function")
9486 (version (git-version "0.0.0" revision commit))
9487 (source
9488 (origin
9489 (method git-fetch)
9490 (uri (git-reference
9491 (url "https://github.com/numcl/specialized-function")
9492 (commit commit)))
9493 (file-name (git-file-name name version))
9494 (sha256
9495 (base32 "1mcc7mmpbnmgnr1cl2jl5r1ai54gn7fbisv2c14sh9za5w4sib82"))))
9496 (build-system asdf-build-system/sbcl)
9497 (synopsis "Julia-like dispatch for Common Lisp")
9498 (description
9499 "This library is part of NUMCL. It provides a macro
9500 @code{SPECIALIZED} that performs a Julia-like dispatch on the arguments,
9501 lazily compiling a type-specific version of the function from the same
9502 code. The main target of this macro is speed.")
9503 (home-page "https://github.com/numcl/specialized-function")
9504 (license license:lgpl3+)
9505 (inputs
9506 `(("trivia" ,sbcl-trivia)
9507 ("alexandria" ,sbcl-alexandria)
9508 ("iterate" ,sbcl-iterate)
9509 ("lisp-namespace" ,sbcl-lisp-namespace)
9510 ("type-r" ,sbcl-type-r)
9511 ("trivial-cltl2" ,sbcl-trivial-cltl2)))
9512 (native-inputs
9513 `(("fiveam" ,sbcl-fiveam)))
9514 (arguments
9515 `(#:asd-files '("specialized-function.asd")
9516 #:test-asd-file "specialized-function.test.asd"
9517 ;; Tests fail because they try to use an internal symbol of SBCL
9518 ;; that does not exists in recent versions:
9519 ;; "The variable SB-VM:COMPLEX-VECTOR-NIL-WIDETAG is unbound."
9520 #:tests? #f)))))
9521
9522 (define-public cl-specialized-function
9523 (sbcl-package->cl-source-package sbcl-specialized-function))
9524
9525 (define-public ecl-specialized-function
9526 (sbcl-package->ecl-package sbcl-specialized-function))
9527
9528 (define-public sbcl-constantfold
9529 (let ((commit "0ff1d97a3fbcb89264f6a2af6ce62b73e7b421f4")
9530 (revision "1"))
9531 (package
9532 (name "sbcl-constantfold")
9533 (version (git-version "0.1" revision commit))
9534 (source
9535 (origin
9536 (method git-fetch)
9537 (uri (git-reference
9538 (url "https://github.com/numcl/constantfold")
9539 (commit commit)))
9540 (file-name (git-file-name name version))
9541 (sha256
9542 (base32
9543 "153h0569z6bff1qbad0bdssplwwny75l7ilqwcfqfdvzsxf9jh06"))))
9544 (build-system asdf-build-system/sbcl)
9545 (synopsis "Support library for numcl")
9546 (description
9547 "Support library for numcl. Registers a function as an
9548 additional form that is considered as a candidate for a constant.")
9549 (home-page "https://github.com/numcl/constantfold")
9550 (license license:lgpl3+)
9551 (inputs
9552 `(("trivia" ,sbcl-trivia)
9553 ("alexandria" ,sbcl-alexandria)
9554 ("iterate" ,sbcl-iterate)
9555 ("lisp-namespace" ,sbcl-lisp-namespace)))
9556 (native-inputs
9557 `(("fiveam" ,sbcl-fiveam)))
9558 (arguments
9559 `(#:asd-files '("constantfold.asd")
9560 #:test-asd-file "constantfold.test.asd")))))
9561
9562 (define-public cl-constantfold
9563 (sbcl-package->cl-source-package sbcl-constantfold))
9564
9565 (define-public ecl-constantfold
9566 (sbcl-package->ecl-package sbcl-constantfold))
9567
9568 (define-public sbcl-gtype
9569 (let ((commit "2442e32485635525af278ebd8fa69a27d5b8cf18")
9570 (revision "2"))
9571 (package
9572 (name "sbcl-gtype")
9573 (version (git-version "0.1" revision commit))
9574 (source
9575 (origin
9576 (method git-fetch)
9577 (uri (git-reference
9578 (url "https://github.com/numcl/gtype")
9579 (commit commit)))
9580 (file-name (git-file-name name version))
9581 (sha256
9582 (base32 "0hbkfdw00v7bsa6zbric34p5w6hfwxycccg8wc2faq0cxhsvpv9h"))))
9583 (build-system asdf-build-system/sbcl)
9584 (synopsis "C++/Julia-like parametric types in Common Lisp")
9585 (description
9586 "Support library for numcl that provides Julia-like runtime parametric
9587 type correctness in Common Lisp. It is based on CLtL2 extensions.")
9588 (home-page "https://github.com/numcl/gtype")
9589 (license license:lgpl3+)
9590 (inputs
9591 `(("trivialib.type-unify" ,sbcl-trivialib-type-unify)
9592 ("trivial-cltl2" ,sbcl-trivial-cltl2)
9593 ("trivia" ,sbcl-trivia)
9594 ("alexandria" ,sbcl-alexandria)
9595 ("iterate" ,sbcl-iterate)
9596 ("type-r" ,sbcl-type-r)))
9597 (native-inputs
9598 `(("fiveam" ,sbcl-fiveam)))
9599 (arguments
9600 `(#:asd-files '("gtype.asd")
9601 #:test-asd-file "gtype.test.asd")))))
9602
9603 (define-public cl-gtype
9604 (sbcl-package->cl-source-package sbcl-gtype))
9605
9606 (define-public ecl-gtype
9607 (let ((pkg (sbcl-package->ecl-package sbcl-gtype)))
9608 (package
9609 (inherit pkg)
9610 (arguments
9611 (substitute-keyword-arguments (package-arguments pkg)
9612 ;; The tests fail on ECL with a COMPILE-FILE-ERROR for t/package.lisp.
9613 ((#:tests? _ #f) #f))))))
9614
9615 (define-public sbcl-numcl
9616 (let ((commit "d19f36356be900c600ef08560c9e1af441a166cb")
9617 (revision "1"))
9618 (package
9619 (name "sbcl-numcl")
9620 (version (git-version "0.2.0" revision commit))
9621 (source
9622 (origin
9623 (method git-fetch)
9624 (uri (git-reference
9625 (url "https://github.com/numcl/numcl")
9626 (commit commit)))
9627 (file-name (git-file-name "numcl" version))
9628 (sha256
9629 (base32 "0q4ylfr7hl0gz2ynr0c15h09dmnli2x6ndnm5wr58wfplf1wfj31"))))
9630 (build-system asdf-build-system/sbcl)
9631 (arguments
9632 `(#:test-asd-file "numcl.test.asd"
9633 #:asd-files '("numcl.asd")))
9634 (native-inputs
9635 `(("fiveam" ,sbcl-fiveam)))
9636 (inputs
9637 `(("alexandria" ,sbcl-alexandria)
9638 ("cl-randist" ,sbcl-cl-randist)
9639 ("constantfold" ,sbcl-constantfold)
9640 ("float-features" ,sbcl-float-features)
9641 ("function-cache" ,sbcl-function-cache)
9642 ("gtype" ,sbcl-gtype)
9643 ("iterate" ,sbcl-iterate)
9644 ("lisp-namespace" ,sbcl-lisp-namespace)
9645 ("specialized-function" ,sbcl-specialized-function)
9646 ("trivia" ,sbcl-trivia)
9647 ("type-r" ,sbcl-type-r)))
9648 (home-page "https://numcl.github.io/numcl/")
9649 (synopsis "Numpy clone in Common Lisp")
9650 (description
9651 "This package is a Python Numpy clone implemented in pure Common Lisp.")
9652 (license license:lgpl3+))))
9653
9654 (define-public cl-numcl
9655 (sbcl-package->cl-source-package sbcl-numcl))
9656
9657 (define-public ecl-numcl
9658 (sbcl-package->ecl-package sbcl-numcl))
9659
9660 (define-public sbcl-pzmq
9661 (let ((commit "7c7390eedc469d033c72dc497984d1536ee75826")
9662 (revision "1"))
9663 (package
9664 (name "sbcl-pzmq")
9665 (version (git-version "0.0.0" revision commit))
9666 (source
9667 (origin
9668 (method git-fetch)
9669 (uri (git-reference
9670 (url "https://github.com/orivej/pzmq")
9671 (commit commit)))
9672 (file-name (git-file-name name version))
9673 (sha256
9674 (base32 "0gmwzf7h90wa7v4wnk49g0hv2mdalljpwhyigxcb967wzv8lqci9"))))
9675 (build-system asdf-build-system/sbcl)
9676 (native-inputs
9677 `(("bordeaux-threads" ,sbcl-bordeaux-threads)
9678 ("fiveam" ,sbcl-fiveam)
9679 ("let-plus" ,sbcl-let-plus)))
9680 (inputs
9681 `(("cffi" ,sbcl-cffi)
9682 ("zeromq" ,zeromq)))
9683 (arguments
9684 `(#:phases (modify-phases %standard-phases
9685 (add-after 'unpack 'fix-paths
9686 (lambda* (#:key inputs #:allow-other-keys)
9687 (substitute* "c-api.lisp"
9688 (("\"libzmq")
9689 (string-append "\""
9690 (assoc-ref inputs "zeromq")
9691 "/lib/libzmq")))
9692 #t)))))
9693 (synopsis "Common Lisp bindings for the ZeroMQ library")
9694 (description "This Common Lisp library provides bindings for the ZeroMQ
9695 lightweight messaging kernel.")
9696 (home-page "https://github.com/orivej/pzmq")
9697 (license license:unlicense))))
9698
9699 (define-public cl-pzmq
9700 (sbcl-package->cl-source-package sbcl-pzmq))
9701
9702 (define-public ecl-pzmq
9703 (sbcl-package->ecl-package sbcl-pzmq))
9704
9705 (define-public sbcl-clss
9706 (let ((revision "1")
9707 (commit "2a8e8615ab55870d4ca01928f3ed3bbeb4e75c8d"))
9708 (package
9709 (name "sbcl-clss")
9710 (version (git-version "0.3.1" revision commit))
9711 (source
9712 (origin
9713 (method git-fetch)
9714 (uri
9715 (git-reference
9716 (url "https://github.com/Shinmera/clss")
9717 (commit commit)))
9718 (sha256
9719 (base32 "0la4dbcda78x29szanylccrsljqrn9d1mhh569sqkyp44ni5fv91"))
9720 (file-name (git-file-name name version))))
9721 (inputs
9722 `(("array-utils" ,sbcl-array-utils)
9723 ("plump" ,sbcl-plump)))
9724 (build-system asdf-build-system/sbcl)
9725 (synopsis "DOM tree searching engine based on CSS selectors")
9726 (description "CLSS is a DOM traversal engine based on CSS
9727 selectors. It makes use of the Plump-DOM and is used by lQuery.")
9728 (home-page "https://github.com/Shinmera/clss")
9729 (license license:zlib))))
9730
9731 (define-public cl-clss
9732 (sbcl-package->cl-source-package sbcl-clss))
9733
9734 (define-public ecl-clss
9735 (sbcl-package->ecl-package sbcl-clss))
9736
9737 (define-public sbcl-lquery
9738 (let ((revision "1")
9739 (commit "8048111c6b83956daa632e7a3ffbd8c9c203bd8d"))
9740 (package
9741 (name "sbcl-lquery")
9742 (version (git-version "3.2.1" revision commit))
9743 (source
9744 (origin
9745 (method git-fetch)
9746 (uri
9747 (git-reference
9748 (url "https://github.com/Shinmera/lquery")
9749 (commit commit)))
9750 (sha256
9751 (base32 "0520mcpxc2d6fdm8z61arpgd2z38kan7cf06qs373n5r64rakz6w"))
9752 (file-name (git-file-name name version))))
9753 (native-inputs
9754 `(("fiveam" ,sbcl-fiveam)))
9755 (inputs
9756 `(("array-utils" ,sbcl-array-utils)
9757 ("form-fiddle" ,sbcl-form-fiddle)
9758 ("plump" ,sbcl-plump)
9759 ("clss" ,sbcl-clss)))
9760 (build-system asdf-build-system/sbcl)
9761 (synopsis "Library to allow jQuery-like HTML/DOM manipulation")
9762 (description "@code{lQuery} is a DOM manipulation library written in
9763 Common Lisp, inspired by and based on the jQuery syntax and
9764 functions. It uses Plump and CLSS as DOM and selector engines. The
9765 main idea behind lQuery is to provide a simple interface for crawling
9766 and modifying HTML sites, as well as to allow for an alternative
9767 approach to templating.")
9768 (home-page "https://github.com/Shinmera/lquery")
9769 (license license:zlib))))
9770
9771 (define-public cl-lquery
9772 (sbcl-package->cl-source-package sbcl-lquery))
9773
9774 (define-public ecl-lquery
9775 (sbcl-package->ecl-package sbcl-lquery))
9776
9777 (define-public sbcl-cl-mysql
9778 (let ((commit "ab56c279c1815aec6ca0bfe85164ff7e85cfb6f9")
9779 (revision "1"))
9780 (package
9781 (name "sbcl-cl-mysql")
9782 (version (git-version "0.1" revision commit))
9783 (source
9784 (origin
9785 (method git-fetch)
9786 (uri (git-reference
9787 (url "https://github.com/hackinghat/cl-mysql")
9788 (commit commit)))
9789 (file-name (git-file-name name version))
9790 (sha256
9791 (base32 "0dg5ynx2ww94d0qfwrdrm7plkn43h64hs4iiq9mj2s1s4ixnp3lr"))))
9792 (build-system asdf-build-system/sbcl)
9793 (native-inputs
9794 `(("stefil" ,sbcl-stefil)))
9795 (inputs
9796 `(("cffi" ,sbcl-cffi)
9797 ("mariadb-lib" ,mariadb "lib")))
9798 (arguments
9799 `(#:tests? #f ; TODO: Tests require a running server
9800 #:phases
9801 (modify-phases %standard-phases
9802 (add-after 'unpack 'fix-paths
9803 (lambda* (#:key inputs #:allow-other-keys)
9804 (substitute* "system.lisp"
9805 (("libmysqlclient_r" all)
9806 (string-append (assoc-ref inputs "mariadb-lib")
9807 "/lib/"
9808 all)))
9809 #t)))))
9810 (synopsis "Common Lisp wrapper for MySQL")
9811 (description
9812 "@code{cl-mysql} is a Common Lisp implementation of a MySQL wrapper.")
9813 (home-page "http://www.hackinghat.com/index.php/cl-mysql")
9814 (license license:expat))))
9815
9816 (define-public cl-mysql
9817 (sbcl-package->cl-source-package sbcl-cl-mysql))
9818
9819 (define-public ecl-cl-mysql
9820 (sbcl-package->ecl-package sbcl-cl-mysql))
9821
9822 (define-public sbcl-postmodern
9823 (package
9824 (name "sbcl-postmodern")
9825 (version "1.32.8")
9826 (source
9827 (origin
9828 (method git-fetch)
9829 (uri (git-reference
9830 (url "https://github.com/marijnh/Postmodern")
9831 (commit (string-append "v" version))))
9832 (file-name (git-file-name name version))
9833 (sha256
9834 (base32 "0vr5inbr8dldf6dsl0qj3h2yrnnsayzfwxfzwkn1pk7xbns2l78q"))))
9835 (build-system asdf-build-system/sbcl)
9836 (native-inputs
9837 `(("fiveam" ,sbcl-fiveam)))
9838 (inputs
9839 `(("alexandria" ,sbcl-alexandria)
9840 ("bordeaux-threads" ,sbcl-bordeaux-threads)
9841 ("cl-base64" ,sbcl-cl-base64)
9842 ("cl-unicode" ,sbcl-cl-unicode)
9843 ("closer-mop" ,sbcl-closer-mop)
9844 ("global-vars" ,sbcl-global-vars)
9845 ("ironclad" ,sbcl-ironclad)
9846 ("local-time" ,sbcl-local-time)
9847 ("md5" ,sbcl-md5)
9848 ("split-sequence" ,sbcl-split-sequence)
9849 ("uax-15" ,sbcl-uax-15)
9850 ("usocket" ,sbcl-usocket)))
9851 (arguments
9852 ;; TODO: (Sharlatan-20210114T171037+0000) tests still failing but on other
9853 ;; step, some functionality in `local-time' prevents passing tests.
9854 ;; Error:
9855 ;;
9856 ;; Can't create directory
9857 ;; /gnu/store
9858 ;; /4f47agf1kyiz057ppy6x5p98i7mcbfsv-sbcl-local-time-1.0.6-2.a177eb9
9859 ;; /lib/common-lisp/sbcl/local-time/src/integration/
9860 ;;
9861 ;; NOTE: (Sharlatan-20210124T191940+0000): When set env HOME to /tmp above
9862 ;; issue is resolved but it required live test database to connect to now.
9863 ;; Keep tests switched off.
9864 `(#:tests? #f
9865 #:asd-systems '("cl-postgres"
9866 "s-sql"
9867 "postmodern"
9868 "simple-date"
9869 "simple-date/postgres-glue")))
9870 (synopsis "Common Lisp library for interacting with PostgreSQL")
9871 (description
9872 "@code{postmodern} is a Common Lisp library for interacting with
9873 PostgreSQL databases. It provides the following features:
9874
9875 @itemize
9876 @item Efficient communication with the database server without need for
9877 foreign libraries.
9878 @item Support for UTF-8 on Unicode-aware Lisp implementations.
9879 @item A syntax for mixing SQL and Lisp code.
9880 @item Convenient support for prepared statements and stored procedures.
9881 @item A metaclass for simple database-access objects.
9882 @end itemize\n
9883
9884 This package produces 4 systems: postmodern, cl-postgres, s-sql, simple-date
9885
9886 @code{SIMPLE-DATE} is a very basic implementation of date and time objects, used
9887 to support storing and retrieving time-related SQL types. It is not loaded by
9888 default and you can use local-time (which has support for timezones) instead.
9889
9890 @code{S-SQL} is used to compile s-expressions to strings of SQL code, escaping
9891 any Lisp values inside, and doing as much as possible of the work at compile
9892 time.
9893
9894 @code{CL-POSTGRES} is the low-level library used for interfacing with a PostgreSQL
9895 server over a socket.
9896
9897 @code{POSTMODERN} itself is a wrapper around these packages and provides higher
9898 level functions, a very simple data access object that can be mapped directly to
9899 database tables and some convient utilities. It then tries to put all these
9900 things together into a convenient programming interface")
9901 (home-page "https://marijnhaverbeke.nl/postmodern/")
9902 (license license:zlib)))
9903
9904 (define-public cl-postmodern
9905 (sbcl-package->cl-source-package sbcl-postmodern))
9906
9907 (define-public ecl-postmodern
9908 (package
9909 (inherit (sbcl-package->ecl-package sbcl-postmodern))
9910 (arguments
9911 `(#:tests? #f
9912 #:asd-systems '("cl-postgres"
9913 "s-sql"
9914 "postmodern"
9915 "simple-date"
9916 "simple-date/postgres-glue")
9917 #:phases
9918 (modify-phases %standard-phases
9919 (add-after 'unpack 'fix-build
9920 (lambda _
9921 (substitute* "cl-postgres.asd"
9922 ((":or :sbcl :allegro :ccl :clisp" all)
9923 (string-append all " :ecl")))
9924 #t)))))))
9925
9926 (define-public sbcl-db3
9927 (let ((commit "38e5ad35f025769fb7f8dcdc6e56df3e8efd8e6d")
9928 (revision "1"))
9929 (package
9930 (name "sbcl-db3")
9931 (version (git-version "0.0.0" revision commit))
9932 (source
9933 (origin
9934 (method git-fetch)
9935 (uri (git-reference
9936 (url "https://github.com/dimitri/cl-db3")
9937 (commit commit)))
9938 (file-name (git-file-name "cl-db3" version))
9939 (sha256
9940 (base32 "1i7j0mlri6kbklcx1lsm464s8kmyhhij5c4xh4aybrw8m4ixn1s5"))))
9941 (build-system asdf-build-system/sbcl)
9942 (home-page "https://github.com/dimitri/cl-db3")
9943 (synopsis "Common Lisp library to read dBase III database files")
9944 (description
9945 "This is a Common Lisp library for processing data found in dBase III
9946 database files (dbf and db3 files).")
9947 (license license:public-domain))))
9948
9949 (define-public ecl-db3
9950 (sbcl-package->ecl-package sbcl-db3))
9951
9952 (define-public cl-db3
9953 (sbcl-package->cl-source-package sbcl-db3))
9954
9955 (define-public sbcl-dbi
9956 ;; Master includes a breaking change which other packages depend on since
9957 ;; Quicklisp decided to follow it:
9958 ;; https://github.com/fukamachi/cl-dbi/commit/31c46869722f77fd5292a81b5b101f1347d7fce1
9959 (let ((commit "31c46869722f77fd5292a81b5b101f1347d7fce1"))
9960 (package
9961 (name "sbcl-dbi")
9962 (version (git-version "0.9.4" "1" commit))
9963 (source
9964 (origin
9965 (method git-fetch)
9966 (uri (git-reference
9967 (url "https://github.com/fukamachi/cl-dbi")
9968 (commit commit)))
9969 (file-name (git-file-name name version))
9970 (sha256
9971 (base32 "0r3n4rw12qqxad0cryym2ibm4ddl49gbq4ra227afibsr43nw5k3"))))
9972 (build-system asdf-build-system/sbcl)
9973 (native-inputs
9974 `(("rove" ,sbcl-rove)
9975 ("trivial-types" ,sbcl-trivial-types)))
9976 (inputs
9977 `(("bordeaux-threads" ,sbcl-bordeaux-threads)
9978 ("cl-mysql" ,sbcl-cl-mysql)
9979 ("cl-sqlite" ,sbcl-cl-sqlite)
9980 ("closer-mop" ,sbcl-closer-mop)
9981 ("postmodern" ,sbcl-postmodern)
9982 ("split-sequence" ,sbcl-split-sequence)
9983 ("trivial-garbage" ,sbcl-trivial-garbage)))
9984 (arguments
9985 `(#:asd-systems '("dbi"
9986 "dbd-mysql"
9987 "dbd-postgres"
9988 "dbd-sqlite3")))
9989 (synopsis "Database independent interface for Common Lisp")
9990 (description
9991 "@code{dbi} is a Common Lisp library providing a database independent
9992 interface for MySQL, PostgreSQL and SQLite.")
9993 (home-page "https://github.com/fukamachi/cl-dbi")
9994 (license license:llgpl))))
9995
9996 (define-public cl-dbi
9997 (sbcl-package->cl-source-package sbcl-dbi))
9998
9999 (define-public ecl-dbi
10000 (sbcl-package->ecl-package sbcl-dbi))
10001
10002 (define-public sbcl-uffi
10003 (package
10004 (name "sbcl-uffi")
10005 (version "2.1.2")
10006 (source
10007 (origin
10008 (method git-fetch)
10009 (uri (git-reference
10010 (url "http://git.kpe.io/uffi.git")
10011 (commit (string-append "v" version))))
10012 (file-name (git-file-name name version))
10013 (sha256
10014 (base32 "1hqszvz0a3wk4s9faa83sc3vjxcb5rxmjclyr17yzwg55z733kry"))))
10015 (build-system asdf-build-system/sbcl)
10016 (arguments
10017 `(#:tests? #f ; TODO: Fix use of deprecated ASDF functions
10018 #:asd-files '("uffi.asd")
10019 #:phases
10020 (modify-phases %standard-phases
10021 (add-after 'unpack 'fix-permissions
10022 (lambda _
10023 (make-file-writable "doc/html.tar.gz")
10024 #t)))))
10025 (synopsis "Universal foreign function library for Common Lisp")
10026 (description
10027 "UFFI provides a universal foreign function interface (FFI)
10028 for Common Lisp.")
10029 (home-page "http://quickdocs.org/uffi/")
10030 (license license:llgpl)))
10031
10032 (define-public cl-uffi
10033 (package
10034 (inherit (sbcl-package->cl-source-package sbcl-uffi))
10035 (arguments
10036 `(#:phases
10037 ;; asdf-build-system/source has its own phases and does not inherit
10038 ;; from asdf-build-system/sbcl phases.
10039 (modify-phases %standard-phases/source
10040 ;; Already done in SBCL package.
10041 (delete 'reset-gzip-timestamps))))))
10042
10043 (define-public sbcl-clsql
10044 (package
10045 (name "sbcl-clsql")
10046 (version "6.7.0")
10047 (source
10048 (origin
10049 (method git-fetch)
10050 (uri (git-reference
10051 (url "http://git.kpe.io/clsql.git")
10052 (commit (string-append "v" version))))
10053 (file-name (git-file-name name version))
10054 (sha256
10055 (base32 "1v1k3s5bsy3lgd9gk459bzpb1r0kdjda25s29samxw4gsgf1fqvp"))
10056 (snippet
10057 '(begin
10058 ;; Remove precompiled libraries.
10059 (delete-file "db-mysql/clsql_mysql.dll")
10060 (delete-file "uffi/clsql_uffi.dll")
10061 (delete-file "uffi/clsql_uffi.lib")
10062 #t))))
10063 (build-system asdf-build-system/sbcl)
10064 (native-inputs
10065 `(("rt" ,sbcl-rt)))
10066 (inputs
10067 `(("cffi" ,sbcl-cffi)
10068 ("md5" ,sbcl-md5)
10069 ("mysql" ,mysql)
10070 ("postgresql" ,postgresql)
10071 ("postmodern" ,sbcl-postmodern)
10072 ("sqlite" ,sqlite)
10073 ("uffi" ,sbcl-uffi)
10074 ("zlib" ,zlib)))
10075 (arguments
10076 `(#:asd-files '("clsql.asd"
10077 "clsql-uffi.asd"
10078 "clsql-sqlite3.asd"
10079 "clsql-postgresql.asd"
10080 "clsql-postgresql-socket3.asd"
10081 "clsql-mysql.asd")
10082 #:asd-systems '("clsql"
10083 "clsql-sqlite3"
10084 "clsql-postgresql"
10085 "clsql-postgresql-socket3"
10086 "clsql-mysql")
10087 #:phases
10088 (modify-phases %standard-phases
10089 (add-after 'unpack 'fix-permissions
10090 (lambda _
10091 (make-file-writable "doc/html.tar.gz")
10092 #t))
10093 (add-after 'unpack 'fix-build
10094 (lambda _
10095 (substitute* "clsql-uffi.asd"
10096 (("\\(:version uffi \"2.0\"\\)")
10097 "uffi"))
10098 (substitute* "db-postgresql/postgresql-api.lisp"
10099 (("\\(data :cstring\\)")
10100 "(data :string)"))
10101 #t))
10102 (add-after 'unpack 'fix-paths
10103 (lambda* (#:key inputs outputs #:allow-other-keys)
10104 (substitute* "db-sqlite3/sqlite3-loader.lisp"
10105 (("libsqlite3")
10106 (string-append (assoc-ref inputs "sqlite")
10107 "/lib/libsqlite3")))
10108 (substitute* "db-postgresql/postgresql-loader.lisp"
10109 (("libpq")
10110 (string-append (assoc-ref inputs "postgresql")
10111 "/lib/libpq")))
10112 (let ((lib (string-append "#p\""
10113 (assoc-ref outputs "out")
10114 "/lib/\"")))
10115 (substitute* "clsql-mysql.asd"
10116 (("#p\"/usr/lib/clsql/clsql_mysql\\.so\"")
10117 lib))
10118 (substitute* "db-mysql/mysql-loader.lisp"
10119 (("libmysqlclient" all)
10120 (string-append (assoc-ref inputs "mysql") "/lib/" all))
10121 (("clsql-mysql-system::\\*library-file-dir\\*")
10122 lib)))
10123 #t))
10124 (add-before 'build 'build-helper-library
10125 (lambda* (#:key inputs outputs #:allow-other-keys)
10126 (let* ((mysql (assoc-ref inputs "mysql"))
10127 (inc-dir (string-append mysql "/include/mysql"))
10128 (lib-dir (string-append mysql "/lib"))
10129 (shared-lib-dir (string-append (assoc-ref outputs "out")
10130 "/lib"))
10131 (shared-lib (string-append shared-lib-dir
10132 "/clsql_mysql.so")))
10133 (mkdir-p shared-lib-dir)
10134 (invoke "gcc" "-fPIC" "-shared"
10135 "-I" inc-dir
10136 "db-mysql/clsql_mysql.c"
10137 "-Wl,-soname=clsql_mysql"
10138 "-L" lib-dir "-lmysqlclient" "-lz"
10139 "-o" shared-lib)
10140 #t)))
10141 (add-after 'unpack 'fix-tests
10142 (lambda _
10143 (substitute* "clsql.asd"
10144 (("clsql-tests :force t")
10145 "clsql-tests"))
10146 #t)))))
10147 (synopsis "Common Lisp SQL Interface library")
10148 (description
10149 "@code{clsql} is a Common Lisp interface to SQL RDBMS based on the
10150 Xanalys CommonSQL interface for Lispworks. It provides low-level database
10151 interfaces as well as a functional and an object oriented interface.")
10152 (home-page "http://clsql.kpe.io/")
10153 (license license:llgpl)))
10154
10155 (define-public cl-clsql
10156 (package
10157 (inherit (sbcl-package->cl-source-package sbcl-clsql))
10158 (native-inputs
10159 `(("rt" ,cl-rt)))
10160 (inputs
10161 `(("mysql" ,mysql)
10162 ("postgresql" ,postgresql)
10163 ("sqlite" ,sqlite)
10164 ("zlib" ,zlib)))
10165 (propagated-inputs
10166 `(("cffi" ,cl-cffi)
10167 ("md5" ,cl-md5)
10168 ("postmodern" ,cl-postmodern)
10169 ("uffi" ,cl-uffi)))
10170 (arguments
10171 `(#:phases
10172 ;; asdf-build-system/source has its own phases and does not inherit
10173 ;; from asdf-build-system/sbcl phases.
10174 (modify-phases %standard-phases/source
10175 (add-after 'unpack 'fix-permissions
10176 (lambda _
10177 (make-file-writable "doc/html.tar.gz")
10178 #t)))))))
10179
10180 (define-public ecl-clsql
10181 (let ((pkg (sbcl-package->ecl-package sbcl-clsql)))
10182 (package
10183 (inherit pkg)
10184 (inputs
10185 (alist-delete "uffi" (package-inputs pkg)))
10186 (arguments
10187 (substitute-keyword-arguments (package-arguments pkg)
10188 ((#:asd-files asd-files '())
10189 `(cons "clsql-cffi.asd" ,asd-files)))))))
10190
10191 (define-public sbcl-sycamore
10192 (let ((commit "fd2820fec165ad514493426dea209728f64e6d18"))
10193 (package
10194 (name "sbcl-sycamore")
10195 (version "0.0.20120604")
10196 (source
10197 (origin
10198 (method git-fetch)
10199 (uri (git-reference
10200 (url "https://github.com/ndantam/sycamore/")
10201 (commit commit)))
10202 (file-name (git-file-name name version))
10203 (sha256
10204 (base32 "00bv1aj89q5vldmq92zp2364jq312zjq2mbd3iyz1s2b4widzhl7"))))
10205 (build-system asdf-build-system/sbcl)
10206 (inputs
10207 `(("alexandria" ,sbcl-alexandria)
10208 ("cl-ppcre" ,sbcl-cl-ppcre)))
10209 (synopsis "Purely functional data structure library in Common Lisp")
10210 (description
10211 "Sycamore is a fast, purely functional data structure library in Common Lisp.
10212 If features:
10213
10214 @itemize
10215 @item Fast, purely functional weight-balanced binary trees.
10216 @item Leaf nodes are simple-vectors, greatly reducing tree height.
10217 @item Interfaces for tree Sets and Maps (dictionaries).
10218 @item Ropes.
10219 @item Purely functional pairing heaps.
10220 @item Purely functional amortized queue.
10221 @end itemize\n")
10222 (home-page "http://ndantam.github.io/sycamore/")
10223 (license license:bsd-3))))
10224
10225 (define-public cl-sycamore
10226 (sbcl-package->cl-source-package sbcl-sycamore))
10227
10228 (define-public ecl-sycamore
10229 (sbcl-package->ecl-package sbcl-sycamore))
10230
10231 (define-public sbcl-trivial-package-local-nicknames
10232 (package
10233 (name "sbcl-trivial-package-local-nicknames")
10234 (version "0.2")
10235 (home-page "https://github.com/phoe/trivial-package-local-nicknames")
10236 (source
10237 (origin
10238 (method git-fetch)
10239 (uri (git-reference
10240 (url home-page)
10241 (commit "16b7ad4c2b120f50da65154191f468ea5598460e")))
10242 (file-name (git-file-name name version))
10243 (sha256
10244 (base32 "18qc27xkjzdcqrilpk3pm7djldwq5rm3ggd5h9cr8hqcd54i2fqg"))))
10245 (build-system asdf-build-system/sbcl)
10246 (synopsis "Common Lisp compatibility library for package local nicknames")
10247 (description
10248 "This library is a portable compatibility layer around package local nicknames (PLN).
10249 This was done so there is a portability library for the PLN API not included
10250 in DEFPACKAGE.")
10251 (license license:unlicense)))
10252
10253 (define-public cl-trivial-package-local-nicknames
10254 (sbcl-package->cl-source-package sbcl-trivial-package-local-nicknames))
10255
10256 (define-public ecl-trivial-package-local-nicknames
10257 (sbcl-package->ecl-package sbcl-trivial-package-local-nicknames))
10258
10259 (define-public sbcl-enchant
10260 (let ((commit "6af162a7bf10541cbcfcfa6513894900329713fa"))
10261 (package
10262 (name "sbcl-enchant")
10263 (version (git-version "0.0.0" "1" commit))
10264 (home-page "https://github.com/tlikonen/cl-enchant")
10265 (source
10266 (origin
10267 (method git-fetch)
10268 (uri (git-reference
10269 (url home-page)
10270 (commit commit)))
10271 (file-name (git-file-name name version))
10272 (sha256
10273 (base32 "19yh5ihirzi1d8xqy1cjqipzd6ly3245cfxa5s9xx496rryz0s01"))))
10274 (build-system asdf-build-system/sbcl)
10275 (inputs
10276 `(("enchant" ,enchant)
10277 ("cffi" ,sbcl-cffi)))
10278 (arguments
10279 `(#:phases
10280 (modify-phases %standard-phases
10281 (add-after 'unpack 'fix-paths
10282 (lambda* (#:key inputs #:allow-other-keys)
10283 (substitute* "load-enchant.lisp"
10284 (("libenchant")
10285 (string-append
10286 (assoc-ref inputs "enchant") "/lib/libenchant-2"))))))))
10287 (synopsis "Common Lisp interface for the Enchant spell-checker library")
10288 (description
10289 "Enchant is a Common Lisp interface for the Enchant spell-checker
10290 library. The Enchant library is a generic spell-checker library which uses
10291 other spell-checkers transparently as back-end. The library supports the
10292 multiple checkers, including Aspell and Hunspell.")
10293 (license license:public-domain))))
10294
10295 (define-public cl-enchant
10296 (sbcl-package->cl-source-package sbcl-enchant))
10297
10298 (define-public ecl-enchant
10299 (sbcl-package->ecl-package sbcl-enchant))
10300
10301 (define-public sbcl-cl-change-case
10302 (let ((commit "45c70b601125889689e0c1c37d7e727a3a0af022")
10303 (revision "1"))
10304 (package
10305 (name "sbcl-cl-change-case")
10306 (version (git-version "0.2.0" revision commit))
10307 (home-page "https://github.com/rudolfochrist/cl-change-case")
10308 (source
10309 (origin
10310 (method git-fetch)
10311 (uri (git-reference
10312 (url home-page)
10313 (commit commit)))
10314 (file-name (git-file-name "cl-change-case" version))
10315 (sha256
10316 (base32 "0qmk341zzcsbf8sq0w9ix3r080zg4ri6vzxym63lhdjfzwz3y8if"))))
10317 (build-system asdf-build-system/sbcl)
10318 (inputs
10319 `(("cl-ppcre" ,sbcl-cl-ppcre)
10320 ("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)))
10321 (native-inputs
10322 `(("fiveam" ,sbcl-fiveam)))
10323 (synopsis
10324 "Convert Common Lisp strings between camelCase, PascalCase and more")
10325 (description
10326 "@code{cl-change-case} is a library to convert strings between
10327 camelCase, PascalCase, snake_case, param-case, CONSTANT_CASE and more.")
10328 (license license:llgpl))))
10329
10330 (define-public cl-change-case
10331 (sbcl-package->cl-source-package sbcl-cl-change-case))
10332
10333 (define-public ecl-cl-change-case
10334 (sbcl-package->ecl-package sbcl-cl-change-case))
10335
10336 (define-public sbcl-modularize
10337 (let ((commit "86c5d9a11fbd2df9f0f03ac10b5d71837c8934ba")
10338 (revision "1"))
10339 (package
10340 (name "sbcl-modularize")
10341 (version (git-version "1.0.0" revision commit))
10342 (source
10343 (origin
10344 (method git-fetch)
10345 (uri (git-reference
10346 (url "https://github.com/Shinmera/modularize")
10347 (commit commit)))
10348 (file-name (git-file-name name version))
10349 (sha256
10350 (base32 "1zys29rfkb649rkgl3snxhajk8d5yf7ryxkrwy020kwdh7zdsg7d"))))
10351 (build-system asdf-build-system/sbcl)
10352 (arguments
10353 `(#:test-asd-file "modularize-test-module.asd"
10354 #:asd-files '("modularize.asd" "modularize-test-module.asd")
10355 #:asd-systems '("modularize" "modularize-test-module")))
10356 (inputs
10357 `(("documentation-utils" ,sbcl-documentation-utils)
10358 ("trivial-package-local-nicknames" ,sbcl-trivial-package-local-nicknames)))
10359 (home-page "https://shinmera.github.io/modularize/")
10360 (synopsis "Common Lisp modularization framework")
10361 (description
10362 "@code{MODULARIZE} is an attempt at providing a common interface to
10363 segregate major application components. This is achieved by adding special
10364 treatment to packages. Each module is a package that is specially registered,
10365 which allows it to interact and co-exist with other modules in better ways. For
10366 instance, by adding module definition options you can introduce mechanisms to
10367 tie modules together in functionality, hook into each other and so on.")
10368 (license license:zlib))))
10369
10370 (define-public ecl-modularize
10371 (sbcl-package->ecl-package sbcl-modularize))
10372
10373 (define-public cl-modularize
10374 (sbcl-package->cl-source-package sbcl-modularize))
10375
10376 (define-public sbcl-modularize-hooks
10377 (let ((commit "e0348ed3ffd59a9ec31ca4ab28289e748bfbf96a")
10378 (revision "1"))
10379 (package
10380 (name "sbcl-modularize-hooks")
10381 (version (git-version "1.0.2" revision commit))
10382 (source
10383 (origin
10384 (method git-fetch)
10385 (uri (git-reference
10386 (url "https://github.com/Shinmera/modularize-hooks")
10387 (commit commit)))
10388 (file-name (git-file-name "modularize-hooks" version))
10389 (sha256
10390 (base32 "12kjvin8hxidwkzfb7inqv5b6g5qzcssnj9wc497v2ixc56fqdz7"))))
10391 (build-system asdf-build-system/sbcl)
10392 (inputs
10393 `(("closer-mop" ,sbcl-closer-mop)
10394 ("lambda-fiddle" ,sbcl-lambda-fiddle)
10395 ("modularize" ,sbcl-modularize)
10396 ("trivial-arguments" ,sbcl-trivial-arguments)))
10397 (home-page "https://shinmera.github.io/modularize-hooks/")
10398 (synopsis "Generic hooks and triggers extension for Modularize")
10399 (description
10400 "This is a simple extension to @code{MODULARIZE} that allows modules to
10401 define and trigger hooks, which other modules can hook on to.")
10402 (license license:zlib))))
10403
10404 (define-public ecl-modularize-hooks
10405 (sbcl-package->ecl-package sbcl-modularize-hooks))
10406
10407 (define-public cl-modularize-hooks
10408 (sbcl-package->cl-source-package sbcl-modularize-hooks))
10409
10410 (define-public sbcl-modularize-interfaces
10411 (let ((commit "96353657afb8c7aeba7ef5b51eb04c5ed3bcb6ef")
10412 (revision "1"))
10413 (package
10414 (name "sbcl-modularize-interfaces")
10415 (version (git-version "0.9.3" revision commit))
10416 (source
10417 (origin
10418 (method git-fetch)
10419 (uri (git-reference
10420 (url "https://github.com/Shinmera/modularize-interfaces")
10421 (commit commit)))
10422 (file-name (git-file-name "modularize-interfaces" version))
10423 (sha256
10424 (base32 "0bjf4wy39cwf75m7vh0r7mmcchs09yz2lrbyap98hnq8blq70fhc"))))
10425 (build-system asdf-build-system/sbcl)
10426 (inputs
10427 `(("lambda-fiddle" ,sbcl-lambda-fiddle)
10428 ("modularize" ,sbcl-modularize)
10429 ("trivial-arguments" ,sbcl-trivial-arguments)
10430 ("trivial-indent" ,sbcl-trivial-indent)))
10431 (home-page "https://shinmera.github.io/modularize-interfaces/")
10432 (synopsis "Programmatical interfaces extension for Modularize")
10433 (description
10434 "This is an extension to @code{MODULARIZE} that allows your application
10435 to define interfaces in-code that serve both as a primary documentation and as
10436 compliance control.")
10437 (license license:zlib))))
10438
10439 (define-public ecl-modularize-interfaces
10440 (sbcl-package->ecl-package sbcl-modularize-interfaces))
10441
10442 (define-public cl-modularize-interfaces
10443 (sbcl-package->cl-source-package sbcl-modularize-interfaces))
10444
10445 (define-public sbcl-moptilities
10446 (let ((commit "a436f16b357c96b82397ec018ea469574c10dd41"))
10447 (package
10448 (name "sbcl-moptilities")
10449 (version (git-version "0.3.13" "1" commit))
10450 (home-page "https://github.com/gwkkwg/moptilities/")
10451 (source
10452 (origin
10453 (method git-fetch)
10454 (uri (git-reference
10455 (url home-page)
10456 (commit commit)))
10457 (file-name (git-file-name name version))
10458 (sha256
10459 (base32 "1q12bqjbj47lx98yim1kfnnhgfhkl80102fkgp9pdqxg0fp6g5fc"))))
10460 (build-system asdf-build-system/sbcl)
10461 (inputs
10462 `(("closer-mop" ,sbcl-closer-mop)))
10463 (native-inputs
10464 `(("lift" ,sbcl-lift)))
10465 (arguments
10466 `(#:phases
10467 (modify-phases %standard-phases
10468 (add-after 'unpack 'fix-tests
10469 (lambda _
10470 (substitute* "lift-standard.config"
10471 ((":relative-to lift-test")
10472 ":relative-to moptilities-test"))
10473 #t)))))
10474 (synopsis "Compatibility layer for Common Lisp MOP implementation differences")
10475 (description
10476 "MOP utilities provide a common interface between Lisps and make the
10477 MOP easier to use.")
10478 (license license:expat))))
10479
10480 (define-public cl-moptilities
10481 (sbcl-package->cl-source-package sbcl-moptilities))
10482
10483 (define-public sbcl-osicat
10484 (let ((commit "de0c18a367eedc857e1902a7319828af072a0d97"))
10485 (package
10486 (name "sbcl-osicat")
10487 (version (git-version "0.7.0" "1" commit))
10488 (home-page "http://www.common-lisp.net/project/osicat/")
10489 (source
10490 (origin
10491 (method git-fetch)
10492 (uri (git-reference
10493 (url "https://github.com/osicat/osicat")
10494 (commit commit)))
10495 (file-name (git-file-name name version))
10496 (sha256
10497 (base32 "15viw5pi5sa7qq9b4n2rr3dj2jkqr180rh9z1lh8w3rgl42i2adc"))))
10498 (build-system asdf-build-system/sbcl)
10499 (inputs
10500 `(("alexandria" ,sbcl-alexandria)
10501 ("cffi" ,sbcl-cffi)
10502 ("trivial-features" ,sbcl-trivial-features)))
10503 (native-inputs
10504 `(("rt" ,sbcl-rt)))
10505 (synopsis "Operating system interface for Common Lisp")
10506 (description
10507 "Osicat is a lightweight operating system interface for Common Lisp on
10508 Unix-platforms. It is not a POSIX-style API, but rather a simple lispy
10509 accompaniment to the standard ANSI facilities.")
10510 (license license:expat))))
10511
10512 (define-public cl-osicat
10513 (sbcl-package->cl-source-package sbcl-osicat))
10514
10515 (define-public ecl-osicat
10516 (sbcl-package->ecl-package sbcl-osicat))
10517
10518 (define-public sbcl-clx-xembed
10519 (let ((commit "a5c4b844d31ee68ffa58c933cc1cdddde6990743")
10520 (revision "1"))
10521 (package
10522 (name "sbcl-clx-xembed")
10523 (version (git-version "0.1" revision commit))
10524 (home-page "https://github.com/laynor/clx-xembed")
10525 (source
10526 (origin
10527 (method git-fetch)
10528 (uri (git-reference
10529 (url "https://github.com/laynor/clx-xembed")
10530 (commit commit)))
10531 (file-name (git-file-name name version))
10532 (sha256
10533 (base32 "1abx4v36ycmfjdwpjk4hh8058ya8whwia7ds9vd96q2qsrs57f12"))))
10534 (build-system asdf-build-system/sbcl)
10535 (arguments
10536 `(#:asd-systems '("xembed")))
10537 (inputs
10538 `(("sbcl-clx" ,sbcl-clx)))
10539 (synopsis "CL(x) xembed protocol implementation ")
10540 (description "CL(x) xembed protocol implementation")
10541 ;; MIT License
10542 (license license:expat))))
10543
10544 (define-public cl-clx-xembed
10545 (sbcl-package->cl-source-package sbcl-clx-xembed))
10546
10547 (define-public ecl-clx-xembed
10548 (sbcl-package->ecl-package sbcl-clx-xembed))
10549
10550 (define-public sbcl-quantile-estimator
10551 (package
10552 (name "sbcl-quantile-estimator")
10553 (version "0.0.1")
10554 (source
10555 (origin
10556 (method git-fetch)
10557 (uri (git-reference
10558 (url "https://github.com/deadtrickster/quantile-estimator.cl")
10559 (commit "84d0ea405d793f5e808c68c4ddaf25417b0ff8e5")))
10560 (file-name (git-file-name name version))
10561 (sha256
10562 (base32
10563 "0rlswkf0siaabsvvch3dgxmg45fw5w8pd9b7ri2w7a298aya52z9"))))
10564 (build-system asdf-build-system/sbcl)
10565 (arguments
10566 '(#:asd-files '("quantile-estimator.asd")))
10567 (inputs
10568 `(("alexandria" ,sbcl-alexandria)))
10569 (home-page "https://github.com/deadtrickster/quantile-estimator.cl")
10570 (synopsis
10571 "Effective computation of biased quantiles over data streams")
10572 (description
10573 "Common Lisp implementation of Graham Cormode and S.
10574 Muthukrishnan's Effective Computation of Biased Quantiles over Data
10575 Streams in ICDE’05.")
10576 (license license:expat)))
10577
10578 (define-public cl-quantile-estimator
10579 (sbcl-package->cl-source-package sbcl-quantile-estimator))
10580
10581 (define-public ecl-quantile-estimator
10582 (sbcl-package->ecl-package sbcl-quantile-estimator))
10583
10584 (define-public sbcl-prometheus
10585 (package
10586 (name "sbcl-prometheus")
10587 (version "0.4.1")
10588 (source
10589 (origin
10590 (method git-fetch)
10591 (uri (git-reference
10592 (url "https://github.com/deadtrickster/prometheus.cl")
10593 (commit "7352b92296996ff383503e19bdd3bcea30409a15")))
10594 (file-name (git-file-name name version))
10595 (sha256
10596 (base32
10597 "0fzczls2kfgdx18pja4lqxjrz72i583185d8nq0pb3s331hhzh0z"))))
10598 (build-system asdf-build-system/sbcl)
10599 (inputs
10600 `(("alexandria" ,sbcl-alexandria)
10601 ("bordeaux-threads" ,sbcl-bordeaux-threads)
10602 ("cffi" ,sbcl-cffi)
10603 ("cl-fad" ,sbcl-cl-fad)
10604 ("cl-ppcre" ,sbcl-cl-ppcre)
10605 ("drakma" ,sbcl-drakma)
10606 ("hunchentoot" ,sbcl-hunchentoot)
10607 ("local-time" ,sbcl-local-time)
10608 ("quantile-estimator" ,sbcl-quantile-estimator)
10609 ("salza2" ,sbcl-salza2)
10610 ("split-sequence" ,sbcl-split-sequence)
10611 ("trivial-utf-8" ,sbcl-trivial-utf-8)))
10612 (arguments
10613 '(#:asd-files '("prometheus.asd"
10614 "prometheus.collectors.sbcl.asd"
10615 "prometheus.collectors.process.asd"
10616 "prometheus.formats.text.asd"
10617 "prometheus.exposers.hunchentoot.asd"
10618 "prometheus.pushgateway.asd")
10619 #:asd-systems '("prometheus"
10620 "prometheus.collectors.sbcl"
10621 "prometheus.collectors.process"
10622 "prometheus.formats.text"
10623 "prometheus.exposers.hunchentoot"
10624 "prometheus.pushgateway")))
10625 (home-page "https://github.com/deadtrickster/prometheus.cl")
10626 (synopsis "Prometheus.io Common Lisp client")
10627 (description "Prometheus.io Common Lisp client.")
10628 (license license:expat)))
10629
10630 (define-public cl-prometheus
10631 (sbcl-package->cl-source-package sbcl-prometheus))
10632
10633 (define-public ecl-prometheus
10634 (sbcl-package->ecl-package sbcl-prometheus))
10635
10636 (define-public sbcl-uuid
10637 (let ((commit "e7d6680c3138385c0708f7aaf0c96622eeb140e8"))
10638 (package
10639 (name "sbcl-uuid")
10640 (version (git-version "2012.12.26" "1" commit))
10641 (source
10642 (origin
10643 (method git-fetch)
10644 (uri (git-reference
10645 (url "https://github.com/dardoria/uuid")
10646 (commit commit)))
10647 (file-name (git-file-name name version))
10648 (sha256
10649 (base32
10650 "0jnyp2kibcf5cwi60l6grjrj8wws9chasjvsw7xzwyym2lyid46f"))))
10651 (build-system asdf-build-system/sbcl)
10652 (inputs
10653 `(("ironclad" ,sbcl-ironclad)
10654 ("trivial-utf-8" ,sbcl-trivial-utf-8)))
10655 (home-page "https://github.com/dardoria/uuid")
10656 (synopsis
10657 "Common Lisp implementation of UUIDs according to RFC4122")
10658 (description
10659 "Common Lisp implementation of UUIDs according to RFC4122.")
10660 (license license:llgpl))))
10661
10662 (define-public cl-uuid
10663 (sbcl-package->cl-source-package sbcl-uuid))
10664
10665 (define-public ecl-uuid
10666 (sbcl-package->ecl-package sbcl-uuid))
10667
10668 (define-public sbcl-dissect
10669 (let ((commit "cffd38479f0e64e805f167bbdb240b783ecc8d45"))
10670 (package
10671 (name "sbcl-dissect")
10672 (version (git-version "1.0.0" "1" commit))
10673 (source
10674 (origin
10675 (method git-fetch)
10676 (uri (git-reference
10677 (url "https://github.com/Shinmera/dissect")
10678 (commit commit)))
10679 (file-name (git-file-name name version))
10680 (sha256
10681 (base32
10682 "0rmsjkgjl90gl6ssvgd60hb0d5diyhsiyypvw9hbc0ripvbmk5r5"))))
10683 (build-system asdf-build-system/sbcl)
10684 (inputs
10685 `(("cl-ppcre" ,sbcl-cl-ppcre)))
10686 (home-page "https://shinmera.github.io/dissect/")
10687 (synopsis
10688 "Introspection library for the call stack and restarts")
10689 (description
10690 "Dissect is a small Common Lisp library for introspecting the call stack
10691 and active restarts.")
10692 (license license:zlib))))
10693
10694 (define-public cl-dissect
10695 (sbcl-package->cl-source-package sbcl-dissect))
10696
10697 (define-public ecl-dissect
10698 (sbcl-package->ecl-package sbcl-dissect))
10699
10700 (define-public sbcl-rove
10701 (package
10702 (name "sbcl-rove")
10703 (version "0.9.6")
10704 (source
10705 (origin
10706 (method git-fetch)
10707 (uri (git-reference
10708 (url "https://github.com/fukamachi/rove")
10709 (commit "f3695db08203bf26f3b861dc22ac0f4257d3ec21")))
10710 (file-name (git-file-name name version))
10711 (sha256
10712 (base32
10713 "07ala4l2fncxf540fzxj3h5mhi9i4wqllhj0rqk8m2ljl5zbz89q"))))
10714 (build-system asdf-build-system/sbcl)
10715 (inputs
10716 `(("bordeaux-threads" ,sbcl-bordeaux-threads)
10717 ("dissect" ,sbcl-dissect)
10718 ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
10719 (home-page "https://github.com/fukamachi/rove")
10720 (synopsis
10721 "Yet another common lisp testing library")
10722 (description
10723 "Rove is a unit testing framework for Common Lisp applications.
10724 This is intended to be a successor of Prove.")
10725 (license license:bsd-3)))
10726
10727 (define-public cl-rove
10728 (sbcl-package->cl-source-package sbcl-rove))
10729
10730 (define-public ecl-rove
10731 (sbcl-package->ecl-package sbcl-rove))
10732
10733 (define-public sbcl-exponential-backoff
10734 (let ((commit "8d9e8444d8b3184a524c12ce3449f91613ab714f"))
10735 (package
10736 (name "sbcl-exponential-backoff")
10737 (version (git-version "0" "1" commit))
10738 (source
10739 (origin
10740 (method git-fetch)
10741 (uri (git-reference
10742 (url "https://github.com/death/exponential-backoff")
10743 (commit commit)))
10744 (file-name (git-file-name name version))
10745 (sha256
10746 (base32
10747 "1389hm9hxv85s0125ja4js1bvh8ay4dsy9q1gaynjv27ynik6gmv"))))
10748 (build-system asdf-build-system/sbcl)
10749 (home-page "https://github.com/death/exponential-backoff")
10750 (synopsis "Exponential backoff algorithm in Common Lisp")
10751 (description
10752 "An implementation of the exponential backoff algorithm in Common Lisp.
10753 Inspired by the implementation found in Chromium. Read the header file to
10754 learn about each of the parameters.")
10755 (license license:expat))))
10756
10757 (define-public cl-exponential-backoff
10758 (sbcl-package->cl-source-package sbcl-exponential-backoff))
10759
10760 (define-public ecl-exponential-backoff
10761 (sbcl-package->ecl-package sbcl-exponential-backoff))
10762
10763 (define-public sbcl-sxql
10764 (let ((commit "5aa8b739492c5829e8623432b5d46482263990e8"))
10765 (package
10766 (name "sbcl-sxql")
10767 (version (git-version "0.1.0" "1" commit))
10768 (source
10769 (origin
10770 (method git-fetch)
10771 (uri (git-reference
10772 (url "https://github.com/fukamachi/sxql")
10773 (commit commit)))
10774 (file-name (git-file-name name version))
10775 (sha256
10776 (base32
10777 "0k25p6w2ld9cn8q8s20lda6yjfyp4q89219sviayfgixnj27avnj"))))
10778 (build-system asdf-build-system/sbcl)
10779 (arguments
10780 `(#:test-asd-file "sxql-test.asd"))
10781 (inputs
10782 `(("alexandria" ,sbcl-alexandria)
10783 ("cl-syntax" ,sbcl-cl-syntax)
10784 ("iterate" ,sbcl-iterate)
10785 ("optima" ,sbcl-optima)
10786 ("split-sequence" ,sbcl-split-sequence)
10787 ("trivial-types" ,sbcl-trivial-types)))
10788 (native-inputs
10789 `(("prove" ,sbcl-prove)))
10790 (home-page "https://github.com/fukamachi/sxql")
10791 (synopsis "SQL generator for Common Lisp")
10792 (description "SQL generator for Common Lisp.")
10793 (license license:bsd-3))))
10794
10795 (define-public cl-sxql
10796 (sbcl-package->cl-source-package sbcl-sxql))
10797
10798 (define-public ecl-sxql
10799 (sbcl-package->ecl-package sbcl-sxql))
10800
10801 (define-public sbcl-1am
10802 (let ((commit "8b1da94eca4613fd8a20bdf63f0e609e379b0ba5"))
10803 (package
10804 (name "sbcl-1am")
10805 (version (git-version "0.0" "1" commit))
10806 (source
10807 (origin
10808 (method git-fetch)
10809 (uri (git-reference
10810 (url "https://github.com/lmj/1am")
10811 (commit commit)))
10812 (file-name (git-file-name name version))
10813 (sha256
10814 (base32
10815 "05ss4nz1jb9kb796295482b62w5cj29msfj8zis33sp2rw2vmv2g"))))
10816 (build-system asdf-build-system/sbcl)
10817 (arguments
10818 `(#:asd-systems '("1am")))
10819 (home-page "https://github.com/lmj/1am")
10820 (synopsis "Minimal testing framework for Common Lisp")
10821 (description "A minimal testing framework for Common Lisp.")
10822 (license license:expat))))
10823
10824 (define-public cl-1am
10825 (sbcl-package->cl-source-package sbcl-1am))
10826
10827 (define-public ecl-1am
10828 (sbcl-package->ecl-package sbcl-1am))
10829
10830 (define-public sbcl-cl-ascii-table
10831 (let ((commit "d9f5e774a56fad1b416e4dadb8f8a5b0e84094e2")
10832 (revision "1"))
10833 (package
10834 (name "sbcl-cl-ascii-table")
10835 (version (git-version "0.0.0" revision commit))
10836 (source
10837 (origin
10838 (method git-fetch)
10839 (uri (git-reference
10840 (url "https://github.com/telephil/cl-ascii-table")
10841 (commit commit)))
10842 (file-name (git-file-name name version))
10843 (sha256
10844 (base32 "125fdif9sgl7k0ngjhxv0wjas2q27d075025hvj2rx1b1x948z4s"))))
10845 (build-system asdf-build-system/sbcl)
10846 (synopsis "Library to make ascii-art tables")
10847 (description
10848 "This is a Common Lisp library to present tabular data in ascii-art
10849 tables.")
10850 (home-page "https://github.com/telephil/cl-ascii-table")
10851 (license license:expat))))
10852
10853 (define-public cl-ascii-table
10854 (sbcl-package->cl-source-package sbcl-cl-ascii-table))
10855
10856 (define-public ecl-cl-ascii-table
10857 (sbcl-package->ecl-package sbcl-cl-ascii-table))
10858
10859 (define-public sbcl-cl-rdkafka
10860 (package
10861 (name "sbcl-cl-rdkafka")
10862 (version "1.1.0")
10863 (source
10864 (origin
10865 (method git-fetch)
10866 (uri (git-reference
10867 (url "https://github.com/SahilKang/cl-rdkafka")
10868 (commit (string-append "v" version))))
10869 (file-name (git-file-name name version))
10870 (sha256
10871 (base32
10872 "0z2g0k0xy8k1p9g93h8dy9wbygaq7ziwagm4yz93zk67mhc0b84v"))))
10873 (build-system asdf-build-system/sbcl)
10874 (arguments
10875 `(#:tests? #f ; Attempts to connect to locally running Kafka
10876 #:phases
10877 (modify-phases %standard-phases
10878 (add-after 'unpack 'fix-paths
10879 (lambda* (#:key inputs #:allow-other-keys)
10880 (substitute* "src/low-level/librdkafka-bindings.lisp"
10881 (("librdkafka" all)
10882 (string-append (assoc-ref inputs "librdkafka") "/lib/"
10883 all))))))))
10884 (inputs
10885 `(("bordeaux-threads" ,sbcl-bordeaux-threads)
10886 ("cffi" ,sbcl-cffi)
10887 ("librdkafka" ,librdkafka)
10888 ("lparallel" ,sbcl-lparallel)
10889 ("trivial-garbage" ,sbcl-trivial-garbage)))
10890 (home-page "https://github.com/SahilKang/cl-rdkafka")
10891 (synopsis "Common Lisp client library for Apache Kafka")
10892 (description "A Common Lisp client library for Apache Kafka.")
10893 (license license:gpl3)))
10894
10895 (define-public cl-rdkafka
10896 (sbcl-package->cl-source-package sbcl-cl-rdkafka))
10897
10898 (define-public ecl-cl-rdkafka
10899 (sbcl-package->ecl-package sbcl-cl-rdkafka))
10900
10901 (define-public sbcl-acclimation
10902 (let ((commit "4d51150902568fcd59335f4cc4cfa022df6116a5"))
10903 (package
10904 (name "sbcl-acclimation")
10905 (version (git-version "0.0.0" "1" commit))
10906 (source
10907 (origin
10908 (method git-fetch)
10909 (uri (git-reference
10910 (url "https://github.com/robert-strandh/Acclimation")
10911 (commit commit)))
10912 (file-name (git-file-name name version))
10913 (sha256
10914 (base32
10915 "1aw7rarjl8ai57h0jxnp9hr3dka7qrs55mmbl1p6rhd6xj8mp9wq"))))
10916 (build-system asdf-build-system/sbcl)
10917 (home-page "https://github.com/robert-strandh/Acclimation")
10918 (synopsis "Internationalization library for Common Lisp")
10919 (description "This project is meant to provide tools for
10920 internationalizing Common Lisp programs.
10921
10922 One important aspect of internationalization is of course the language used in
10923 error messages, documentation strings, etc. But with this project we provide
10924 tools for all other aspects of internationalization as well, including dates,
10925 weight, temperature, names of physical quantitites, etc.")
10926 (license license:bsd-2))))
10927
10928 (define-public cl-acclimation
10929 (sbcl-package->cl-source-package sbcl-acclimation))
10930
10931 (define-public ecl-acclimation
10932 (sbcl-package->ecl-package sbcl-acclimation))
10933
10934 (define-public sbcl-clump
10935 (let ((commit "1ea4dbac1cb86713acff9ae58727dd187d21048a"))
10936 (package
10937 (name "sbcl-clump")
10938 (version (git-version "0.0.0" "1" commit))
10939 (source
10940 (origin
10941 (method git-fetch)
10942 (uri (git-reference
10943 (url "https://github.com/robert-strandh/Clump")
10944 (commit commit)))
10945 (file-name (git-file-name name version))
10946 (sha256
10947 (base32
10948 "1639msyagsswj85gc0wd90jgh8588j3qg5q70by9s2brf2q6w4lh"))))
10949 (inputs
10950 `(("acclimation" ,sbcl-acclimation)))
10951 (build-system asdf-build-system/sbcl)
10952 (home-page "https://github.com/robert-strandh/Clump")
10953 (synopsis "Collection of tree implementations for Common Lisp")
10954 (description "The purpose of this library is to provide a collection of
10955 implementations of trees.
10956
10957 In contrast to existing libraries such as cl-containers, it does not impose a
10958 particular use for the trees. Instead, it aims for a stratified design,
10959 allowing client code to choose between different levels of abstraction.
10960
10961 As a consequence of this policy, low-level interfaces are provided where
10962 the concrete representation is exposed, but also high level interfaces
10963 where the trees can be used as search trees or as trees that represent
10964 sequences of objects.")
10965 (license license:bsd-2))))
10966
10967 (define-public cl-clump
10968 (sbcl-package->cl-source-package sbcl-clump))
10969
10970 (define-public ecl-clump
10971 (sbcl-package->ecl-package sbcl-clump))
10972
10973 (define-public sbcl-cluffer
10974 (let ((commit "4aad29c276a58a593064e79972ee4d77cae0af4a"))
10975 (package
10976 (name "sbcl-cluffer")
10977 (version (git-version "0.0.0" "1" commit))
10978 (source
10979 (origin
10980 (method git-fetch)
10981 (uri (git-reference
10982 (url "https://github.com/robert-strandh/cluffer")
10983 (commit commit)))
10984 (file-name (git-file-name name version))
10985 (sha256
10986 (base32
10987 "1bcg13g7qb3dr8z50aihdjqa6miz5ivlc9wsj2csgv1km1mak2kj"))))
10988 (build-system asdf-build-system/sbcl)
10989 (inputs
10990 `(("acclimation" ,sbcl-acclimation)
10991 ("clump" ,sbcl-clump)))
10992 (home-page "https://github.com/robert-strandh/cluffer")
10993 (synopsis "Common Lisp library providing a protocol for text-editor buffers")
10994 (description "Cluffer is a library for representing the buffer of a text
10995 editor. As such, it defines a set of CLOS protocols for client code to
10996 interact with the buffer contents in various ways, and it supplies different
10997 implementations of those protocols for different purposes.")
10998 (license license:bsd-2))))
10999
11000 (define-public cl-cluffer
11001 (sbcl-package->cl-source-package sbcl-cluffer))
11002
11003 (define-public ecl-cluffer
11004 (sbcl-package->ecl-package sbcl-cluffer))
11005
11006 (define-public sbcl-cl-libsvm-format
11007 (let ((commit "3300f84fd8d9f5beafc114f543f9d83417c742fb")
11008 (revision "0"))
11009 (package
11010 (name "sbcl-cl-libsvm-format")
11011 (version (git-version "0.1.0" revision commit))
11012 (source
11013 (origin
11014 (method git-fetch)
11015 (uri (git-reference
11016 (url "https://github.com/masatoi/cl-libsvm-format")
11017 (commit commit)))
11018 (file-name (git-file-name name version))
11019 (sha256
11020 (base32
11021 "0284aj84xszhkhlivaigf9qj855fxad3mzmv3zfr0qzb5k0nzwrg"))))
11022 (build-system asdf-build-system/sbcl)
11023 (native-inputs
11024 `(("prove" ,sbcl-prove)))
11025 (inputs
11026 `(("alexandria" ,sbcl-alexandria)))
11027 (synopsis "LibSVM data format reader for Common Lisp")
11028 (description
11029 "This Common Lisp library provides a fast reader for data in LibSVM
11030 format.")
11031 (home-page "https://github.com/masatoi/cl-libsvm-format")
11032 (license license:expat))))
11033
11034 (define-public cl-libsvm-format
11035 (sbcl-package->cl-source-package sbcl-cl-libsvm-format))
11036
11037 (define-public ecl-cl-libsvm-format
11038 (sbcl-package->ecl-package sbcl-cl-libsvm-format))
11039
11040 (define-public sbcl-cl-online-learning
11041 (let ((commit "87fbef8a340219e853adb3a5bf44a0470da76964")
11042 (revision "1"))
11043 (package
11044 (name "sbcl-cl-online-learning")
11045 (version (git-version "0.5" revision commit))
11046 (source
11047 (origin
11048 (method git-fetch)
11049 (uri (git-reference
11050 (url "https://github.com/masatoi/cl-online-learning")
11051 (commit commit)))
11052 (file-name (git-file-name "cl-online-learning" version))
11053 (sha256
11054 (base32
11055 "1lfq04lnxivx59nq5dd02glyqsqzf3vdn4s9b8wnaln5fs8g2ph9"))))
11056 (build-system asdf-build-system/sbcl)
11057 (native-inputs
11058 `(("prove" ,sbcl-prove)))
11059 (inputs
11060 `(("cl-libsvm-format" ,sbcl-cl-libsvm-format)
11061 ("cl-store" ,sbcl-cl-store)))
11062 (arguments
11063 `(#:test-asd-file "cl-online-learning-test.asd"
11064 #:asd-systems '("cl-online-learning-test"
11065 "cl-online-learning")))
11066 (home-page "https://github.com/masatoi/cl-online-learning")
11067 (synopsis "Online Machine Learning for Common Lisp")
11068 (description
11069 "This library contains a collection of machine learning algorithms for
11070 online linear classification written in Common Lisp.")
11071 (license license:expat))))
11072
11073 (define-public cl-online-learning
11074 (sbcl-package->cl-source-package sbcl-cl-online-learning))
11075
11076 (define-public ecl-cl-online-learning
11077 (sbcl-package->ecl-package sbcl-cl-online-learning))
11078
11079 (define-public sbcl-cl-mpg123
11080 (let ((commit "5f042c839d2ea4a2ff2a7b60c839d8633d64161d")
11081 (revision "1"))
11082 (package
11083 (name "sbcl-cl-mpg123")
11084 (version (git-version "1.0.0" revision commit))
11085 (source
11086 (origin
11087 (method git-fetch)
11088 (uri (git-reference
11089 (url "https://github.com/Shirakumo/cl-mpg123")
11090 (commit commit)))
11091 (file-name (git-file-name "cl-mpg123" version))
11092 (sha256
11093 (base32 "1hl721xaczxck008ax2y3jpkm509ry1sg3lklh2k76764m3ndrjf"))
11094 (modules '((guix build utils)))
11095 (snippet
11096 '(begin
11097 ;; Remove bundled pre-compiled libraries.
11098 (delete-file-recursively "static")
11099 #t))))
11100 (build-system asdf-build-system/sbcl)
11101 (arguments
11102 `(#:asd-files '("cl-mpg123.asd" "cl-mpg123-example.asd")
11103 #:asd-systems '("cl-mpg123" "cl-mpg123-example")
11104 #:phases
11105 (modify-phases %standard-phases
11106 (add-after 'unpack 'fix-paths
11107 (lambda* (#:key inputs #:allow-other-keys)
11108 (substitute* "low-level.lisp"
11109 (("libmpg123.so" all)
11110 (string-append (assoc-ref inputs "libmpg123")
11111 "/lib/" all))))))))
11112 (inputs
11113 `(("cffi" ,sbcl-cffi)
11114 ("cl-out123" ,sbcl-cl-out123)
11115 ("documentation-utils" ,sbcl-documentation-utils)
11116 ("libmpg123" ,mpg123)
11117 ("trivial-features" ,sbcl-trivial-features)
11118 ("trivial-garbage" ,sbcl-trivial-garbage)
11119 ("verbose" ,sbcl-verbose)))
11120 (home-page "https://shirakumo.github.io/cl-mpg123/")
11121 (synopsis "Common Lisp bindings to libmpg123")
11122 (description
11123 "This is a bindings and wrapper library to @code{libmpg123} allowing for
11124 convenient, extensive, and fast decoding of MPEG1/2/3 (most prominently mp3)
11125 files.")
11126 (license license:zlib))))
11127
11128 (define-public ecl-cl-mpg123
11129 (sbcl-package->ecl-package sbcl-cl-mpg123))
11130
11131 (define-public cl-mpg123
11132 (sbcl-package->cl-source-package sbcl-cl-mpg123))
11133
11134 (define-public sbcl-cl-out123
11135 (let ((commit "6b58d3f8c2a28ad09059ac4c60fb3c781b9b421b")
11136 (revision "1"))
11137 (package
11138 (name "sbcl-cl-out123")
11139 (version (git-version "1.0.0" revision commit))
11140 (source
11141 (origin
11142 (method git-fetch)
11143 (uri (git-reference
11144 (url "https://github.com/Shirakumo/cl-out123")
11145 (commit commit)))
11146 (file-name (git-file-name "cl-out123" version))
11147 (sha256
11148 (base32 "0mdwgfax6sq68wvdgjjp78i40ah7wqkpqnvaq8a1c509k7ghdgv1"))
11149 (modules '((guix build utils)))
11150 (snippet
11151 '(begin
11152 ;; Remove bundled pre-compiled libraries.
11153 (delete-file-recursively "static")
11154 #t))))
11155 (build-system asdf-build-system/sbcl)
11156 (arguments
11157 `(#:phases
11158 (modify-phases %standard-phases
11159 (add-after 'unpack 'fix-paths
11160 (lambda* (#:key inputs #:allow-other-keys)
11161 (substitute* "low-level.lisp"
11162 (("libout123.so" all)
11163 (string-append (assoc-ref inputs "libout123")
11164 "/lib/" all)))))
11165 ;; NOTE: (Sharlatan-20210129T134529+0000): ECL package `ext' has no
11166 ;; exported macro `without-interrupts' it's moved to `mp' package
11167 ;; https://github.com/Shirakumo/cl-out123/issues/2
11168 ;; https://gitlab.com/embeddable-common-lisp/ecl/-/blob/develop/src/lsp/mp.lsp
11169 (add-after 'unpack 'fix-ecl-package-name
11170 (lambda _
11171 (substitute* "wrapper.lisp"
11172 (("ext:without-interrupts.*") "mp:without-interrupts\n"))
11173 #t)))))
11174 (inputs
11175 `(("bordeaux-threads" ,sbcl-bordeaux-threads)
11176 ("cffi" ,sbcl-cffi)
11177 ("documentation-utils" ,sbcl-documentation-utils)
11178 ("libout123" ,mpg123)
11179 ("trivial-features" ,sbcl-trivial-features)
11180 ("trivial-garbage" ,sbcl-trivial-garbage)))
11181 (home-page "https://shirakumo.github.io/cl-out123/")
11182 (synopsis "Common Lisp bindings to libout123")
11183 (description
11184 "This is a bindings library to @code{libout123} which allows easy
11185 cross-platform audio playback.")
11186 (license license:zlib))))
11187
11188 (define-public ecl-cl-out123
11189 (sbcl-package->ecl-package sbcl-cl-out123))
11190
11191 (define-public cl-out123
11192 (sbcl-package->cl-source-package sbcl-cl-out123))
11193
11194 (define-public sbcl-cl-random-forest
11195 (let ((commit "fedb36ce99bb6f4d7e3a7dd6d8b058f331308f91")
11196 (revision "1"))
11197 (package
11198 (name "sbcl-cl-random-forest")
11199 (version (git-version "0.1" revision commit))
11200 (source
11201 (origin
11202 (method git-fetch)
11203 (uri (git-reference
11204 (url "https://github.com/masatoi/cl-random-forest")
11205 (commit commit)))
11206 (file-name (git-file-name name version))
11207 (sha256
11208 (base32
11209 "0wqh4dxy5hrvm14jgyfypwhdw35f24rsksid4blz5a6l2z16rlmq"))))
11210 (build-system asdf-build-system/sbcl)
11211 (native-inputs
11212 `(("prove" ,sbcl-prove)
11213 ("trivial-garbage" ,sbcl-trivial-garbage)))
11214 (inputs
11215 `(("alexandria" ,sbcl-alexandria)
11216 ("cl-libsvm-format" ,sbcl-cl-libsvm-format)
11217 ("cl-online-learning" ,sbcl-cl-online-learning)
11218 ("lparallel" ,sbcl-lparallel)))
11219 (arguments
11220 `(#:tests? #f)) ; The tests download data from the Internet
11221 (synopsis "Random Forest and Global Refinement for Common Lisp")
11222 (description
11223 "CL-random-forest is an implementation of Random Forest for multiclass
11224 classification and univariate regression written in Common Lisp. It also
11225 includes an implementation of Global Refinement of Random Forest.")
11226 (home-page "https://github.com/masatoi/cl-random-forest")
11227 (license license:expat))))
11228
11229 (define-public cl-random-forest
11230 (sbcl-package->cl-source-package sbcl-cl-random-forest))
11231
11232 (define-public ecl-cl-random-forest
11233 (sbcl-package->ecl-package sbcl-cl-random-forest))
11234
11235 (define-public sbcl-bordeaux-fft
11236 (let ((commit "4a1f5600cae59bdabcb32de4ee2d7d73a9450d6e")
11237 (revision "0"))
11238 (package
11239 (name "sbcl-bordeaux-fft")
11240 (version (git-version "1.0.1" revision commit))
11241 (source
11242 (origin
11243 (method git-fetch)
11244 (uri (git-reference
11245 (url "https://github.com/ahefner/bordeaux-fft")
11246 (commit commit)))
11247 (file-name (git-file-name name version))
11248 (sha256
11249 (base32 "0j584w6kq2k6r8lp2i14f9605rxhp3r15s33xs08iz1pndn6iwqf"))))
11250 (build-system asdf-build-system/sbcl)
11251 (home-page "http://vintage-digital.com/hefner/software/bordeaux-fft/")
11252 (synopsis "Fast Fourier Transform for Common Lisp")
11253 (description
11254 "The Bordeaux-FFT library provides a reasonably efficient implementation
11255 of the Fast Fourier Transform and its inverse for complex-valued inputs, in
11256 portable Common Lisp.")
11257 (license license:gpl2+))))
11258
11259 (define-public cl-bordeaux-fft
11260 (sbcl-package->cl-source-package sbcl-bordeaux-fft))
11261
11262 (define-public ecl-bordeaux-fft
11263 (sbcl-package->ecl-package sbcl-bordeaux-fft))
11264
11265 (define-public sbcl-napa-fft3
11266 (let ((commit "f2d9614c7167da327c9ceebefb04ff6eae2d2236")
11267 (revision "0"))
11268 (package
11269 (name "sbcl-napa-fft3")
11270 (version (git-version "0.0.1" revision commit))
11271 (source
11272 (origin
11273 (method git-fetch)
11274 (uri (git-reference
11275 (url "https://github.com/pkhuong/Napa-FFT3")
11276 (commit commit)))
11277 (file-name (git-file-name name version))
11278 (sha256
11279 (base32 "1hxjf599xgwm28gbryy7q96j9ys6hfszmv0qxpr5698hxnhknscp"))))
11280 (build-system asdf-build-system/sbcl)
11281 (home-page "https://github.com/pkhuong/Napa-FFT3")
11282 (synopsis "Fast Fourier Transform routines in Common Lisp")
11283 (description
11284 "Napa-FFT3 provides Discrete Fourier Transform (DFT) routines, but also
11285 buildings blocks to express common operations that involve DFTs: filtering,
11286 convolutions, etc.")
11287 (license license:bsd-3))))
11288
11289 (define-public cl-napa-fft3
11290 (sbcl-package->cl-source-package sbcl-napa-fft3))
11291
11292 (define-public sbcl-cl-tga
11293 (let ((commit "4dc2f7b8a259b9360862306640a07a23d4afaacc")
11294 (revision "0"))
11295 (package
11296 (name "sbcl-cl-tga")
11297 (version (git-version "0.0.0" revision commit))
11298 (source
11299 (origin
11300 (method git-fetch)
11301 (uri (git-reference
11302 (url "https://github.com/fisxoj/cl-tga")
11303 (commit commit)))
11304 (file-name (git-file-name name version))
11305 (sha256
11306 (base32 "03k3npmn0xd3fd2m7vwxph82av2xrfb150imqrinlzqmzvz1v1br"))))
11307 (build-system asdf-build-system/sbcl)
11308 (home-page "https://github.com/fisxoj/cl-tga")
11309 (synopsis "TGA file loader for Common Lisp")
11310 (description
11311 "Cl-tga was written to facilitate loading @emph{.tga} files into OpenGL
11312 programs. It's a very simple library, and, at the moment, only supports
11313 non-RLE encoded forms of the files.")
11314 (license license:expat))))
11315
11316 (define-public cl-tga
11317 (sbcl-package->cl-source-package sbcl-cl-tga))
11318
11319 (define-public ecl-cl-tga
11320 (sbcl-package->ecl-package sbcl-cl-tga))
11321
11322 (define-public sbcl-com.gigamonkeys.binary-data
11323 (let ((commit "22e908976d7f3e2318b7168909f911b4a00963ee")
11324 (revision "0"))
11325 (package
11326 (name "sbcl-com.gigamonkeys.binary-data")
11327 (version (git-version "0.0.0" revision commit))
11328 (source
11329 (origin
11330 (method git-fetch)
11331 (uri (git-reference
11332 (url "https://github.com/gigamonkey/monkeylib-binary-data")
11333 (commit commit)))
11334 (file-name (git-file-name name version))
11335 (sha256
11336 (base32 "072v417vmcnvmyh8ddq9vmwwrizm7zwz9dpzi14qy9nsw8q649zw"))))
11337 (build-system asdf-build-system/sbcl)
11338 (inputs
11339 `(("alexandria" ,sbcl-alexandria)))
11340 (home-page "https://github.com/gigamonkey/monkeylib-binary-data")
11341 (synopsis "Common Lisp library for reading and writing binary data")
11342 (description
11343 "This a Common Lisp library for reading and writing binary data. It is
11344 based on code from chapter 24 of the book @emph{Practical Common Lisp}.")
11345 (license license:bsd-3))))
11346
11347 (define-public cl-com.gigamonkeys.binary-data
11348 (sbcl-package->cl-source-package sbcl-com.gigamonkeys.binary-data))
11349
11350 (define-public ecl-com.gigamonkeys.binary-data
11351 (sbcl-package->ecl-package sbcl-com.gigamonkeys.binary-data))
11352
11353 (define-public sbcl-deflate
11354 (package
11355 (name "sbcl-deflate")
11356 (version "1.0.3")
11357 (source
11358 (origin
11359 (method git-fetch)
11360 (uri (git-reference
11361 (url "https://github.com/pmai/Deflate")
11362 (commit (string-append "release-" version))))
11363 (file-name (git-file-name name version))
11364 (sha256
11365 (base32 "1jpdjnxh6cw2d8hk70r2sxn92is52s9b855irvwkdd777fdciids"))))
11366 (build-system asdf-build-system/sbcl)
11367 (home-page "https://github.com/pmai/Deflate")
11368 (synopsis "Native deflate decompression for Common Lisp")
11369 (description
11370 "This library is an implementation of Deflate (RFC 1951) decompression,
11371 with optional support for ZLIB-style (RFC 1950) and gzip-style (RFC 1952)
11372 wrappers of deflate streams. It currently does not handle compression.")
11373 (license license:expat)))
11374
11375 (define-public cl-deflate
11376 (sbcl-package->cl-source-package sbcl-deflate))
11377
11378 (define-public ecl-deflate
11379 (sbcl-package->ecl-package sbcl-deflate))
11380
11381 (define-public sbcl-skippy
11382 (let ((commit "e456210202ca702c792292c5060a264d45e47090")
11383 (revision "0"))
11384 (package
11385 (name "sbcl-skippy")
11386 (version (git-version "1.3.12" revision commit))
11387 (source
11388 (origin
11389 (method git-fetch)
11390 (uri (git-reference
11391 (url "https://github.com/xach/skippy")
11392 (commit commit)))
11393 (file-name (git-file-name name version))
11394 (sha256
11395 (base32 "1sxbn5nh24qpx9w64x8mhp259cxcl1x8p126wk3b91ijjsj7l5vj"))))
11396 (build-system asdf-build-system/sbcl)
11397 (home-page "https://xach.com/lisp/skippy/")
11398 (synopsis "Common Lisp library for GIF images")
11399 (description
11400 "Skippy is a Common Lisp library to read and write GIF image files.")
11401 (license license:bsd-2))))
11402
11403 (define-public cl-skippy
11404 (sbcl-package->cl-source-package sbcl-skippy))
11405
11406 (define-public ecl-skippy
11407 (sbcl-package->ecl-package sbcl-skippy))
11408
11409 (define-public sbcl-cl-freetype2
11410 (let ((commit "96058da730b4812df916c1f4ee18c99b3b15a3de")
11411 (revision "0"))
11412 (package
11413 (name "sbcl-cl-freetype2")
11414 (version (git-version "1.1" revision commit))
11415 (source
11416 (origin
11417 (method git-fetch)
11418 (uri (git-reference
11419 (url "https://github.com/rpav/cl-freetype2")
11420 (commit commit)))
11421 (file-name (git-file-name name version))
11422 (sha256
11423 (base32 "0f8darhairgxnb5bzqcny7nh7ss3471bdzix5rzcyiwdbr5kymjl"))))
11424 (build-system asdf-build-system/sbcl)
11425 (native-inputs
11426 `(("fiveam" ,sbcl-fiveam)))
11427 (inputs
11428 `(("alexandria" ,sbcl-alexandria)
11429 ("cffi" ,sbcl-cffi)
11430 ("freetype" ,freetype)
11431 ("trivial-garbage" ,sbcl-trivial-garbage)))
11432 (arguments
11433 `(#:phases
11434 (modify-phases %standard-phases
11435 (add-after 'unpack 'fix-paths
11436 (lambda* (#:key inputs #:allow-other-keys)
11437 (substitute* "src/ffi/ft2-lib.lisp"
11438 (("\"libfreetype\"")
11439 (string-append "\"" (assoc-ref inputs "freetype")
11440 "/lib/libfreetype\"")))
11441 (substitute* "src/ffi/grovel/grovel-freetype2.lisp"
11442 (("-I/usr/include/freetype")
11443 (string-append "-I" (assoc-ref inputs "freetype")
11444 "/include/freetype")))
11445 #t)))))
11446 (home-page "https://github.com/rpav/cl-freetype2")
11447 (synopsis "Common Lisp bindings for Freetype 2")
11448 (description
11449 "This is a general Freetype 2 wrapper for Common Lisp using CFFI. It's
11450 geared toward both using Freetype directly by providing a simplified API, as
11451 well as providing access to the underlying C structures and functions for use
11452 with other libraries which may also use Freetype.")
11453 (license license:bsd-3))))
11454
11455 (define-public cl-freetype2
11456 (sbcl-package->cl-source-package sbcl-cl-freetype2))
11457
11458 (define-public ecl-cl-freetype2
11459 (sbcl-package->ecl-package sbcl-cl-freetype2))
11460
11461 (define-public sbcl-opticl-core
11462 (let ((commit "b7cd13d26df6b824b216fbc360dc27bfadf04999")
11463 (revision "0"))
11464 (package
11465 (name "sbcl-opticl-core")
11466 (version (git-version "0.0.0" revision commit))
11467 (source
11468 (origin
11469 (method git-fetch)
11470 (uri (git-reference
11471 (url "https://github.com/slyrus/opticl-core")
11472 (commit commit)))
11473 (file-name (git-file-name name version))
11474 (sha256
11475 (base32 "0458bllabcdjghfrqx6aki49c9qmvfmkk8jl75cfpi7q0i12kh95"))))
11476 (build-system asdf-build-system/sbcl)
11477 (inputs
11478 `(("alexandria" ,sbcl-alexandria)))
11479 (home-page "https://github.com/slyrus/opticl-core")
11480 (synopsis "Core classes and pixel access macros for Opticl")
11481 (description
11482 "This Common Lisp library contains the core classes and pixel access
11483 macros for the Opticl image processing library.")
11484 (license license:bsd-2))))
11485
11486 (define-public cl-opticl-core
11487 (sbcl-package->cl-source-package sbcl-opticl-core))
11488
11489 (define-public ecl-opticl-core
11490 (sbcl-package->ecl-package sbcl-opticl-core))
11491
11492 (define-public sbcl-retrospectiff
11493 (let ((commit "c2a69d77d5010f8cdd9045b3e36a08a73da5d321")
11494 (revision "0"))
11495 (package
11496 (name "sbcl-retrospectiff")
11497 (version (git-version "0.2" revision commit))
11498 (source
11499 (origin
11500 (method git-fetch)
11501 (uri (git-reference
11502 (url "https://github.com/slyrus/retrospectiff")
11503 (commit commit)))
11504 (file-name (git-file-name name version))
11505 (sha256
11506 (base32 "0qsn9hpd8j2kp43dk05j8dczz9zppdff5rrclbp45n3ksk9inw8i"))))
11507 (build-system asdf-build-system/sbcl)
11508 (native-inputs
11509 `(("fiveam" ,sbcl-fiveam)))
11510 (inputs
11511 `(("cl-jpeg" ,sbcl-cl-jpeg)
11512 ("com.gigamonkeys.binary-data" ,sbcl-com.gigamonkeys.binary-data)
11513 ("deflate" ,sbcl-deflate)
11514 ("flexi-streams" ,sbcl-flexi-streams)
11515 ("ieee-floats" ,sbcl-ieee-floats)
11516 ("opticl-core" ,sbcl-opticl-core)))
11517 (home-page "https://github.com/slyrus/retrospectiff")
11518 (synopsis "Common Lisp library for TIFF images")
11519 (description
11520 "Retrospectiff is a common lisp library for reading and writing images
11521 in the TIFF (Tagged Image File Format) format.")
11522 (license license:bsd-2))))
11523
11524 (define-public cl-retrospectif
11525 (sbcl-package->cl-source-package sbcl-retrospectiff))
11526
11527 (define-public ecl-retrospectiff
11528 (sbcl-package->ecl-package sbcl-retrospectiff))
11529
11530 (define-public sbcl-mmap
11531 (let ((commit "ba2e98c67e25f0fb8ff838238561120a23903ce7")
11532 (revision "0"))
11533 (package
11534 (name "sbcl-mmap")
11535 (version (git-version "1.0.0" revision commit))
11536 (source
11537 (origin
11538 (method git-fetch)
11539 (uri (git-reference
11540 (url "https://github.com/Shinmera/mmap")
11541 (commit commit)))
11542 (file-name (git-file-name name version))
11543 (sha256
11544 (base32 "0qd0xp20i1pcfn12kkapv9pirb6hd4ns7kz4zf1mmjwykpsln96q"))))
11545 (build-system asdf-build-system/sbcl)
11546 (native-inputs
11547 `(("alexandria" ,sbcl-alexandria)
11548 ("cffi" ,sbcl-cffi)
11549 ("parachute" ,sbcl-parachute)
11550 ("trivial-features" ,sbcl-trivial-features)))
11551 (inputs
11552 `(("cffi" ,sbcl-cffi)
11553 ("documentation-utils" ,sbcl-documentation-utils)))
11554 (home-page "https://shinmera.github.io/mmap/")
11555 (synopsis "File memory mapping for Common Lisp")
11556 (description
11557 "This is a utility library providing access to the @emph{mmap} family of
11558 functions in a portable way. It allows you to directly map a file into the
11559 address space of your process without having to manually read it into memory
11560 sequentially. Typically this is much more efficient for files that are larger
11561 than a few Kb.")
11562 (license license:zlib))))
11563
11564 (define-public cl-mmap
11565 (sbcl-package->cl-source-package sbcl-mmap))
11566
11567 (define-public ecl-mmap
11568 (sbcl-package->ecl-package sbcl-mmap))
11569
11570 (define-public sbcl-3bz
11571 (let ((commit "569614c40408f3aefc77ba233e0e4bd66d3850ad")
11572 (revision "1"))
11573 (package
11574 (name "sbcl-3bz")
11575 (version (git-version "0.0.0" revision commit))
11576 (source
11577 (origin
11578 (method git-fetch)
11579 (uri (git-reference
11580 (url "https://github.com/3b/3bz")
11581 (commit commit)))
11582 (file-name (git-file-name name version))
11583 (sha256
11584 (base32 "0kvvlvf50jhhw1s510f3clpr1a68632bq6d698yxcrx722igcrg4"))))
11585 (build-system asdf-build-system/sbcl)
11586 (inputs
11587 `(("alexandria" ,sbcl-alexandria)
11588 ("babel" ,sbcl-babel)
11589 ("cffi" ,sbcl-cffi)
11590 ("mmap" ,sbcl-mmap)
11591 ("nibbles" ,sbcl-nibbles)
11592 ("trivial-features" ,sbcl-trivial-features)))
11593 (arguments
11594 ;; FIXME: #41437 - Build fails when package name starts from a digit
11595 `(#:asd-systems '("3bz")))
11596 (home-page "https://github.com/3b/3bz")
11597 (synopsis "Deflate decompression for Common Lisp")
11598 (description
11599 "3bz is an implementation of Deflate decompression (RFC 1951) optionally
11600 with zlib (RFC 1950) or gzip (RFC 1952) wrappers, with support for reading from
11601 foreign pointers (for use with mmap and similar, etc), and from CL octet
11602 vectors and streams.")
11603 (license license:expat))))
11604
11605 (define-public cl-3bz
11606 (sbcl-package->cl-source-package sbcl-3bz))
11607
11608 (define-public ecl-3bz
11609 (sbcl-package->ecl-package sbcl-3bz))
11610
11611 (define-public sbcl-zpb-exif
11612 (package
11613 (name "sbcl-zpb-exif")
11614 (version "1.2.4")
11615 (source
11616 (origin
11617 (method git-fetch)
11618 (uri (git-reference
11619 (url "https://github.com/xach/zpb-exif")
11620 (commit (string-append "release-" version))))
11621 (file-name (git-file-name name version))
11622 (sha256
11623 (base32 "15s227jhby55cisz14xafb0p1ws2jmrg2rrbbd00lrb97im84hy6"))))
11624 (build-system asdf-build-system/sbcl)
11625 (home-page "https://xach.com/lisp/zpb-exif/")
11626 (synopsis "EXIF information extractor for Common Lisp")
11627 (description
11628 "This is a Common Lisp library to extract EXIF information from image
11629 files.")
11630 (license license:bsd-2)))
11631
11632 (define-public cl-zpb-exif
11633 (sbcl-package->cl-source-package sbcl-zpb-exif))
11634
11635 (define-public ecl-zpb-exif
11636 (sbcl-package->ecl-package sbcl-zpb-exif))
11637
11638 (define-public sbcl-pngload
11639 (let ((commit "91f1d703c65bb6a94d6fee06ddbbbbbc5778b71f")
11640 (revision "2"))
11641 (package
11642 (name "sbcl-pngload")
11643 (version (git-version "2.0.0" revision commit))
11644 (source
11645 (origin
11646 (method git-fetch)
11647 (uri (git-reference
11648 (url "https://git.mfiano.net/mfiano/pngload.git")
11649 (commit commit)))
11650 (file-name (git-file-name "pngload" version))
11651 (sha256
11652 (base32 "0s94fdbrbqj12qvgyn2g4lfwvz7qhhzbclrpz5ni7adwxgrmvxl1"))))
11653 (build-system asdf-build-system/sbcl)
11654 (inputs
11655 `(("3bz" ,sbcl-3bz)
11656 ("alexandria" ,sbcl-alexandria)
11657 ("cffi" ,sbcl-cffi)
11658 ("mmap" ,sbcl-mmap)
11659 ("parse-float" ,sbcl-parse-float)
11660 ("static-vectors" ,sbcl-static-vectors)
11661 ("swap-bytes" ,sbcl-swap-bytes)
11662 ("zpb-exif" ,sbcl-zpb-exif)))
11663 (arguments
11664 ;; Test suite disabled because of a dependency cycle.
11665 ;; pngload tests depend on opticl which depends on pngload.
11666 '(#:tests? #f))
11667 (home-page "https://git.mfiano.net/mfiano/pngload.git")
11668 (synopsis "PNG image decoder for Common Lisp")
11669 (description
11670 "This is a Common Lisp library to load images in the PNG image format,
11671 both from files on disk, or streams in memory.")
11672 (license license:expat))))
11673
11674 (define-public cl-pngload
11675 (sbcl-package->cl-source-package sbcl-pngload))
11676
11677 (define-public ecl-pngload
11678 (sbcl-package->ecl-package sbcl-pngload))
11679
11680 (define-public sbcl-opticl
11681 (let ((commit "e8684416eca2e78e82a7b436d436ef2ea24c019d")
11682 (revision "0"))
11683 (package
11684 (name "sbcl-opticl")
11685 (version (git-version "0.0.0" revision commit))
11686 (source
11687 (origin
11688 (method git-fetch)
11689 (uri (git-reference
11690 (url "https://github.com/slyrus/opticl")
11691 (commit commit)))
11692 (file-name (git-file-name name version))
11693 (sha256
11694 (base32 "03rirnnhhisjbimlmpi725h1d3x0cfv00r57988am873dyzawmm1"))))
11695 (build-system asdf-build-system/sbcl)
11696 (native-inputs
11697 `(("fiveam" ,sbcl-fiveam)))
11698 (inputs
11699 `(("alexandria" ,sbcl-alexandria)
11700 ("cl-jpeg" ,sbcl-cl-jpeg)
11701 ("cl-tga" ,sbcl-cl-tga)
11702 ("png-read" ,sbcl-png-read)
11703 ("pngload" ,sbcl-pngload)
11704 ("retrospectiff" ,sbcl-retrospectiff)
11705 ("skippy" ,sbcl-skippy)
11706 ("zpng" ,sbcl-zpng)))
11707 (arguments
11708 '(#:asd-files '("opticl.asd")))
11709 (home-page "https://github.com/slyrus/opticl")
11710 (synopsis "Image processing library for Common Lisp")
11711 (description
11712 "Opticl is a Common Lisp library for representing, processing, loading,
11713 and saving 2-dimensional pixel-based images.")
11714 (license license:bsd-2))))
11715
11716 (define-public cl-opticl
11717 (sbcl-package->cl-source-package sbcl-opticl))
11718
11719 (define-public ecl-opticl
11720 (sbcl-package->ecl-package sbcl-opticl))
11721
11722 (define-public sbcl-mcclim
11723 (let ((commit "04cc542dd4b461b9d56406e40681d1a8f080730f")
11724 (revision "1"))
11725 (package
11726 (name "sbcl-mcclim")
11727 (version (git-version "0.9.7" revision commit))
11728 (source
11729 (origin
11730 (method git-fetch)
11731 (uri (git-reference
11732 (url "https://github.com/mcclim/mcclim")
11733 (commit commit)))
11734 (file-name (git-file-name name version))
11735 (sha256
11736 (base32 "1xjly8i62z72hfhlnz5kjd9i8xhrwckc7avyizxvhih67pkjmsx0"))))
11737 (build-system asdf-build-system/sbcl)
11738 (native-inputs
11739 `(("fiveam" ,sbcl-fiveam)
11740 ("pkg-config" ,pkg-config)))
11741 (inputs
11742 `(("alexandria" ,sbcl-alexandria)
11743 ("babel" ,sbcl-babel)
11744 ("bordeaux-threads" ,sbcl-bordeaux-threads)
11745 ("cl-freetype2" ,sbcl-cl-freetype2)
11746 ("cl-pdf" ,sbcl-cl-pdf)
11747 ("cffi" ,sbcl-cffi)
11748 ("cl-unicode" ,sbcl-cl-unicode)
11749 ("cl-vectors" ,sbcl-cl-vectors)
11750 ("closer-mop" ,sbcl-closer-mop)
11751 ("clx" ,sbcl-clx)
11752 ("flexi-streams" ,sbcl-flexi-streams)
11753 ("flexichain" ,sbcl-flexichain)
11754 ("font-dejavu" ,font-dejavu)
11755 ("fontconfig" ,fontconfig)
11756 ("freetype" ,freetype)
11757 ("harfbuzz" ,harfbuzz)
11758 ("log4cl" ,sbcl-log4cl)
11759 ("opticl" ,sbcl-opticl)
11760 ("spatial-trees" ,sbcl-spatial-trees)
11761 ("swank" ,sbcl-slime-swank)
11762 ("trivial-features" ,sbcl-trivial-features)
11763 ("trivial-garbage" ,sbcl-trivial-garbage)
11764 ("trivial-gray-streams" ,sbcl-trivial-gray-streams)
11765 ("zpb-ttf" ,sbcl-zpb-ttf)))
11766 (arguments
11767 '(#:asd-systems '("mcclim"
11768 "clim-examples")
11769 #:phases
11770 (modify-phases %standard-phases
11771 (add-after 'unpack 'fix-paths
11772 (lambda* (#:key inputs #:allow-other-keys)
11773 ;; mcclim-truetype uses DejaVu as default font and
11774 ;; sets the path at build time.
11775 (substitute* "Extensions/fonts/fontconfig.lisp"
11776 (("/usr/share/fonts/truetype/dejavu/")
11777 (string-append (assoc-ref inputs "font-dejavu")
11778 "/share/fonts/truetype/")))
11779 (substitute* "Extensions/fontconfig/src/functions.lisp"
11780 (("libfontconfig\\.so")
11781 (string-append (assoc-ref inputs "fontconfig")
11782 "/lib/libfontconfig.so")))
11783 (substitute* "Extensions/harfbuzz/src/functions.lisp"
11784 (("libharfbuzz\\.so")
11785 (string-append (assoc-ref inputs "harfbuzz")
11786 "/lib/libharfbuzz.so")))
11787 #t))
11788 (add-after 'unpack 'fix-build
11789 (lambda _
11790 ;; The cffi-grovel system does not get loaded automatically,
11791 ;; so we load it explicitly.
11792 (substitute* "Extensions/fontconfig/mcclim-fontconfig.asd"
11793 (("\\(asdf:defsystem #:mcclim-fontconfig" all)
11794 (string-append "(asdf:load-system :cffi-grovel)\n" all)))
11795 (substitute* "Extensions/harfbuzz/mcclim-harfbuzz.asd"
11796 (("\\(asdf:defsystem #:mcclim-harfbuzz" all)
11797 (string-append "(asdf:load-system :cffi-grovel)\n" all)))
11798 #t)))))
11799 (home-page "https://common-lisp.net/project/mcclim/")
11800 (synopsis "Common Lisp GUI toolkit")
11801 (description
11802 "McCLIM is an implementation of the @emph{Common Lisp Interface Manager
11803 specification}, a toolkit for writing GUIs in Common Lisp.")
11804 (license license:lgpl2.1+))))
11805
11806 (define-public cl-mcclim
11807 (sbcl-package->cl-source-package sbcl-mcclim))
11808
11809 (define-public ecl-mcclim
11810 (sbcl-package->ecl-package sbcl-mcclim))
11811
11812 (define-public sbcl-cl-inflector
11813 (let ((commit "f1ab16919ccce3bd82a0042677d9616dde2034fe")
11814 (revision "1"))
11815 (package
11816 (name "sbcl-cl-inflector")
11817 (version (git-version "0.2" revision commit))
11818 (source
11819 (origin
11820 (method git-fetch)
11821 (uri (git-reference
11822 (url "https://github.com/AccelerationNet/cl-inflector")
11823 (commit commit)))
11824 (file-name (git-file-name name version))
11825 (sha256
11826 (base32 "1xwwlhik1la4fp984qnx2dqq24v012qv4x0y49sngfpwg7n0ya7y"))))
11827 (build-system asdf-build-system/sbcl)
11828 (native-inputs
11829 `(("lisp-unit2" ,sbcl-lisp-unit2)))
11830 (inputs
11831 `(("alexandria" ,sbcl-alexandria)
11832 ("cl-ppcre" ,sbcl-cl-ppcre)))
11833 (home-page "https://github.com/AccelerationNet/cl-inflector")
11834 (synopsis "Library to pluralize/singularize English and Portuguese words")
11835 (description
11836 "This is a common lisp library to easily pluralize and singularize
11837 English and Portuguese words. This is a port of the ruby ActiveSupport
11838 Inflector module.")
11839 (license license:expat))))
11840
11841 (define-public cl-inflector
11842 (sbcl-package->cl-source-package sbcl-cl-inflector))
11843
11844 (define-public ecl-cl-inflector
11845 (sbcl-package->ecl-package sbcl-cl-inflector))
11846
11847 (define-public sbcl-ixf
11848 (let ((commit "ed26f87e4127e4a9e3aac4ff1e60d1f39cca5183")
11849 (revision "1"))
11850 (package
11851 (name "sbcl-ixf")
11852 (version (git-version "0.1.0" revision commit))
11853 (source
11854 (origin
11855 (method git-fetch)
11856 (uri (git-reference
11857 (url "https://github.com/dimitri/cl-ixf")
11858 (commit commit)))
11859 (file-name (git-file-name "cl-ixf" version))
11860 (sha256
11861 (base32 "1wjdnf4vr9z7lcfc49kl43g6l2i23q9n81siy494k17d766cdvqa"))))
11862 (build-system asdf-build-system/sbcl)
11863 (inputs
11864 `(("alexandria" ,sbcl-alexandria)
11865 ("babel" ,sbcl-babel)
11866 ("cl-ppcre" ,sbcl-cl-ppcre)
11867 ("ieee-floats" ,sbcl-ieee-floats)
11868 ("local-time" ,sbcl-local-time)
11869 ("md5" ,sbcl-md5)
11870 ("split-sequence" ,sbcl-split-sequence)))
11871 (home-page "https://github.com/dimitri/cl-ixf")
11872 (synopsis "Parse IBM IXF file format")
11873 (description
11874 "This is a Common Lisp library to handle the IBM PC version of the IXF
11875 (Integration Exchange Format) file format.")
11876 (license license:public-domain))))
11877
11878 (define-public ecl-ixf
11879 (sbcl-package->ecl-package sbcl-ixf))
11880
11881 (define-public cl-ixf
11882 (sbcl-package->cl-source-package sbcl-ixf))
11883
11884 (define-public sbcl-qbase64
11885 (package
11886 (name "sbcl-qbase64")
11887 (version "0.3.0")
11888 (source
11889 (origin
11890 (method git-fetch)
11891 (uri (git-reference
11892 (url "https://github.com/chaitanyagupta/qbase64")
11893 (commit version)))
11894 (file-name (git-file-name name version))
11895 (sha256
11896 (base32 "1dir0s70ca3hagxv9x15zq4p4ajgl7jrcgqsza2n2y7iqbxh0dwi"))))
11897 (build-system asdf-build-system/sbcl)
11898 (inputs
11899 `(("metabang-bind" ,sbcl-metabang-bind)
11900 ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
11901 (native-inputs
11902 `(("fiveam" ,sbcl-fiveam)))
11903 (home-page "https://github.com/chaitanyagupta/qbase64")
11904 (synopsis "Base64 encoder and decoder for Common Lisp")
11905 (description "@code{qbase64} provides a fast and flexible base64 encoder
11906 and decoder for Common Lisp.")
11907 (license license:bsd-3)))
11908
11909 (define-public cl-qbase64
11910 (sbcl-package->cl-source-package sbcl-qbase64))
11911
11912 (define-public ecl-qbase64
11913 (sbcl-package->ecl-package sbcl-qbase64))
11914
11915 (define-public sbcl-lw-compat
11916 ;; No release since 2013.
11917 (let ((commit "aabfe28c6c1a4949f9d7b3cb30319367c9fd1c0d"))
11918 (package
11919 (name "sbcl-lw-compat")
11920 (version (git-version "1.0.0" "1" commit))
11921 (source
11922 (origin
11923 (method git-fetch)
11924 (uri (git-reference
11925 (url "https://github.com/pcostanza/lw-compat/")
11926 (commit commit)))
11927 (file-name (git-file-name name version))
11928 (sha256
11929 (base32 "131rq5k2mlv9bfhmafiv6nfsivl4cxx13d9wr06v5jrqnckh4aav"))))
11930 (build-system asdf-build-system/sbcl)
11931 (home-page "https://github.com/pcostanza/lw-compat/")
11932 (synopsis "LispWorks utilities ported to other Common Lisp implementations")
11933 (description "This package contains a few utility functions from the
11934 LispWorks library that are used in software such as ContextL.")
11935 (license license:expat))))
11936
11937 (define-public cl-lw-compat
11938 (sbcl-package->cl-source-package sbcl-lw-compat))
11939
11940 (define-public ecl-lw-compat
11941 (sbcl-package->ecl-package sbcl-lw-compat))
11942
11943 (define-public sbcl-contextl
11944 ;; No release since 2013.
11945 (let ((commit "5d18a71a85824f6c25a9f35a21052f967b8b6bb9"))
11946 (package
11947 (name "sbcl-contextl")
11948 (version (git-version "1.0.0" "1" commit))
11949 (source
11950 (origin
11951 (method git-fetch)
11952 (uri (git-reference
11953 (url "https://github.com/pcostanza/contextl/")
11954 (commit commit)))
11955 (file-name (git-file-name name version))
11956 (sha256
11957 (base32 "0gk1izx6l6g48nypmnm9r6mzjx0jixqjj2kc6klf8a88rr5xd226"))))
11958 (build-system asdf-build-system/sbcl)
11959 (inputs
11960 `(("closer-mop" ,sbcl-closer-mop)
11961 ("lw-compat" ,sbcl-lw-compat)))
11962 (home-page "https://github.com/pcostanza/contextl")
11963 (synopsis "Context-oriented programming for Common Lisp")
11964 (description "ContextL is a CLOS extension for Context-Oriented
11965 Programming (COP).
11966
11967 Find overview of ContextL's features in an overview paper:
11968 @url{http://www.p-cos.net/documents/contextl-soa.pdf}. See also this general
11969 overview article about COP which also contains some ContextL examples:
11970 @url{http://www.jot.fm/issues/issue_2008_03/article4/}.")
11971 (license license:expat))))
11972
11973 (define-public cl-contextl
11974 (sbcl-package->cl-source-package sbcl-contextl))
11975
11976 (define-public ecl-contextl
11977 (sbcl-package->ecl-package sbcl-contextl))
11978
11979 (define-public sbcl-hu.dwim.common-lisp
11980 (let ((commit "90558195773383142a57a16687d5e7f4adea6418"))
11981 (package
11982 (name "sbcl-hu.dwim.common-lisp")
11983 (version "2021-01-27")
11984 (source
11985 (origin
11986 (method git-fetch)
11987 (uri (git-reference
11988 (url "https://github.com/hu-dwim/hu.dwim.common-lisp/")
11989 (commit commit)))
11990 (file-name (git-file-name name version))
11991 (sha256
11992 (base32 "06zkdw3scnaw0d4nmsgkv7pi7sw00dikdgfgsqmbqfbz2yrsdabk"))))
11993 (build-system asdf-build-system/sbcl)
11994 (native-inputs
11995 `(("hu.dwim.asdf" ,sbcl-hu.dwim.asdf)))
11996 (home-page "http://dwim.hu/project/hu.dwim.common-lisp")
11997 (synopsis "Redefine some standard Common Lisp names")
11998 (description "This library is a redefinition of the standard Common Lisp
11999 package that includes a number of renames and shadows. ")
12000 (license license:public-domain))))
12001
12002 (define-public cl-hu.dwim.common-lisp
12003 (sbcl-package->cl-source-package sbcl-hu.dwim.common-lisp))
12004
12005 (define-public ecl-hu.dwim.common-lisp
12006 (sbcl-package->ecl-package sbcl-hu.dwim.common-lisp))
12007
12008 (define-public sbcl-hu.dwim.common
12009 (package
12010 (name "sbcl-hu.dwim.common")
12011 (version "2015-07-09")
12012 (source
12013 (origin
12014 (method url-fetch)
12015 (uri (string-append
12016 "http://beta.quicklisp.org/archive/hu.dwim.common/"
12017 version "/hu.dwim.common-"
12018 (string-replace-substring version "-" "")
12019 "-darcs.tgz"))
12020 (sha256
12021 (base32 "12l1rr6w9m99w0b5gc6hv58ainjfhbc588kz6vwshn4gqsxyzbhp"))))
12022 (build-system asdf-build-system/sbcl)
12023 (native-inputs
12024 `(("hu.dwim.asdf" ,sbcl-hu.dwim.asdf)))
12025 (inputs
12026 `(("alexandria" ,sbcl-alexandria)
12027 ("anaphora" ,sbcl-anaphora)
12028 ("closer-mop" ,sbcl-closer-mop)
12029 ("hu.dwim.common-lisp" ,sbcl-hu.dwim.common-lisp)
12030 ("iterate" ,sbcl-iterate)
12031 ("metabang-bind" ,sbcl-metabang-bind)))
12032 (home-page "http://dwim.hu/")
12033 (synopsis "Common Lisp library shared by other hu.dwim systems")
12034 (description "This package contains a support library for other
12035 hu.dwim systems.")
12036 (license license:public-domain)))
12037
12038 (define-public cl-hu.dwim.common
12039 (sbcl-package->cl-source-package sbcl-hu.dwim.common))
12040
12041 (define-public ecl-hu.dwim.common
12042 (sbcl-package->ecl-package sbcl-hu.dwim.common))
12043
12044 (define-public sbcl-hu.dwim.defclass-star
12045 (let ((commit "39d458f1b1bc830d1f5e18a6a35bf0e96a2cfd61"))
12046 (package
12047 (name "sbcl-hu.dwim.defclass-star")
12048 ;; We used to set version from the date when it was a darcs repo, so we
12049 ;; keep the year so that package gets updated on previous installs.
12050 (version (git-version "2021" "1" commit))
12051 (source
12052 (origin
12053 (method git-fetch)
12054 (uri (git-reference
12055 (url "https://github.com/hu-dwim/hu.dwim.defclass-star")
12056 (commit commit)))
12057 (file-name (git-file-name name version))
12058 (sha256
12059 (base32 "0hfkq2wad98vkyxdg1wh18y86d9w9yqkm8lxkk96szvpwymm7lmq"))))
12060 (build-system asdf-build-system/sbcl)
12061 (native-inputs
12062 `( ;; These 2 inputs are only needed tests which are disabled, see below.
12063 ;; ("hu.dwim.common" ,sbcl-hu.dwim.common)
12064 ;; Need cl- package for the :hu.dwim.stefil+hu.dwim.def+swank system.
12065 ;; ("hu.dwim.stefil" ,cl-hu.dwim.stefil)
12066 ("hu.dwim.asdf" ,sbcl-hu.dwim.asdf)))
12067 (arguments
12068 `(#:test-asd-file "hu.dwim.defclass-star.test.asd"
12069 ;; Tests require a circular dependency: hu.dwim.stefil -> hu.dwim.def
12070 ;; -> hu.dwim.util -> hu.dwim.defclass-star.
12071 #:tests? #f))
12072 (home-page "https://github.com/hu-dwim/hu.dwim.defclass-star")
12073 (synopsis "Simplify definitions with defclass* and friends in Common Lisp")
12074 (description "@code{defclass-star} provides defclass* and defcondition* to
12075 simplify class and condition declarations. Features include:
12076
12077 @itemize
12078 @item Automatically export all or select slots at compile time.
12079 @item Define the @code{:initarg} and @code{:accessor} automatically.
12080 @item Specify a name transformer for both the @code{:initarg} and
12081 @code{:accessor}, etc.
12082 @item Specify the @code{:initform} as second slot value.
12083 @end itemize
12084
12085 See
12086 @url{https://common-lisp.net/project/defclass-star/configuration.lisp.html}
12087 for an example.")
12088 (license license:public-domain))))
12089
12090 (define-public cl-hu.dwim.defclass-star
12091 (sbcl-package->cl-source-package sbcl-hu.dwim.defclass-star))
12092
12093 (define-public ecl-hu.dwim.defclass-star
12094 (sbcl-package->ecl-package sbcl-hu.dwim.defclass-star))
12095
12096 (define-public sbcl-livesupport
12097 (let ((commit "71e6e412df9f3759ad8378fabb203913d82e228a")
12098 (revision "1"))
12099 (package
12100 (name "sbcl-livesupport")
12101 (version (git-version "0.0.0" revision commit))
12102 (source
12103 (origin
12104 (method git-fetch)
12105 (uri (git-reference
12106 (url "https://github.com/cbaggers/livesupport")
12107 (commit commit)))
12108 (file-name (git-file-name name version))
12109 (sha256
12110 (base32 "1rvnl0mncylbx63608pz5llss7y92j7z3ydambk9mcnjg2mjaapg"))))
12111 (build-system asdf-build-system/sbcl)
12112 (home-page "https://github.com/cbaggers/livesupport")
12113 (synopsis "Some helpers that make livecoding a little easier")
12114 (description "This package provides a macro commonly used in livecoding to
12115 enable continuing when errors are raised. Simply wrap around a chunk of code
12116 and it provides a restart called @code{continue} which ignores the error and
12117 carrys on from the end of the body.")
12118 (license license:bsd-2))))
12119
12120 (define-public cl-livesupport
12121 (sbcl-package->cl-source-package sbcl-livesupport))
12122
12123 (define-public ecl-livesupport
12124 (sbcl-package->ecl-package sbcl-livesupport))
12125
12126 (define-public sbcl-envy
12127 (let ((commit "956321b2852d58ba71c6fe621f5c2924178e9f88")
12128 (revision "1"))
12129 (package
12130 (name "sbcl-envy")
12131 (version (git-version "0.1" revision commit))
12132 (home-page "https://github.com/fukamachi/envy")
12133 (source
12134 (origin
12135 (method git-fetch)
12136 (uri (git-reference
12137 (url home-page)
12138 (commit commit)))
12139 (file-name (git-file-name name version))
12140 (sha256
12141 (base32 "17iwrfxcdinjbb2h6l09qf40s7xkbhrpmnljlwpjy8l8rll8h3vg"))))
12142 (build-system asdf-build-system/sbcl)
12143 ;; (native-inputs ; Only for tests.
12144 ;; `(("prove" ,sbcl-prove)
12145 ;; ("osicat" ,sbcl-osicat)))
12146 (arguments
12147 '(#:phases
12148 (modify-phases %standard-phases
12149 (add-after 'unpack 'fix-tests
12150 (lambda _
12151 (substitute* "envy-test.asd"
12152 (("cl-test-more") "prove"))
12153 #t)))
12154 ;; Tests fail with
12155 ;; Component ENVY-ASD::ENVY-TEST not found, required by #<SYSTEM "envy">
12156 ;; like xsubseq. Why?
12157 #:tests? #f))
12158 (synopsis "Common Lisp configuration switcher inspired by Perl's Config::ENV.")
12159 (description "Envy is a configuration manager for various applications.
12160 Envy uses an environment variable to determine a configuration to use. This
12161 can separate configuration system from an implementation.")
12162 (license license:bsd-2))))
12163
12164 (define-public cl-envy
12165 (sbcl-package->cl-source-package sbcl-envy))
12166
12167 (define-public ecl-envy
12168 (sbcl-package->ecl-package sbcl-envy))
12169
12170 (define-public sbcl-mito
12171 (let ((commit "d3b9e375ef364a65692da2185085a08c969ac88a")
12172 (revision "1"))
12173 (package
12174 (name "sbcl-mito")
12175 (version (git-version "0.1" revision commit))
12176 (home-page "https://github.com/fukamachi/mito")
12177 (source
12178 (origin
12179 (method git-fetch)
12180 (uri (git-reference
12181 (url home-page)
12182 (commit commit)))
12183 (file-name (git-file-name name version))
12184 (sha256
12185 (base32 "08mncgzjnbbsf1a6am3l73iw4lyfvz5ldjg5g84awfaxml4p73mb"))))
12186 (build-system asdf-build-system/sbcl)
12187 (native-inputs
12188 `(("prove" ,sbcl-prove)))
12189 (inputs
12190 `(("alexandria" ,sbcl-alexandria)
12191 ("cl-ppcre" ,sbcl-cl-ppcre)
12192 ("cl-reexport" ,sbcl-cl-reexport)
12193 ("closer-mop" ,sbcl-closer-mop)
12194 ("dbi" ,sbcl-dbi)
12195 ("dissect" ,sbcl-dissect)
12196 ("esrap" ,sbcl-esrap)
12197 ("local-time" ,sbcl-local-time)
12198 ("optima" ,sbcl-optima)
12199 ("sxql" ,sbcl-sxql)
12200 ("uuid" ,sbcl-uuid)))
12201 (arguments
12202 '(#:phases
12203 (modify-phases %standard-phases
12204 (add-after 'unpack 'remove-non-functional-tests
12205 (lambda _
12206 (substitute* "mito-test.asd"
12207 (("\\(:test-file \"db/mysql\"\\)") "")
12208 (("\\(:test-file \"db/postgres\"\\)") "")
12209 (("\\(:test-file \"dao\"\\)") "")
12210 ;; TODO: migration/sqlite3 should work, re-enable once
12211 ;; upstream has fixed it:
12212 ;; https://github.com/fukamachi/mito/issues/70
12213 (("\\(:test-file \"migration/sqlite3\"\\)") "")
12214 (("\\(:test-file \"migration/mysql\"\\)") "")
12215 (("\\(:test-file \"migration/postgres\"\\)") "")
12216 (("\\(:test-file \"postgres-types\"\\)") "")
12217 (("\\(:test-file \"mixin\"\\)") ""))
12218 #t)))
12219 ;; TODO: While all enabled tests pass, the phase fails with:
12220 ;; Component MITO-ASD::MITO-TEST not found, required by #<SYSTEM "mito">
12221 #:tests? #f))
12222 (synopsis "ORM for Common Lisp with migrations and relationships support")
12223 (description "Mito is yet another object relational mapper, and it aims
12224 to be a successor of Integral.
12225
12226 @itemize
12227 @item Support MySQL, PostgreSQL and SQLite3.
12228 @item Add id (serial/uuid primary key), created_at and updated_at by default
12229 like Ruby's ActiveRecord.
12230 @item Migrations.
12231 @item Database schema versioning.
12232 @end itemize\n")
12233 (license license:llgpl))))
12234
12235 (define-public cl-mito
12236 (sbcl-package->cl-source-package sbcl-mito))
12237
12238 (define-public ecl-mito
12239 (sbcl-package->ecl-package sbcl-mito))
12240
12241 (define-public sbcl-kebab
12242 (let ((commit "e7f77644c4e46131e7b8039d191d35fe6211f31b")
12243 (revision "1"))
12244 (package
12245 (name "sbcl-kebab")
12246 (version (git-version "0.1" revision commit))
12247 (home-page "https://github.com/pocket7878/kebab")
12248 (source
12249 (origin
12250 (method git-fetch)
12251 (uri (git-reference
12252 (url home-page)
12253 (commit commit)))
12254 (file-name (git-file-name name version))
12255 (sha256
12256 (base32 "0j5haabnvj0vz0rx9mwyfsb3qzpga9nickbjw8xs6vypkdzlqv1b"))))
12257 (build-system asdf-build-system/sbcl)
12258 (inputs
12259 `(("cl-ppcre" ,sbcl-cl-ppcre)
12260 ("alexandria" ,sbcl-alexandria)
12261 ("cl-interpol" ,sbcl-cl-interpol)
12262 ("split-sequence" ,sbcl-split-sequence)))
12263 (native-inputs
12264 `(("prove" ,sbcl-prove)))
12265 (arguments
12266 ;; Tests passes but the phase fails with
12267 ;; Component KEBAB-ASD::KEBAB-TEST not found, required by #<SYSTEM "kebab">.
12268 `(#:tests? #f))
12269 (synopsis "Common Lisp case converter")
12270 (description "This Common Lisp library converts strings, symbols and
12271 keywords between any of the following typographical cases: PascalCase,
12272 camelCase, snake_case, kebab-case (lisp-case).")
12273 (license license:llgpl))))
12274
12275 (define-public cl-kebab
12276 (sbcl-package->cl-source-package sbcl-kebab))
12277
12278 (define-public ecl-kebab
12279 (sbcl-package->ecl-package sbcl-kebab))
12280
12281 (define-public sbcl-datafly
12282 (let ((commit "adece27fcbc4b5ea39ad1a105048b6b7166e3b0d")
12283 (revision "1"))
12284 (package
12285 (name "sbcl-datafly")
12286 (version (git-version "0.1" revision commit))
12287 (home-page "https://github.com/fukamachi/datafly")
12288 (source
12289 (origin
12290 (method git-fetch)
12291 (uri (git-reference
12292 (url home-page)
12293 (commit commit)))
12294 (file-name (git-file-name name version))
12295 (sha256
12296 (base32 "16b78kzmglp2a4nxlxxl7rpf5zaibsgagn0p3c56fsxvx0c4hszv"))))
12297 (build-system asdf-build-system/sbcl)
12298 (inputs
12299 `(("alexandria" ,sbcl-alexandria)
12300 ("iterate" ,sbcl-iterate)
12301 ("optima" ,sbcl-optima)
12302 ("trivial-types" ,sbcl-trivial-types)
12303 ("closer-mop" ,sbcl-closer-mop)
12304 ("cl-syntax" ,sbcl-cl-syntax)
12305 ("sxql" ,sbcl-sxql)
12306 ("dbi" ,sbcl-dbi)
12307 ("babel" ,sbcl-babel)
12308 ("local-time" ,sbcl-local-time)
12309 ("function-cache" ,sbcl-function-cache)
12310 ("jonathan" ,sbcl-jonathan)
12311 ("kebab" ,sbcl-kebab)
12312 ("log4cl" ,sbcl-log4cl)))
12313 (native-inputs
12314 `(("prove" ,sbcl-prove)))
12315 (arguments
12316 ;; TODO: Tests fail with
12317 ;; While evaluating the form starting at line 22, column 0
12318 ;; of #P"/tmp/guix-build-sbcl-datafly-0.1-1.adece27.drv-0/source/t/datafly.lisp":
12319 ;; Unhandled SQLITE:SQLITE-ERROR in thread #<SB-THREAD:THREAD "main thread" RUNNING
12320 ;; {10009F8083}>:
12321 ;; Error when binding parameter 1 to value NIL.
12322 ;; Code RANGE: column index out of range.
12323 `(#:tests? #f))
12324 (synopsis "Lightweight database library for Common Lisp")
12325 (description "Datafly is a lightweight database library for Common Lisp.")
12326 (license license:bsd-3))))
12327
12328 (define-public cl-datafly
12329 (sbcl-package->cl-source-package sbcl-datafly))
12330
12331 (define-public ecl-datafly
12332 (sbcl-package->ecl-package sbcl-datafly))
12333
12334 (define-public sbcl-do-urlencode
12335 (let ((commit "199846441dad5dfac5478b8dee4b4e20d107af6a")
12336 (revision "1"))
12337 (package
12338 (name "sbcl-do-urlencode")
12339 (version (git-version "0.0.0" revision commit))
12340 (home-page "https://github.com/drdo/do-urlencode")
12341 (source
12342 (origin
12343 (method git-fetch)
12344 (uri (git-reference
12345 (url home-page)
12346 (commit commit)))
12347 (file-name (git-file-name name version))
12348 (sha256
12349 (base32 "0k2i3d4k9cpci235mwfm0c5a4yqfkijr716bjv7cdlpzx88lazm9"))))
12350 (build-system asdf-build-system/sbcl)
12351 (inputs
12352 `(("alexandria" ,sbcl-alexandria)
12353 ("babel" ,sbcl-babel)))
12354 (synopsis "Percent Encoding (aka URL Encoding) Common Lisp library")
12355 (description "This library provides trivial percent encoding and
12356 decoding functions for URLs.")
12357 (license license:isc))))
12358
12359 (define-public cl-do-urlencode
12360 (sbcl-package->cl-source-package sbcl-do-urlencode))
12361
12362 (define-public ecl-do-urlencode
12363 (sbcl-package->ecl-package sbcl-do-urlencode))
12364
12365 (define-public sbcl-cl-emb
12366 (let ((commit "fd8652174d048d4525a81f38cdf42f4fa519f840")
12367 (revision "1"))
12368 (package
12369 (name "sbcl-cl-emb")
12370 (version (git-version "0.4.3" revision commit))
12371 (home-page "https://common-lisp.net/project/cl-emb/")
12372 (source
12373 (origin
12374 (method git-fetch)
12375 (uri (git-reference
12376 (url "https://github.com/38a938c2/cl-emb")
12377 (commit commit)))
12378 (file-name (git-file-name name version))
12379 (sha256
12380 (base32 "1xcm31n7afh5316lwz8iqbjx7kn5lw0l11arg8mhdmkx42aj4gkk"))))
12381 (build-system asdf-build-system/sbcl)
12382 (inputs
12383 `(("cl-ppcre" ,sbcl-cl-ppcre)))
12384 (synopsis "Templating system for Common Lisp")
12385 (description "A mixture of features from eRuby and HTML::Template. You
12386 could name it \"Yet Another LSP\" (LispServer Pages) but it's a bit more than
12387 that and not limited to a certain server or text format.")
12388 (license license:llgpl))))
12389
12390 (define-public cl-emb
12391 (sbcl-package->cl-source-package sbcl-cl-emb))
12392
12393 (define-public ecl-cl-emb
12394 (sbcl-package->ecl-package sbcl-cl-emb))
12395
12396 (define-public sbcl-cl-project
12397 (let ((commit "151107014e534fc4666222d57fec2cc8549c8814")
12398 (revision "1"))
12399 (package
12400 (name "sbcl-cl-project")
12401 (version (git-version "0.3.1" revision commit))
12402 (home-page "https://github.com/fukamachi/cl-project")
12403 (source
12404 (origin
12405 (method git-fetch)
12406 (uri (git-reference
12407 (url home-page)
12408 (commit commit)))
12409 (file-name (git-file-name name version))
12410 (sha256
12411 (base32 "1rmh6s1ncv8s2yrr14ja9wisgg745sq6xibqwb341ikdicxdp26y"))))
12412 (build-system asdf-build-system/sbcl)
12413 (inputs
12414 `(("cl-emb" ,sbcl-cl-emb)
12415 ("cl-ppcre" ,sbcl-cl-ppcre)
12416 ("local-time" ,sbcl-local-time)
12417 ("prove" ,sbcl-prove)))
12418 (arguments
12419 ;; Tests depend on caveman, which in turns depends on cl-project.
12420 '(#:tests? #f
12421 #:asd-files '("cl-project.asd")))
12422 (synopsis "Generate a skeleton for modern Common Lisp projects")
12423 (description "This library provides a modern project skeleton generator.
12424 In contract with other generators, CL-Project generates one package per file
12425 and encourages unit testing by generating a system for unit testing, so you
12426 can begin writing unit tests as soon as the project is generated.")
12427 (license license:llgpl))))
12428
12429 (define-public cl-project
12430 (sbcl-package->cl-source-package sbcl-cl-project))
12431
12432 (define-public ecl-cl-project
12433 (sbcl-package->ecl-package sbcl-cl-project))
12434
12435 (define-public sbcl-caveman
12436 (let ((commit "faa5f7e3b364fd7e7096af9a7bb06728b8d80441") ; No release since 2012
12437 (revision "1"))
12438 (package
12439 (name "sbcl-caveman")
12440 (version (git-version "2.4.0" revision commit))
12441 (home-page "http://8arrow.org/caveman/")
12442 (source
12443 (origin
12444 (method git-fetch)
12445 (uri (git-reference
12446 (url "https://github.com/fukamachi/caveman/")
12447 (commit commit)))
12448 (file-name (git-file-name name version))
12449 (sha256
12450 (base32 "0kh0gx05pczk8f7r9qdi4zn1p3d0a2prps27k7jpgvc1dxkl8qhq"))))
12451 (build-system asdf-build-system/sbcl)
12452 (inputs
12453 `(("ningle" ,cl-ningle)
12454 ("lack" ,sbcl-lack)
12455 ("cl-project" ,sbcl-cl-project)
12456 ("dbi" ,sbcl-dbi)
12457 ("cl-syntax" ,sbcl-cl-syntax)
12458 ("myway" ,sbcl-myway)
12459 ("quri" ,sbcl-quri)))
12460 (native-inputs
12461 `(("usocket" ,sbcl-usocket)
12462 ("dexador" ,sbcl-dexador)))
12463 (arguments
12464 `(#:asd-files '("caveman2.asd")
12465 #:asd-systems '("caveman2")
12466 #:phases
12467 (modify-phases %standard-phases
12468 (add-after 'unpack 'remove-v1
12469 (lambda _
12470 (delete-file-recursively "v1")
12471 (for-each delete-file
12472 '("README.v1.markdown" "caveman.asd" "caveman-test.asd")))))
12473 ;; TODO: Tests fail with:
12474 ;; writing /gnu/store/...-sbcl-caveman-2.4.0-1.faa5f7e/share/common-lisp/sbcl-source/caveman2/v2/t/tmp/myapp573/tests/myapp573.lisp
12475 ;; While evaluating the form starting at line 38, column 0
12476 ;; of #P"/tmp/guix-build-sbcl-caveman-2.4.0-1.faa5f7e.drv-0/source/v2/t/caveman.lisp":
12477 ;; Unhandled ASDF/FIND-COMPONENT:MISSING-COMPONENT in thread #<SB-THREAD:THREAD "main thread" RUNNING
12478 ;; {10009F8083}>:
12479 ;; Component "myapp573" not found
12480 #:tests? #f))
12481 (synopsis "Lightweight web application framework in Common Lisp")
12482 (description "Caveman is intended to be a collection of common parts for
12483 web applications. Caveman2 has three design goals:
12484
12485 @itemize
12486 @item Be extensible.
12487 @item Be practical.
12488 @item Don't force anything.
12489 @end itemize\n")
12490 (license license:llgpl))))
12491
12492 (define-public cl-caveman
12493 (package
12494 (inherit
12495 (sbcl-package->cl-source-package sbcl-caveman))
12496 (propagated-inputs
12497 `(("ningle" ,cl-ningle)))))
12498
12499 (define-public ecl-caveman
12500 (sbcl-package->ecl-package sbcl-caveman))
12501
12502 (define-public sbcl-lambda-fiddle
12503 (let ((commit "d16bba55acf6065b412f64ab8fdff679a4a32b1e") ;; no tagged branch
12504 (revision "1"))
12505 (package
12506 (name "sbcl-lambda-fiddle")
12507 (version (git-version "1.0.0" revision commit))
12508 (source
12509 (origin
12510 (method git-fetch)
12511 (uri (git-reference
12512 (url "https://github.com/Shinmera/lambda-fiddle")
12513 (commit commit)))
12514 (file-name (git-file-name name version))
12515 (sha256
12516 (base32 "1zarj1pqjqmk95kdx1axkgpwy2wq3canczk7f9z5hvaw5an6gand"))))
12517 (build-system asdf-build-system/sbcl)
12518 (home-page "https://github.com/Shinmera/lambda-fiddle")
12519 (synopsis "Collection of utilities to process lambda-lists")
12520 (description "This collection of utilities is useful in contexts where
12521 you want a macro that uses lambda-lists in some fashion but need more precise
12522 processing.")
12523 (license license:zlib))))
12524
12525 (define-public cl-lambda-fiddle
12526 (sbcl-package->cl-source-package sbcl-lambda-fiddle))
12527
12528 (define-public ecl-lambda-fiddle
12529 (sbcl-package->ecl-package sbcl-lambda-fiddle))
12530
12531 (define-public sbcl-xmls
12532 (let ((commit "18546f0850b1338e03997ffd1696add1cb1800d1") ;; no tagged branch
12533 (revision "1"))
12534 (package
12535 (name "sbcl-xmls")
12536 (version (git-version "3.0.2" revision commit))
12537 (source
12538 (origin
12539 (method git-fetch)
12540 (uri (git-reference
12541 (url "https://github.com/rpgoldman/xmls")
12542 (commit commit)))
12543 (file-name (git-file-name name version))
12544 (sha256
12545 (base32 "1lmvfml2ldbb1wkhm25jqqk2bhwsz52hhcgljbnzj1xr8xhc3anp"))))
12546 (native-inputs
12547 `(("fiveam" ,sbcl-fiveam)))
12548 (build-system asdf-build-system/sbcl)
12549 (home-page "https://github.com/rpgoldman/xmls")
12550 (synopsis "Non-validating XML parser for Common Lisp")
12551 (description "Xmls is a self-contained, easily embedded parser that
12552 recognizes a useful subset of the XML spec. It provides a simple mapping from
12553 XML to Lisp structures or s-expressions and back.")
12554 (license license:bsd-2))))
12555
12556 (define-public cl-xmls
12557 (sbcl-package->cl-source-package sbcl-xmls))
12558
12559 (define-public ecl-xmls
12560 (sbcl-package->ecl-package sbcl-xmls))
12561
12562 (define-public sbcl-geco
12563 (package
12564 (name "sbcl-geco")
12565 (version "2.1.1")
12566 (source
12567 (origin
12568 (method git-fetch)
12569 (uri (git-reference
12570 (url "https://github.com/gpwwjr/GECO")
12571 (commit (string-append "v" version))))
12572 (file-name (git-file-name "geco" version))
12573 (sha256
12574 (base32 "1rc8a4mk40hjx5qy980hjylv6xxqdbq38hg8c4w30y93abfd519s"))))
12575 (build-system asdf-build-system/sbcl)
12576 (home-page "http://hiwaay.net/~gpw/geco/geco.html")
12577 (synopsis "Genetic algorithm toolkit for Common Lisp")
12578 (description
12579 "GECO (Genetic Evolution through Combination of Objects) is an extensible,
12580 object-oriented framework for prototyping genetic algorithms in Common Lisp.")
12581 (license license:lgpl2.1+)))
12582
12583 (define-public cl-geco
12584 (sbcl-package->cl-source-package sbcl-geco))
12585
12586 (define-public ecl-geco
12587 (sbcl-package->ecl-package sbcl-geco))
12588
12589 (define-public sbcl-html-entities
12590 (let ((commit "4af018048e891f41d77e7d680ed3aeb639e1eedb"))
12591 (package
12592 (name "sbcl-html-entities")
12593 (version (git-version "0.02" "1" commit))
12594 (source
12595 (origin
12596 (method git-fetch)
12597 (uri (git-reference
12598 (url "https://github.com/BnMcGn/html-entities/")
12599 (commit commit)))
12600 (file-name (git-file-name name version))
12601 (sha256
12602 (base32 "1b2yl6lf6vis17y4n5s505p7ica96bdafcl6vydy1hg50fy33nfr"))))
12603 (build-system asdf-build-system/sbcl)
12604 (inputs
12605 `(("ppcre" ,sbcl-cl-ppcre)))
12606 (native-inputs
12607 `(("fiveam" ,sbcl-fiveam)))
12608 (home-page "https://github.com/BnMcGn/html-entities/")
12609 (synopsis "Encode and decode entities in HTML with Common Lisp")
12610 (description "Html-entities is a Common Lisp library that lets you
12611 encode and decode entities in HTML.")
12612 (license license:expat))))
12613
12614 (define-public cl-html-entities
12615 (sbcl-package->cl-source-package sbcl-html-entities))
12616
12617 (define-public ecl-html-entities
12618 (sbcl-package->ecl-package sbcl-html-entities))
12619
12620 (define-public sbcl-quicksearch
12621 (let ((commit "fb02ecf7c876ec580ab18c7d2c8c7814c06af599"))
12622 (package
12623 (name "sbcl-quicksearch")
12624 (version (git-version "0.01.04" "1" commit))
12625 (source
12626 (origin
12627 (method git-fetch)
12628 (uri (git-reference
12629 (url "https://github.com/tkych/quicksearch/")
12630 (commit commit)))
12631 (file-name (git-file-name name version))
12632 (sha256
12633 (base32 "16k19zjkhh7r64vjq371k5jwjs7cdfjz83flh561n4h4v1z89fps"))))
12634 (build-system asdf-build-system/sbcl)
12635 (inputs
12636 `(("bordeaux-threads" ,sbcl-bordeaux-threads)
12637 ("iterate" ,sbcl-iterate)
12638 ("alexandria" ,sbcl-alexandria)
12639 ("anaphora" ,sbcl-anaphora)
12640 ("ppcre" ,sbcl-cl-ppcre)
12641 ("drakma" ,sbcl-drakma)
12642 ("html-entities" ,sbcl-html-entities)
12643 ("yason" ,sbcl-yason)
12644 ("flexi-streams" ,sbcl-flexi-streams)
12645 ("do-urlencode" ,sbcl-do-urlencode)))
12646 (home-page "https://github.com/tkych/quicksearch/")
12647 (synopsis "Search Engine Interface for Common Lisp packages")
12648 (description "Quicksearch is a search-engine-interface for Common Lisp.
12649 The goal of Quicksearch is to find the Common Lisp library quickly. For
12650 example, if you will find the library about json, just type @code{(qs:?
12651 'json)} at REPL.
12652
12653 The function @code{quicksearch} searches for Common Lisp projects in
12654 Quicklisp, Cliki, GitHub and BitBucket, then outputs results in REPL. The
12655 function @code{?} is abbreviation wrapper for @code{quicksearch}.")
12656 (license license:expat))))
12657
12658 (define-public cl-quicksearch
12659 (sbcl-package->cl-source-package sbcl-quicksearch))
12660
12661 (define-public ecl-quicksearch
12662 (sbcl-package->ecl-package sbcl-quicksearch))
12663
12664 (define-public sbcl-agutil
12665 (let ((commit "df188d754d472da9faa1601a48f1f37bb7b34d68"))
12666 (package
12667 (name "sbcl-agutil")
12668 (version (git-version "0.0.1" "1" commit))
12669 (source
12670 (origin
12671 (method git-fetch)
12672 (uri (git-reference
12673 (url "https://github.com/alex-gutev/agutil/")
12674 (commit commit)))
12675 (file-name (git-file-name name version))
12676 (sha256
12677 (base32 "1xpnyzksk2xld64b6lw6rw0gn5zxlb77jwna59sd4yl7kxhxlfpf"))))
12678 (build-system asdf-build-system/sbcl)
12679 (inputs
12680 `(("alexandria" ,sbcl-alexandria)
12681 ("trivia" ,sbcl-trivia)))
12682 (home-page "https://github.com/alex-gutev/agutil/")
12683 (synopsis "Collection of Common Lisp utilities")
12684 (description "A collection of Common Lisp utility functions and macros
12685 mostly not found in other utility packages.")
12686 (license license:expat))))
12687
12688 (define-public cl-agutil
12689 (sbcl-package->cl-source-package sbcl-agutil))
12690
12691 (define-public ecl-agutil
12692 (sbcl-package->ecl-package sbcl-agutil))
12693
12694 (define-public sbcl-custom-hash-table
12695 (let ((commit "f26983133940f5edf826ebbc8077acc04816ddfa"))
12696 (package
12697 (name "sbcl-custom-hash-table")
12698 (version (git-version "0.3" "1" commit))
12699 (source
12700 (origin
12701 (method git-fetch)
12702 (uri (git-reference
12703 (url "https://github.com/metawilm/cl-custom-hash-table")
12704 (commit commit)))
12705 (file-name (git-file-name name version))
12706 (sha256
12707 (base32 "1k4mvrpbqqds2fwjxp1bxmrfmr8ch4dkwhnkbw559knbqshvrlj5"))))
12708 (build-system asdf-build-system/sbcl)
12709 (arguments
12710 '(#:asd-files '("cl-custom-hash-table.asd")
12711 #:asd-systems '("cl-custom-hash-table")))
12712 (home-page "https://github.com/metawilm/cl-custom-hash-table")
12713 (synopsis "Custom hash tables for Common Lisp")
12714 (description "This library allows creation of hash tables with arbitrary
12715 @code{test}/@code{hash} functions, in addition to the @code{test} functions
12716 allowed by the standard (@code{EQ}, @code{EQL}, @code{EQUAL} and
12717 @code{EQUALP}), even in implementations that don't support this functionality
12718 directly.")
12719 (license license:expat))))
12720
12721 (define-public cl-custom-hash-table
12722 (sbcl-package->cl-source-package sbcl-custom-hash-table))
12723
12724 (define-public ecl-custom-hash-table
12725 (sbcl-package->ecl-package sbcl-custom-hash-table))
12726
12727 (define-public sbcl-collectors
12728 (let ((commit "13acef25d8422d1d82e067b1861e513587c166ee"))
12729 (package
12730 (name "sbcl-collectors")
12731 (version (git-version "0.1" "1" commit))
12732 (source
12733 (origin
12734 (method git-fetch)
12735 (uri (git-reference
12736 (url "https://github.com/AccelerationNet/collectors")
12737 (commit commit)))
12738 (file-name (git-file-name name version))
12739 (sha256
12740 (base32 "1si68n1j6rpns8jw6ksqjpb937pdl30v7xza8rld7j5vh0jhy2yi"))))
12741 (build-system asdf-build-system/sbcl)
12742 (inputs
12743 `(("alexandria" ,sbcl-alexandria)
12744 ("closer-mop" ,sbcl-closer-mop)
12745 ("symbol-munger" ,sbcl-symbol-munger)))
12746 (native-inputs
12747 `(("lisp-unit2" ,sbcl-lisp-unit2)))
12748 (home-page "https://github.com/AccelerationNet/collectors/")
12749 (synopsis "Common lisp library providing collector macros")
12750 (description "A small collection of common lisp macros to make
12751 collecting values easier.")
12752 (license license:bsd-3))))
12753
12754 (define-public cl-collectors
12755 (sbcl-package->cl-source-package sbcl-collectors))
12756
12757 (define-public ecl-collectors
12758 (sbcl-package->ecl-package sbcl-collectors))
12759
12760 (define-public sbcl-cl-environments
12761 (let ((commit "0b22154c5afefef23d1eba9a4fae11d73580ef41")) ; No version in 2 years.
12762 (package
12763 (name "sbcl-cl-environments")
12764 (version (git-version "0.2.3" "1" commit))
12765 (source
12766 (origin
12767 (method git-fetch)
12768 (uri (git-reference
12769 (url "https://github.com/alex-gutev/cl-environments")
12770 (commit commit)))
12771 (file-name (git-file-name name version))
12772 (sha256
12773 (base32
12774 "18r3wfarr7lgn78m6c66r0r9aazirv07gy7xgvqkl9pmrz1bc47m"))))
12775 (build-system asdf-build-system/sbcl)
12776 (inputs
12777 `(("alexandria" ,sbcl-alexandria)
12778 ("anaphora" ,sbcl-anaphora)
12779 ("collectors" ,sbcl-collectors)
12780 ("optima" ,sbcl-optima)))
12781 (native-inputs
12782 `(("prove" ,sbcl-prove)))
12783 (home-page "https://github.com/alex-gutev/cl-environments")
12784 (synopsis "Implements the Common Lisp standard environment access API")
12785 (description "This library provides a uniform API, as specified in Common
12786 Lisp the Language 2, for accessing information about variable and function
12787 bindings from implementation-defined lexical environment objects. All major
12788 Common Lisp implementations are supported, even those which don't support the
12789 CLTL2 environment access API.")
12790 (license license:expat))))
12791
12792 (define-public cl-environments
12793 (sbcl-package->cl-source-package sbcl-cl-environments))
12794
12795 (define-public ecl-environments
12796 (sbcl-package->ecl-package sbcl-cl-environments))
12797
12798 (define-public sbcl-static-dispatch
12799 (let ((commit "6243afcd152854c52ba33daef7394367b657d9c6")
12800 (revision "1"))
12801 (package
12802 (name "sbcl-static-dispatch")
12803 (version (git-version "0.3" revision commit))
12804 (source
12805 (origin
12806 (method git-fetch)
12807 (uri (git-reference
12808 (url "https://github.com/alex-gutev/static-dispatch")
12809 (commit commit)))
12810 (file-name (git-file-name "static-dispatch" version))
12811 (sha256
12812 (base32 "1lli9ar1xbnhkgb5d01rlw4pvfylg2arrw68np2c07fpkkafimg7"))))
12813 (build-system asdf-build-system/sbcl)
12814 (native-inputs
12815 `(("prove" ,sbcl-prove)))
12816 (inputs
12817 `(("agutil" ,sbcl-agutil)
12818 ("alexandria" ,sbcl-alexandria)
12819 ("anaphora" ,sbcl-anaphora)
12820 ("arrows" ,sbcl-arrows)
12821 ("cl-environments" ,sbcl-cl-environments)
12822 ("closer-mop" ,sbcl-closer-mop)
12823 ("iterate" ,sbcl-iterate)
12824 ("trivia" ,sbcl-trivia)))
12825 (home-page "https://github.com/alex-gutev/static-dispatch")
12826 (synopsis "Static generic function dispatch for Common Lisp")
12827 (description "Static dispatch is a Common Lisp library, inspired by
12828 @code{inlined-generic-function}, which allows standard Common Lisp generic
12829 function dispatch to be performed statically (at compile time) rather than
12830 dynamically (runtime). This is similar to what is known as \"overloading\" in
12831 languages such as C++ and Java.
12832
12833 The purpose of static dispatch is to provide an optimization in cases where
12834 the usual dynamic dispatch is too slow, and the dynamic features of generic
12835 functions, such as adding/removing methods at runtime are not required. An
12836 example of such a case is a generic equality comparison function. Currently
12837 generic functions are considered far too slow to implement generic arithmetic
12838 and comparison operations when used heavily in numeric code.")
12839 (license license:expat))))
12840
12841 (define-public cl-static-dispatch
12842 (sbcl-package->cl-source-package sbcl-static-dispatch))
12843
12844 (define-public ecl-static-dispatch
12845 (sbcl-package->ecl-package sbcl-static-dispatch))
12846
12847 (define-public sbcl-generic-cl
12848 ;; Latest commit includes a necessary fix for our Guix build.
12849 (let ((commit "8e5a81487ee3c13fe5ffdc8bdda161d476639535"))
12850 (package
12851 (name "sbcl-generic-cl")
12852 (version (git-version "0.7.1" "1" commit))
12853 (source
12854 (origin
12855 (method git-fetch)
12856 (uri (git-reference
12857 (url "https://github.com/alex-gutev/generic-cl")
12858 (commit commit)))
12859 (file-name (git-file-name name version))
12860 (sha256
12861 (base32
12862 "11w0g79s4wmc78vmfng437rmsgnp5qn246zcyr540fp5nw0ad6ix"))))
12863 (build-system asdf-build-system/sbcl)
12864 (inputs
12865 `(("agutil" ,sbcl-agutil)
12866 ("alexandria" ,sbcl-alexandria)
12867 ("anaphora" ,sbcl-anaphora)
12868 ("arrows" ,sbcl-arrows)
12869 ("cl-custom-hash-table" ,sbcl-custom-hash-table)
12870 ("static-dispatch" ,sbcl-static-dispatch)
12871 ("trivia" ,sbcl-trivia)))
12872 (native-inputs
12873 `(("prove" ,sbcl-prove)))
12874 (arguments
12875 ;; Tests fail because SBCL head size is not high enough.
12876 ;; https://github.com/alex-gutev/generic-cl/issues/6
12877 `(#:tests? #f))
12878 (home-page "https://alex-gutev.github.io/generic-cl/")
12879 (synopsis "Generic function interface to standard Common Lisp functions")
12880 (description "@code{generic-cl} provides a generic function wrapper over
12881 various functions in the Common Lisp standard, such as equality predicates and
12882 sequence operations. The goal of this wrapper is to provide a standard
12883 interface to common operations, such as testing for the equality of two
12884 objects, which is extensible to user-defined types.")
12885 (license license:expat))))
12886
12887 (define-public cl-generic-cl
12888 (sbcl-package->cl-source-package sbcl-generic-cl))
12889
12890 (define-public ecl-generic-cl
12891 (sbcl-package->ecl-package sbcl-generic-cl))
12892
12893 (define-public sbcl-defpackage-plus
12894 (let ((revision "0")
12895 (commit "5492e27e0bdb7b75fa5177ea4388519dc7a75f11"))
12896 (package
12897 (name "sbcl-defpackage-plus")
12898 (version (git-version "1.0" revision commit))
12899 (source
12900 (origin
12901 (method git-fetch)
12902 (uri (git-reference
12903 (url "https://github.com/rpav/defpackage-plus")
12904 (commit commit)))
12905 (file-name (git-file-name name version))
12906 (sha256
12907 (base32 "0lzljvf343xb6mlh6lni2i27hpm5qd376522mk6hr2pa20vd6rdq"))))
12908 (build-system asdf-build-system/sbcl)
12909 (inputs
12910 `(("alexandria" ,sbcl-alexandria)))
12911 (home-page "https://github.com/rpav/defpackage-plus")
12912 (synopsis "Extensible @code{DEFPACKAGE} variant with version support")
12913 (description
12914 "@code{DEFPACKAGE-PLUS} is an extensible @code{DEFPACKAGE} variant with
12915 predictable cross-platform behavior and some utilities useful for versioning.")
12916 (license license:bsd-2))))
12917
12918 (define-public cl-defpackage-plus
12919 (sbcl-package->cl-source-package sbcl-defpackage-plus))
12920
12921 (define-public ecl-defpackage-plus
12922 (sbcl-package->ecl-package sbcl-defpackage-plus))
12923
12924 (define-public sbcl-deploy
12925 (let ((commit "9b20e64fe924b9e31832304d87a3a72c383dc6d8")
12926 (revision "2"))
12927 (package
12928 (name "sbcl-deploy")
12929 (version (git-version "1.0.0" revision commit))
12930 (source
12931 (origin
12932 (method git-fetch)
12933 (uri (git-reference
12934 (url "https://github.com/Shinmera/deploy")
12935 (commit commit)))
12936 (file-name (git-file-name "deploy" version))
12937 (sha256
12938 (base32 "07pfkibaridihg8lbq2czwa4iqifqk24n6rx7bfnv7i49p1ppja1"))))
12939 (build-system asdf-build-system/sbcl)
12940 (arguments
12941 `(#:test-asd-file "deploy-test.asd"
12942 #:asd-files '("deploy.asd"
12943 "deploy-test.asd")))
12944 (native-inputs
12945 `(("cl-mpg123" ,sbcl-cl-mpg123)
12946 ("cl-out123" ,sbcl-cl-out123)))
12947 (inputs
12948 `(("cffi" ,sbcl-cffi)
12949 ("documentation-utils" ,sbcl-documentation-utils)
12950 ("trivial-features" ,sbcl-trivial-features)))
12951 (home-page "https://shinmera.github.io/deploy/")
12952 (synopsis "Deployment tools for standalone Common Lisp application")
12953 (description
12954 "This is a system to help you easily and quickly deploy standalone
12955 common lisp applications as binaries. Specifically it is geared towards
12956 applications with foreign library dependencies that run some kind of GUI.")
12957 (license license:artistic2.0))))
12958
12959 (define-public cl-deploy
12960 (sbcl-package->cl-source-package sbcl-deploy))
12961
12962 (define-public ecl-deploy
12963 (sbcl-package->ecl-package sbcl-deploy))
12964
12965 (define-public sbcl-deeds
12966 ;; taged branch is outdated
12967 (let ((revision "1")
12968 (commit "f5df54eac79b58a34030e0eb8acf3952c788410d"))
12969 (package
12970 (name "sbcl-deeds")
12971 (version (git-version "1.1.1" revision commit))
12972 (source
12973 (origin
12974 (method git-fetch)
12975 (uri (git-reference
12976 (url "https://github.com/Shinmera/deeds")
12977 (commit commit)))
12978 (file-name (git-file-name name version))
12979 (sha256
12980 (base32 "062cnb2dwli6pw3zvv46jfxyxdzcbzwsck5pa6nw03qf1j1hyg3k"))))
12981 (build-system asdf-build-system/sbcl)
12982 (inputs
12983 `(("bordeaux-threads" ,sbcl-bordeaux-threads)
12984 ("closer-mop" ,sbcl-closer-mop)
12985 ("form-fiddle" ,sbcl-form-fiddle)
12986 ("lambda-fiddle" ,sbcl-lambda-fiddle)))
12987 (home-page "https://github.com/Shinmera/deeds")
12988 (synopsis "Extensible Event Delivery System")
12989 (description
12990 "@code{deeds} allows for efficient event delivery to multiple handlers
12991 with a complex event filtering system.")
12992 (license license:zlib))))
12993
12994 (define-public cl-deeds
12995 (sbcl-package->cl-source-package sbcl-deeds))
12996
12997 (define-public ecl-deeds
12998 (sbcl-package->ecl-package sbcl-deeds))
12999
13000 (define-public sbcl-make-hash
13001 ;; no tagged branch
13002 (let ((revision "1")
13003 (commit "ae0909cd8e697520a1085fac6f54ac2b448ebd21"))
13004 (package
13005 (name "sbcl-make-hash")
13006 (version (git-version "1.0.2" revision commit))
13007 (source
13008 (origin
13009 (method git-fetch)
13010 (uri (git-reference
13011 (url "https://github.com/genovese/make-hash")
13012 (commit commit)))
13013 (file-name (git-file-name name version))
13014 (sha256
13015 (base32 "1qa4mcmb3pv44py0j129dd8hjx09c2akpnds53b69151mgwv5qz8"))))
13016 (build-system asdf-build-system/sbcl)
13017 (home-page "https://github.com/genovese/make-hash")
13018 (synopsis "Common Lisp package for flexible hash table creation")
13019 (description
13020 "This is a Common Lisp package for hash table creation with flexible,
13021 extensible initializers.")
13022 (license license:bsd-3))))
13023
13024 (define-public cl-make-hash
13025 (sbcl-package->cl-source-package sbcl-make-hash))
13026
13027 (define-public ecl-make-hash
13028 (sbcl-package->ecl-package sbcl-make-hash))
13029
13030 (define-public sbcl-claw-support
13031 (package
13032 (name "sbcl-claw-support")
13033 (version "1.0.0")
13034 (source
13035 (origin
13036 (method git-fetch)
13037 (uri (git-reference
13038 (url "https://github.com/borodust/claw-support")
13039 (commit "9a15c8bed04585f45e6a461bcda1b475144dbd0b")))
13040 (file-name (git-file-name name version))
13041 (sha256
13042 (base32 "1my2ka7h72ipx5n3b465g6kjkasrhsvhqlijwcg6dhlzs5yygl23"))))
13043 (build-system asdf-build-system/sbcl)
13044 (home-page "https://github.com/borodust/claw-support")
13045 (synopsis "Support routines for claw")
13046 (description
13047 "This package provides support routines for the @code{claw} Common Lisp
13048 package.")
13049 (license license:expat)))
13050
13051 (define-public cl-claw-support
13052 (sbcl-package->cl-source-package sbcl-claw-support))
13053
13054 (define-public ecl-claw-support
13055 (sbcl-package->ecl-package sbcl-claw-support))
13056
13057 (define-public sbcl-claw
13058 (let ((revision "0")
13059 (commit "3cd4a96fca95eb9e8d5d069426694669f81b2250"))
13060 (package
13061 (name "sbcl-claw")
13062 (version (git-version "1.0" revision commit))
13063 (source
13064 (origin
13065 (method git-fetch)
13066 (uri (git-reference
13067 (url "https://github.com/borodust/claw")
13068 (commit commit)))
13069 (file-name (git-file-name "claw" version))
13070 (sha256
13071 (base32 "146yv0hc4hmk72562ssj2d41143pp84dcbd1h7f4nx1c7hf2bb0d"))))
13072 (build-system asdf-build-system/sbcl)
13073 (inputs
13074 `(("alexandria" ,sbcl-alexandria)
13075 ("cffi" ,sbcl-cffi)
13076 ("cl-json" ,sbcl-cl-json)
13077 ("cl-ppcre" ,sbcl-cl-ppcre)
13078 ("claw-support" ,sbcl-claw-support)
13079 ("local-time" ,sbcl-local-time)
13080 ("trivial-features" ,sbcl-trivial-features)))
13081 (home-page "https://github.com/borodust/claw")
13082 (synopsis "Autowrapper for Common Lisp")
13083 (description
13084 "This is a Common Lisp autowrapping facility for quickly creating clean
13085 and lean bindings to C libraries.")
13086 (license license:bsd-2))))
13087
13088 (define-public cl-claw
13089 (sbcl-package->cl-source-package sbcl-claw))
13090
13091 (define-public ecl-claw
13092 (sbcl-package->ecl-package sbcl-claw))
13093
13094 (define-public sbcl-claw-utils
13095 (let ((revision "0")
13096 (commit "efe25016501973dc369f067a64c7d225802bc56f"))
13097 (package
13098 (name "sbcl-claw-utils")
13099 ;; version is not specified
13100 (version (git-version "0.0.0" revision commit))
13101 (source
13102 (origin
13103 (method git-fetch)
13104 (uri (git-reference
13105 (url "https://github.com/borodust/claw-utils")
13106 (commit commit)))
13107 (file-name (git-file-name "claw-utils" version))
13108 (sha256
13109 (base32 "01df3kyf2qs3czi332dnz2s35x2j0fq46vgmsw7wjrrvnqc22mk5"))))
13110 (build-system asdf-build-system/sbcl)
13111 (inputs
13112 `(("alexandria" ,sbcl-alexandria)
13113 ("cffi" ,sbcl-cffi)
13114 ("claw" ,sbcl-claw)))
13115 (home-page "https://github.com/borodust/claw-utils")
13116 (synopsis "Utilities for easier autowrapping")
13117 (description
13118 "This Common Lisp library contains various handy utilties to help
13119 autowrapping with @code{claw}.")
13120 (license license:expat))))
13121
13122 (define-public cl-claw-utils
13123 (sbcl-package->cl-source-package sbcl-claw-utils))
13124
13125 (define-public ecl-claw-utils
13126 (sbcl-package->ecl-package sbcl-claw-utils))
13127
13128 (define-public sbcl-array-operations
13129 (let ((commit "75cbc3b1adb2e3ce2109489753d0f290b071e81b")
13130 (revision "0"))
13131 (package
13132 (name "sbcl-array-operations")
13133 (version (git-version "0.0.0" revision commit))
13134 (source
13135 (origin
13136 (method git-fetch)
13137 (uri (git-reference
13138 (url "https://github.com/bendudson/array-operations")
13139 (commit commit)))
13140 (file-name (git-file-name "array-operations" version))
13141 (sha256
13142 (base32 "0ip49hhq32w80qsc7jmspyda5r2rsszvw0mk2r3341cld78sz9ya"))))
13143 (build-system asdf-build-system/sbcl)
13144 (native-inputs
13145 `(("alexandria" ,sbcl-alexandria)
13146 ("clunit2" ,sbcl-clunit2)))
13147 (inputs
13148 `(("let-plus" ,sbcl-let-plus)))
13149 (synopsis "Simple array operations library for Common Lisp")
13150 (description
13151 "This library is a collection of functions and macros for manipulating
13152 Common Lisp arrays and performing numerical calculations with them.")
13153 (home-page "https://github.com/bendudson/array-operations")
13154 (license license:expat))))
13155
13156 (define-public cl-array-operations
13157 (sbcl-package->cl-source-package sbcl-array-operations))
13158
13159 (define-public ecl-array-operations
13160 (sbcl-package->ecl-package sbcl-array-operations))
13161
13162 (define-public sbcl-clml
13163 (let ((commit "95505b54c8c7b4b27f500c3be97fa5732f4b51a8")
13164 (revision "0"))
13165 (package
13166 (name "sbcl-clml")
13167 (version (git-version "0.0.0" revision commit))
13168 (source
13169 (origin
13170 (method git-fetch)
13171 (uri (git-reference
13172 (url "https://github.com/mmaul/clml")
13173 (commit commit)))
13174 (file-name (git-file-name "clml" version))
13175 (sha256
13176 (base32 "006pii59nmpc61n7p7h8ha5vjg6x0dya327i58z0rnvxs249h345"))
13177 ;; TODO: Remove this when the patch has been merged upstream.
13178 (patches (search-patches "sbcl-clml-fix-types.patch"))))
13179 (build-system asdf-build-system/sbcl)
13180 (inputs
13181 `(("alexandia" ,sbcl-alexandria)
13182 ("array-operations" ,sbcl-array-operations)
13183 ("cl-fad" ,sbcl-cl-fad)
13184 ("cl-ppcre" ,sbcl-cl-ppcre)
13185 ("drakma" ,sbcl-drakma)
13186 ("introspect-environment" ,sbcl-introspect-environment)
13187 ("iterate" ,sbcl-iterate)
13188 ("lparallel" ,sbcl-lparallel)
13189 ("parse-number" ,sbcl-parse-number)
13190 ("split-sequence" ,sbcl-split-sequence)
13191 ("trivial-garbage" ,sbcl-trivial-garbage)))
13192 (synopsis "Common Lisp machine learning library")
13193 (description
13194 "CLML (Common Lisp Machine Learning) is a high performance and large
13195 scale statistical machine learning package")
13196 (home-page "https://mmaul.github.io/clml/")
13197 (license license:llgpl))))
13198
13199 (define-public cl-clml
13200 (sbcl-package->cl-source-package sbcl-clml))
13201
13202 (define-public sbcl-utm-ups
13203 (let ((commit "ffcb7b6d5a56fb7d4b2b95b83bbd28ffe6e6961f")
13204 (revision "0"))
13205 (package
13206 (name "sbcl-utm-ups")
13207 (version (git-version "1.1" revision commit))
13208 (source
13209 (origin
13210 (method git-fetch)
13211 (uri (git-reference
13212 (url "https://github.com/glv2/utm-ups")
13213 (commit commit)))
13214 (file-name (git-file-name "utm-ups" version))
13215 (sha256
13216 (base32 "1rvyh0srgd81kvbzmq4ysd9y6c0qdwh23naqxc9asw1vh7fq08x1"))))
13217 (build-system asdf-build-system/sbcl)
13218 (native-inputs
13219 `(("fiveam" ,sbcl-fiveam)))
13220 (synopsis
13221 "Convert coordinates between latitude/longitude and UTM or UPS")
13222 (description
13223 "This a Common Lisp library to convert geographic coordinates between
13224 latitude/longitude and UTM (Universal Transverse Mercator) or UPS (Universal
13225 Polar Stereographic).")
13226 (home-page "https://github.com/glv2/utm-ups")
13227 (license license:gpl3+))))
13228
13229 (define-public cl-utm-ups
13230 (sbcl-package->cl-source-package sbcl-utm-ups))
13231
13232 (define-public ecl-utm-ups
13233 (sbcl-package->ecl-package sbcl-utm-ups))
13234
13235 (define-public sbcl-mgrs
13236 (let ((commit "00455460407b7e5509d1be3da09bf6152956761f")
13237 (revision "0"))
13238 (package
13239 (name "sbcl-mgrs")
13240 (version (git-version "1.0" revision commit))
13241 (source
13242 (origin
13243 (method git-fetch)
13244 (uri (git-reference
13245 (url "https://github.com/glv2/mgrs")
13246 (commit commit)))
13247 (file-name (git-file-name "mgrs" version))
13248 (sha256
13249 (base32 "0ckvn4hg3wwivzavhfashb6fap4a1q10l8krhbng8bdb54ac10sz"))))
13250 (build-system asdf-build-system/sbcl)
13251 (native-inputs
13252 `(("fiveam" ,sbcl-fiveam)))
13253 (inputs
13254 `(("utm-ups" ,sbcl-utm-ups)))
13255 (synopsis
13256 "Convert coordinates between latitude/longitude and MGRS")
13257 (description
13258 "This a Common Lisp library to convert geographic coordinates between
13259 latitude/longitude and MGRS.")
13260 (home-page "https://github.com/glv2/mgrs")
13261 (license license:gpl3+))))
13262
13263 (define-public cl-mgrs
13264 (sbcl-package->cl-source-package sbcl-mgrs))
13265
13266 (define-public ecl-mgrs
13267 (sbcl-package->ecl-package sbcl-mgrs))
13268
13269 (define-public sbcl-maidenhead
13270 (let ((commit "b756d235c27b5d6798867aa240318af1a8f35d6d")
13271 (revision "0"))
13272 (package
13273 (name "sbcl-maidenhead")
13274 (version (git-version "1.0" revision commit))
13275 (source
13276 (origin
13277 (method git-fetch)
13278 (uri (git-reference
13279 (url "https://github.com/glv2/maidenhead")
13280 (commit commit)))
13281 (file-name (git-file-name "maidenhead" version))
13282 (sha256
13283 (base32 "02p990zprhjvifmsfk8yh3frvz6xyw26ikzxvzglqdixbal36nr3"))))
13284 (build-system asdf-build-system/sbcl)
13285 (native-inputs
13286 `(("fiveam" ,sbcl-fiveam)))
13287 (synopsis
13288 "Convert coordinates between latitude/longitude and Maidenhead")
13289 (description
13290 "This a Common Lisp library to convert geographic coordinates between
13291 latitude/longitude and Maidenhead locator system.")
13292 (home-page "https://github.com/glv2/maidenhead")
13293 (license license:gpl3+))))
13294
13295 (define-public cl-maidenhead
13296 (sbcl-package->cl-source-package sbcl-maidenhead))
13297
13298 (define-public ecl-maidenhead
13299 (sbcl-package->ecl-package sbcl-maidenhead))
13300
13301 (define-public sbcl-olc
13302 (let ((commit "517e27fa57d9a119b00a29c4b6b31e553deff309")
13303 (revision "0"))
13304 (package
13305 (name "sbcl-olc")
13306 (version (git-version "1.0" revision commit))
13307 (source
13308 (origin
13309 (method git-fetch)
13310 (uri (git-reference
13311 (url "https://github.com/glv2/olc")
13312 (commit commit)))
13313 (file-name (git-file-name "olc" version))
13314 (sha256
13315 (base32 "1lnfhp6z6kc8l605zp4siyjiw74y1h4bdq3jfizi084v505wxhgr"))))
13316 (build-system asdf-build-system/sbcl)
13317 (native-inputs
13318 `(("fiveam" ,sbcl-fiveam)))
13319 (synopsis
13320 "Convert coordinates between latitude/longitude and Open Location Code")
13321 (description
13322 "This a Common Lisp library to convert geographic coordinates between
13323 latitude/longitude and Open Location Code.")
13324 (home-page "https://github.com/glv2/olc")
13325 (license license:gpl3+))))
13326
13327 (define-public cl-olc
13328 (sbcl-package->cl-source-package sbcl-olc))
13329
13330 (define-public ecl-olc
13331 (sbcl-package->ecl-package sbcl-olc))
13332
13333 (define-public sbcl-regex
13334 (let ((commit "fbc9a9f313b9edc1788f33d4b23a29151635ae22"))
13335 (package
13336 (name "sbcl-regex")
13337 (version (git-version "1" "1" commit))
13338 (source
13339 (origin
13340 (method git-fetch)
13341 (uri (git-reference
13342 (url "https://github.com/michaelw/regex/")
13343 (commit commit)))
13344 (file-name (git-file-name name version))
13345 (sha256
13346 (base32 "0wq5wlafrxv13wg28hg5b10sc48b88swsvznpy2zg7x37m4nmm6a"))))
13347 (build-system asdf-build-system/sbcl)
13348 (home-page "https://github.com/michaelw/regex/")
13349 (synopsis "Regular expression engine for Common Lisp")
13350 (description
13351 "This Common Lisp package provides a regular expression engine.")
13352 (license license:bsd-2))))
13353
13354 (define-public cl-regex
13355 (sbcl-package->cl-source-package sbcl-regex))
13356
13357 (define-public ecl-regex
13358 (sbcl-package->ecl-package sbcl-regex))
13359
13360 (define-public sbcl-clawk
13361 (let ((commit "3a91634df686417114044a98c063cbe76bfac7b6"))
13362 (package
13363 (name "sbcl-clawk")
13364 (version (git-version "4" "1" commit))
13365 (source
13366 (origin
13367 (method git-fetch)
13368 (uri (git-reference
13369 (url "https://github.com/sharplispers/clawk")
13370 (commit commit)))
13371 (file-name (git-file-name name version))
13372 (sha256
13373 (base32 "1ph3xjqilvinvgr9q3w47zxqyz1sqnq030nlx7kgkkv8j3bnqk7a"))))
13374 (build-system asdf-build-system/sbcl)
13375 (inputs
13376 `(("sbcl-regex" ,sbcl-regex)))
13377 (home-page "https://github.com/sharplispers/clawk")
13378 (synopsis "Common Lisp AWK")
13379 (description
13380 "CLAWK is an AWK implementation embedded into Common Lisp.")
13381 (license license:bsd-2))))
13382
13383 (define-public cl-clawk
13384 (sbcl-package->cl-source-package sbcl-clawk))
13385
13386 (define-public ecl-clawk
13387 (sbcl-package->ecl-package sbcl-clawk))
13388
13389 (define-public sbcl-check-it
13390 (let ((commit "b79c9103665be3976915b56b570038f03486e62f"))
13391 (package
13392 (name "sbcl-check-it")
13393 (version (git-version "0.1.0" "1" commit))
13394 (source
13395 (origin
13396 (method git-fetch)
13397 (uri (git-reference
13398 (url "https://github.com/DalekBaldwin/check-it/")
13399 (commit commit)))
13400 (file-name (git-file-name name version))
13401 (sha256
13402 (base32 "1kbjwpniffdpv003igmlz5r0vy65m7wpfnhg54fhwirp1227hgg7"))))
13403 (build-system asdf-build-system/sbcl)
13404 (inputs
13405 `(("alexandria" ,sbcl-alexandria)
13406 ("closer-mop" ,sbcl-closer-mop)
13407 ("optima" ,sbcl-optima)))
13408 (native-inputs
13409 `(("stefil" ,sbcl-stefil)))
13410 (home-page "https://github.com/arclanguage/Clamp")
13411 (synopsis "Randomized specification-based testing for Common Lisp")
13412 (description
13413 "This is a randomized property-based testing library for Common Lisp.
13414 Rather than being a full-fledged general test framework in its own right, it's
13415 designed to embed randomized tests in whatever framework you like.")
13416 (license license:llgpl))))
13417
13418 (define-public cl-check-it
13419 (sbcl-package->cl-source-package sbcl-check-it))
13420
13421 (define-public ecl-check-it
13422 (sbcl-package->ecl-package sbcl-check-it))
13423
13424 (define-public sbcl-clamp
13425 (let ((commit "02b8f3953e5753cc61a719807c82f3795cd28fe1"))
13426 (package
13427 (name "sbcl-clamp")
13428 (version (git-version "0.3" "1" commit))
13429 (source
13430 (origin
13431 (method git-fetch)
13432 (uri (git-reference
13433 (url "https://github.com/arclanguage/Clamp")
13434 (commit commit)))
13435 (file-name (git-file-name name version))
13436 (sha256
13437 (base32 "0fdr9nqfmmpxm6hvjdxi1jkclya9xlnrw1yc3cn1m4ww3f50p31m"))))
13438 (build-system asdf-build-system/sbcl)
13439 (inputs
13440 `(("iterate" ,sbcl-iterate)
13441 ("cl-syntax" ,sbcl-cl-syntax)))
13442 (native-inputs
13443 `(("cl-unit" ,sbcl-clunit)
13444 ("check-it" ,sbcl-check-it)))
13445 (arguments
13446 `(#:phases
13447 (modify-phases %standard-phases
13448 (add-after 'unpack 'fix-build
13449 (lambda _
13450 (substitute* "clamp.asd"
13451 (("\\(:file \"read\" :depends-on \\(\"aliases\"\\)\\)")
13452 "(:file \"read\" :depends-on (\"aliases\" \"base\"))"))
13453 #t)))))
13454 (home-page "https://github.com/arclanguage/Clamp")
13455 (synopsis "Common Lisp with Arc macros and procedures")
13456 (description
13457 "Clamp is an attempt to bring the powerful, but verbose, language of
13458 Common Lisp up to the terseness of Arc.
13459
13460 There are two parts to Clamp. There is the core of Clamp, which implements
13461 the utilities of Arc that are easily converted from Arc to Common Lisp. The
13462 other part is the \"experimental\" part. It contains features of Arc that are
13463 not so easy to copy (ssyntax, argument destructuring, etc.).")
13464 (license license:artistic2.0))))
13465
13466 (define-public cl-clamp
13467 (sbcl-package->cl-source-package sbcl-clamp))
13468
13469 (define-public ecl-clamp
13470 (sbcl-package->ecl-package sbcl-clamp))
13471
13472 (define-public sbcl-trivial-shell
13473 (let ((commit "e02ec191b34b52deca5d1c4ee99d4fa13b8772e0"))
13474 (package
13475 (name "sbcl-trivial-shell")
13476 (version (git-version "0.2.0" "1" commit))
13477 (source
13478 (origin
13479 (method git-fetch)
13480 (uri (git-reference
13481 (url "https://github.com/gwkkwg/trivial-shell")
13482 (commit commit)))
13483 (file-name (git-file-name name version))
13484 (sha256
13485 (base32 "08mpkl5ij5sjfsyn8pq2kvsvpvyvr7ha1r8g1224fa667b8k2q85"))))
13486 (build-system asdf-build-system/sbcl)
13487 (native-inputs
13488 `(("lift" ,sbcl-lift)))
13489 (home-page "http://common-lisp.net/project/trivial-shell/")
13490 (synopsis "Common Lisp access to the shell")
13491 (description
13492 "A simple Common-Lisp interface to the underlying operating system.
13493 It's independent of the implementation and operating system.")
13494 (license license:expat))))
13495
13496 (define-public cl-trivial-shell
13497 (sbcl-package->cl-source-package sbcl-trivial-shell))
13498
13499 (define-public ecl-trivial-shell
13500 (sbcl-package->ecl-package sbcl-trivial-shell))
13501
13502 (define-public sbcl-clesh
13503 (let ((commit "44e96e04a72e5bc006dc4eb02ce8962348dd4a11"))
13504 (package
13505 (name "sbcl-clesh")
13506 (version (git-version "0.0.0" "1" commit))
13507 (source
13508 (origin
13509 (method git-fetch)
13510 (uri (git-reference
13511 (url "https://github.com/Neronus/Clesh")
13512 (commit commit)))
13513 (file-name (git-file-name name version))
13514 (sha256
13515 (base32 "012ry02djnqyvvs61wbbqj3saz621w2l9gczrywdxhi5p4ycx318"))))
13516 (build-system asdf-build-system/sbcl)
13517 (inputs
13518 `(("trivial-shell" ,sbcl-trivial-shell)
13519 ("named-readtables" ,sbcl-named-readtables)))
13520 (home-page "https://github.com/Neronus/Clesh")
13521 (synopsis "Embed shell code in Common Lisp")
13522 (description
13523 "This is a very short and simple program, written in Common Lisp, that
13524 extends Common Lisp to embed shell code in a manner similar to Perl's
13525 backtick. It has been forked from SHELISP.")
13526 (license license:bsd-2))))
13527
13528 (define-public cl-clesh
13529 (sbcl-package->cl-source-package sbcl-clesh))
13530
13531 (define-public ecl-clesh
13532 (sbcl-package->ecl-package sbcl-clesh))
13533
13534 (define-public sbcl-trivial-channels
13535 (let ((commit "e2370118d8983ba69c0360a7695f8f2e2fd6a8a6")
13536 (revision "1"))
13537 (package
13538 (name "sbcl-trivial-channels")
13539 (version (git-version "1.0" revision commit))
13540 (source
13541 (origin
13542 (method git-fetch)
13543 (uri (git-reference
13544 (url "https://github.com/rpav/trivial-channels")
13545 (commit commit)))
13546 (file-name (git-file-name "trivial-channels" version))
13547 (sha256
13548 (base32 "04wnxcgk40x8p0gxnz9arv1a5wasdqrdxa8c4p5v7r2mycfps6jj"))))
13549 (build-system asdf-build-system/sbcl)
13550 (inputs
13551 `(("bordeaux-threads" ,sbcl-bordeaux-threads)
13552 ("trivial-timeout" ,sbcl-trivial-timeout)))
13553 (home-page "https://github.com/rpav/trivial-channels")
13554 (synopsis "Common Lisp simple thread-safe channels with timeout")
13555 (description
13556 "It's very basic implementation of channels and queue for Common Lisp.")
13557 (license license:bsd-2))))
13558
13559 (define-public ecl-trivial-channels
13560 (sbcl-package->ecl-package sbcl-trivial-channels))
13561
13562 (define-public cl-trivial-channels
13563 (sbcl-package->cl-source-package sbcl-trivial-channels))
13564
13565 (define-public sbcl-trivial-download
13566 (let ((commit "d2472061d86b1cf3d32f388daacd4e32a13af699"))
13567 (package
13568 (name "sbcl-trivial-download")
13569 (version (git-version "0.3" "1" commit))
13570 (source
13571 (origin
13572 (method git-fetch)
13573 (uri (git-reference
13574 (url "https://github.com/eudoxia0/trivial-download/")
13575 (commit commit)))
13576 (file-name (git-file-name name version))
13577 (sha256
13578 (base32 "06f46zr3gp3wlm2kgxna24qd2gpr1v89x9fynh1x5vrw6c6hqjcv"))))
13579 (build-system asdf-build-system/sbcl)
13580 (inputs
13581 `(("drakma" ,sbcl-drakma)))
13582 (home-page "https://github.com/eudoxia0/trivial-download/")
13583 (synopsis "Download files from Common Lisp")
13584 (description
13585 "@code{trivial-download} allows you to download files from the Internet
13586 from Common Lisp. It provides a progress bar.")
13587 (license license:bsd-2))))
13588
13589 (define-public cl-trivial-download
13590 (sbcl-package->cl-source-package sbcl-trivial-download))
13591
13592 (define-public ecl-trivial-download
13593 (sbcl-package->ecl-package sbcl-trivial-download))
13594
13595 (define-public sbcl-gtwiwtg
13596 (package
13597 (name "sbcl-gtwiwtg")
13598 (version "0.1.1")
13599 (source
13600 (origin
13601 (method git-fetch)
13602 (uri (git-reference
13603 (url "https://github.com/cbeo/gtwiwtg/")
13604 (commit version)))
13605 (file-name (git-file-name name version))
13606 (sha256
13607 (base32 "0lkraw0dwh4is4x5sp5rjrw6f93m0gr9849abrbi12s25ws7jbw4"))))
13608 (build-system asdf-build-system/sbcl)
13609 (native-inputs
13610 `(("osicat" ,sbcl-osicat)
13611 ("prove" ,sbcl-prove)))
13612 (home-page "https://github.com/cbeo/gtwiwtg/")
13613 (synopsis "Naive generators for Common Lisp")
13614 (description
13615 "The GTWIWTG library (Generators The Way I Want Them Generated --
13616 technically not generators, but iterators) is meant to be small, explorable,
13617 and understandable.")
13618 (license license:gpl3)))
13619
13620 (define-public cl-gtwiwtg
13621 (sbcl-package->cl-source-package sbcl-gtwiwtg))
13622
13623 (define-public ecl-gtwiwtg
13624 (sbcl-package->ecl-package sbcl-gtwiwtg))
13625
13626 (define-public sbcl-cl-progress-bar
13627 (let ((commit "9374170858663c8fe829e9fb5a29bd2cb48d95ae"))
13628 (package
13629 (name "sbcl-cl-progress-bar")
13630 (version (git-version "0.0.0" "1" commit))
13631 (source
13632 (origin
13633 (method git-fetch)
13634 (uri (git-reference
13635 (url "https://github.com/sirherrbatka/cl-progress-bar/")
13636 (commit commit)))
13637 (file-name (git-file-name name version))
13638 (sha256
13639 (base32 "1ldb4qhmx431n3lsq71ynwb9ybazbfqd55icjbhi06mj52ngndir"))))
13640 (build-system asdf-build-system/sbcl)
13641 (inputs
13642 `(("bordeaux-threads" ,sbcl-bordeaux-threads)
13643 ("documentation-utils-extensions" ,sbcl-documentation-utils-extensions)))
13644 (home-page "https://github.com/sirherrbatka/cl-progress-bar/")
13645 (synopsis "Progress bars in Common Lisp")
13646 (description
13647 "This library provides almost the same code as used inside Quicklisp
13648 for drawning progress bars")
13649 (license license:expat))))
13650
13651 (define-public cl-progress-bar
13652 (sbcl-package->cl-source-package sbcl-cl-progress-bar))
13653
13654 (define-public ecl-cl-progress-bar
13655 (sbcl-package->ecl-package sbcl-cl-progress-bar))
13656
13657 (define-public sbcl-repl-utilities
13658 (let ((commit "7e300df663177ea4581f4e7e9c601377881dd986"))
13659 (package
13660 (name "sbcl-repl-utilities")
13661 (version (git-version "0.0.0" "1" commit))
13662 (source
13663 (origin
13664 (method git-fetch)
13665 (uri (git-reference
13666 (url "https://github.com/m-n/repl-utilities/")
13667 (commit commit)))
13668 (file-name (git-file-name name version))
13669 (sha256
13670 (base32 "1hh56pq5nw3l4b83dzlyss69f06r038byj2cnjwvci4hfjhdfcc3"))))
13671 (build-system asdf-build-system/sbcl)
13672 (home-page "https://github.com/m-n/repl-utilities")
13673 (synopsis "Ease common tasks at the Common Lisp REPL")
13674 (description
13675 "@code{repl-utilities} is a set of utilities which ease life at the
13676 REPL. It includes three sorts of features: introspective procedures,
13677 miscellaneous utility functions, and, pulling them together, methods to
13678 conveniently keep these symbols and optionally additional symbols available in
13679 whichever package you switch to.")
13680 (license license:bsd-2))))
13681
13682 (define-public cl-repl-utilities
13683 (sbcl-package->cl-source-package sbcl-repl-utilities))
13684
13685 (define-public ecl-repl-utilities
13686 (sbcl-package->ecl-package sbcl-repl-utilities))
13687
13688 (define-public sbcl-supertrace
13689 (let ((commit "66d22c3ff131ecd1c8048dfced1d62ed6024ecb0"))
13690 (package
13691 (name "sbcl-supertrace")
13692 (version (git-version "0.1.0" "1" commit))
13693 (source
13694 (origin
13695 (method git-fetch)
13696 (uri (git-reference
13697 (url "https://github.com/fukamachi/supertrace")
13698 (commit commit)))
13699 (file-name (git-file-name name version))
13700 (sha256
13701 (base32 "0n369n6b7y1m49biccnnr7svymjdsk8sksrkqrn3mj21vgv7s7bg"))))
13702 (build-system asdf-build-system/sbcl)
13703 (native-inputs
13704 `(("cffi-grovel" ,sbcl-cffi)
13705 ("rove" ,sbcl-rove)
13706 ("cl-ppcre" ,sbcl-cl-ppcre)
13707 ("bordeaux-threads" ,sbcl-bordeaux-threads)))
13708 (inputs
13709 `(("cffi" ,sbcl-cffi)))
13710 (home-page "https://github.com/fukamachi/supertrace")
13711 (synopsis "Improved Common Lisp tracing for debugging and profiling")
13712 (description
13713 "Supertrace provides a superior Common Lisp @code{trace} functionality
13714 for debugging and profiling real world applications.")
13715 (license license:bsd-2))))
13716
13717 (define-public cl-supertrace
13718 (sbcl-package->cl-source-package sbcl-supertrace))
13719
13720 (define-public ecl-supertrace
13721 (sbcl-package->ecl-package sbcl-supertrace))
13722
13723 (define-public sbcl-trivial-benchmark
13724 (let ((commit "42d76733dd2e873471c6f1e27d39113293f7dd5c"))
13725 (package
13726 (name "sbcl-trivial-benchmark")
13727 (version (git-version "2.0.0" "1" commit))
13728 (source
13729 (origin
13730 (method git-fetch)
13731 (uri (git-reference
13732 (url "https://github.com/Shinmera/trivial-benchmark/")
13733 (commit commit)))
13734 (file-name (git-file-name name version))
13735 (sha256
13736 (base32 "0fbzqbpm2ixz85555krl36kbbbjyn699vdj6k383khi3g9y629fa"))))
13737 (build-system asdf-build-system/sbcl)
13738 (inputs
13739 `(("alexandria" ,sbcl-alexandria)))
13740 (home-page "http://shinmera.github.io/trivial-benchmark/")
13741 (synopsis "Easy to use benchmarking system for Common Lisp")
13742 (description
13743 "Trivial-Benchmark runs a block of code many times and outputs some
13744 statistical data for it. On SBCL this includes the data from @code{time}, for
13745 all other implementations just the @code{real-time} and @code{run-time} data.
13746 However, you can extend the system by adding your own @code{metrics} to it, or
13747 even by adding additional statistical @code{compute}ations. ")
13748 (license license:zlib))))
13749
13750 (define-public cl-trivial-benchmark
13751 (sbcl-package->cl-source-package sbcl-trivial-benchmark))
13752
13753 (define-public ecl-trivial-benchmark
13754 (sbcl-package->ecl-package sbcl-trivial-benchmark))
13755
13756 (define-public sbcl-glyphs
13757 (let ((commit "1ff5714e8c1dca327bc604dfe3e3d1f4b7755373"))
13758 (package
13759 (name "sbcl-glyphs")
13760 (version (git-version "0.0.0" "1" commit))
13761 (source
13762 (origin
13763 (method git-fetch)
13764 (uri (git-reference
13765 (url "https://github.com/ahungry/glyphs/")
13766 (commit commit)))
13767 (file-name (git-file-name name version))
13768 (sha256
13769 (base32 "17kai1anbkk5dj5sbrsin2fc019cmcbglb900db60v38myj0y0wf"))))
13770 (build-system asdf-build-system/sbcl)
13771 (inputs
13772 `(("cl-ppcre" ,sbcl-cl-ppcre)
13773 ("parenscript" ,sbcl-parenscript)
13774 ("named-readtables" ,sbcl-named-readtables)))
13775 (home-page "https://github.com/ahungry/glyphs/")
13776 (synopsis "Reduce Common Lisp verbosity")
13777 (description
13778 "This library is a little experiment in reducing verbosity in Common
13779 Lisp, inspired by BODOL (@url{https://github.com/bodil/BODOL}).")
13780 (license license:gpl3))))
13781
13782 (define-public cl-glyphs
13783 (sbcl-package->cl-source-package sbcl-glyphs))
13784
13785 (define-public ecl-glyphs
13786 (sbcl-package->ecl-package sbcl-glyphs))
13787
13788 (define-public sbcl-zs3
13789 (package
13790 (name "sbcl-zs3")
13791 (version "1.3.3")
13792 (source
13793 (origin
13794 (method git-fetch)
13795 (uri
13796 (git-reference
13797 (url "https://github.com/xach/zs3")
13798 (commit (string-append "release-" version))))
13799 (file-name (git-file-name "zs3" version))
13800 (sha256
13801 (base32 "186v95wgsj2hkxdw2jl9x1w4fddjclp7arp0rrd9vf5ly8h8sbf3"))))
13802 (build-system asdf-build-system/sbcl)
13803 (inputs
13804 `(("drakma" ,sbcl-drakma)
13805 ("alexandria" ,sbcl-alexandria)
13806 ("cxml" ,sbcl-cxml)
13807 ("ironclad" ,sbcl-ironclad)
13808 ("puri" ,sbcl-puri)
13809 ("cl-base64" ,sbcl-cl-base64)))
13810 (synopsis "Work with Amazon S3 and Amazon CloudFront from Common Lisp")
13811 (description "This is ZS3, a library for working with Amazon's Simple Storage
13812 Service (S3) and CloudFront service from Common Lisp.")
13813 (home-page "https://github.com/xach/zs3")
13814 (license license:bsd-2)))
13815
13816 (define-public cl-zs3
13817 (sbcl-package->cl-source-package sbcl-zs3))
13818
13819 (define-public ecl-zs3
13820 (sbcl-package->ecl-package sbcl-zs3))
13821
13822 (define-public sbcl-simple-neural-network
13823 (package
13824 (name "sbcl-simple-neural-network")
13825 (version "3.1")
13826 (source
13827 (origin
13828 (method git-fetch)
13829 (uri (git-reference
13830 (url "https://github.com/glv2/simple-neural-network")
13831 (commit (string-append "v" version))))
13832 (file-name (git-file-name "simple-neural-network" version))
13833 (sha256
13834 (base32 "1jj1c90fr5clwka0jv32hv6xp1bkdlpa6x5jh19an13rhx8ll4zr"))))
13835 (build-system asdf-build-system/sbcl)
13836 (native-inputs
13837 `(("chipz" ,sbcl-chipz)
13838 ("fiveam" ,sbcl-fiveam)))
13839 (inputs
13840 `(("cl-store" ,sbcl-cl-store)
13841 ("lparallel" ,sbcl-lparallel)))
13842 (arguments
13843 `(#:phases
13844 (modify-phases %standard-phases
13845 (add-after 'check 'remove-test-data
13846 (lambda* (#:key outputs #:allow-other-keys)
13847 (let ((out (assoc-ref outputs "out")))
13848 (for-each delete-file (find-files out "\\.gz$"))))))))
13849 (synopsis "Simple neural network in Common Lisp")
13850 (description
13851 "@code{simple-neural-network} is a Common Lisp library for creating,
13852 training and using basic neural networks. The networks created by this
13853 library are feedforward neural networks trained using backpropagation.")
13854 (home-page "https://github.com/glv2/simple-neural-network")
13855 (license license:gpl3+)))
13856
13857 (define-public cl-simple-neural-network
13858 (sbcl-package->cl-source-package sbcl-simple-neural-network))
13859
13860 (define-public ecl-simple-neural-network
13861 (sbcl-package->ecl-package sbcl-simple-neural-network))
13862
13863 (define-public sbcl-zstd
13864 (let ((commit "d144582c581aaa52bac24d6686af27fa3e781e06")
13865 (revision "1"))
13866 (package
13867 (name "sbcl-zstd")
13868 (version (git-version "1.0" revision commit))
13869 (source
13870 (origin
13871 (method git-fetch)
13872 (uri (git-reference
13873 (url "https://github.com/glv2/cl-zstd")
13874 (commit commit)))
13875 (file-name (git-file-name "cl-zstd" version))
13876 (sha256
13877 (base32 "1774jy8hzbi6nih3sq6vchk66f7g8w86dwgpbvljyfzcnkcaz6ql"))))
13878 (build-system asdf-build-system/sbcl)
13879 (native-inputs
13880 `(("fiveam" ,sbcl-fiveam)))
13881 (inputs
13882 `(("cffi" ,sbcl-cffi)
13883 ("cl-octet-streams" ,sbcl-cl-octet-streams)
13884 ("zstd-lib" ,zstd "lib")))
13885 (arguments
13886 '(#:phases
13887 (modify-phases %standard-phases
13888 (add-after 'unpack 'fix-paths
13889 (lambda* (#:key inputs #:allow-other-keys)
13890 (substitute* "src/libzstd.lisp"
13891 (("libzstd\\.so")
13892 (string-append (assoc-ref inputs "zstd-lib")
13893 "/lib/libzstd.so")))
13894 #t)))))
13895 (synopsis "Common Lisp library for Zstandard (de)compression")
13896 (description
13897 "This Common Lisp library provides functions for Zstandard
13898 compression/decompression using bindings to the libzstd C library.")
13899 (home-page "https://github.com/glv2/cl-zstd")
13900 (license license:gpl3+))))
13901
13902 (define-public cl-zstd
13903 (sbcl-package->cl-source-package sbcl-zstd))
13904
13905 (define-public ecl-zstd
13906 (sbcl-package->ecl-package sbcl-zstd))
13907
13908 (define-public sbcl-agnostic-lizard
13909 (let ((commit "fe3a73719f05901c8819f8995a3ebae738257952")
13910 (revision "1"))
13911 (package
13912 (name "sbcl-agnostic-lizard")
13913 (version (git-version "0.0.0" revision commit))
13914 (source
13915 (origin
13916 (method git-fetch)
13917 (uri (git-reference
13918 (url "https://gitlab.common-lisp.net/mraskin/agnostic-lizard")
13919 (commit commit)))
13920 (file-name (git-file-name name version))
13921 (sha256
13922 (base32 "0ax78y8w4zlp5dcwyhz2nq7j3shi49qn31dkfg8lv2jlg7mkwh2d"))))
13923 (build-system asdf-build-system/sbcl)
13924 (synopsis "Almost correct portable code walker for Common Lisp")
13925 (description
13926 "Agnostic Lizard is a portable implementation of a code walker and in
13927 particular of the macroexpand-all function (and macro) that makes a best
13928 effort to be correct while not expecting much beyond what the Common Lisp
13929 standard requires.
13930
13931 It aims to be implementation-agnostic and to climb the syntax trees.")
13932 (home-page "https://gitlab.common-lisp.net/mraskin/agnostic-lizard")
13933 (license license:gpl3+))))
13934
13935 (define-public cl-agnostic-lizard
13936 (sbcl-package->cl-source-package sbcl-agnostic-lizard))
13937
13938 (define-public ecl-agnostic-lizard
13939 (sbcl-package->ecl-package sbcl-agnostic-lizard))
13940
13941 (define-public sbcl-dynamic-classes
13942 (package
13943 (name "sbcl-dynamic-classes")
13944 (version "1.0.2")
13945 (source
13946 (origin
13947 (method git-fetch)
13948 (uri (git-reference
13949 (url "https://github.com/gwkkwg/dynamic-classes")
13950 (commit (string-append "version-" version))))
13951 (file-name (git-file-name "dynamic-classes" version))
13952 (sha256
13953 (base32 "1z3ag6w4ff0v6715xa9zhvwjqnp4i6zrjfmxdz8m115sklbwgm6c"))))
13954 (build-system asdf-build-system/sbcl)
13955 (inputs
13956 `(("metatilities-base" ,sbcl-metatilities-base)))
13957 (arguments
13958 ;; NOTE: (Sharlatan-20210106222900+0000) Circular dependencies and failing
13959 ;; test suites. lift-standard.config contains referances to deprecated
13960 ;; functionality.
13961 `(#:tests? #f))
13962 (home-page "https://common-lisp.net/project/dynamic-classes/")
13963 (synopsis "Dynamic class definition for Common Lisp")
13964 (description "Dynamic-Classes helps to ease the prototyping process by
13965 bringing dynamism to class definition.")
13966 (license license:expat)))
13967
13968 (define-public ecl-dynamic-classes
13969 (sbcl-package->ecl-package sbcl-dynamic-classes))
13970
13971 (define-public cl-dynamic-classes
13972 (sbcl-package->cl-source-package sbcl-dynamic-classes))
13973
13974 (define-public sbcl-cl-markdown
13975 ;; NOTE: (Sharlatan-20210106214629+0000) latest version tag
13976 ;; "version-0.10.6_version-0.10.6" is failing to build due to missing system
13977 ;; #:container-dynamic-classes
13978 (package
13979 (name "sbcl-cl-markdown")
13980 (version "0.10.4")
13981 (source
13982 (origin
13983 (method git-fetch)
13984 (uri (git-reference
13985 (url "https://github.com/gwkkwg/cl-markdown")
13986 (commit (string-append "version-" version))))
13987 (file-name (git-file-name "cl-markdown" version))
13988 (sha256
13989 (base32 "1wdjbdd1zyskxf7zlilcp6fmwkivybj0wjp64vvzb265d5xi7p8p"))))
13990 (build-system asdf-build-system/sbcl)
13991 (inputs
13992 `(("anaphora" ,sbcl-anaphora)
13993 ("cl-containers" ,sbcl-cl-containers)
13994 ("cl-ppcre" ,sbcl-cl-ppcre)
13995 ("dynamic-classes" ,sbcl-dynamic-classes)
13996 ("metabang-bind" ,sbcl-metabang-bind)
13997 ("metatilities-base" ,sbcl-metatilities-base)))
13998 (arguments
13999 ;; NOTE: (Sharlatan-20210107213629+0000) Tests depend on too many not
14000 ;; available systems, which themself are abandoned.
14001 `(#:tests? #f))
14002 (home-page "https://common-lisp.net/project/cl-markdown/")
14003 (synopsis "Common Lisp rewrite of Markdown")
14004 (description
14005 "This is an implementation of a Markdown parser in Common Lisp.")
14006 (license license:expat)))
14007
14008 (define-public ecl-cl-markdown
14009 (sbcl-package->ecl-package sbcl-cl-markdown))
14010
14011 (define-public cl-markdown
14012 (sbcl-package->cl-source-package sbcl-cl-markdown))
14013
14014 (define-public sbcl-magicffi
14015 (let ((commit "d88f2f280c31f639e4e05be75215d8a8dce6aef2"))
14016 (package
14017 (name "sbcl-magicffi")
14018 (version (git-version "0.0.0" "1" commit))
14019 (source
14020 (origin
14021 (method git-fetch)
14022 (uri (git-reference
14023 (url "https://github.com/dochang/magicffi/")
14024 (commit commit)))
14025 (file-name (git-file-name name version))
14026 (sha256
14027 (base32 "0p6ysa92fk34bhxpw7bycbfgw150fv11z9x8jr9xb4lh8cm2hvp6"))))
14028 (build-system asdf-build-system/sbcl)
14029 (native-inputs
14030 `(("alexandria" ,sbcl-alexandria)))
14031 (inputs
14032 `(("cffi" ,sbcl-cffi)
14033 ("ppcre" ,sbcl-cl-ppcre)
14034 ("libmagic" ,file)))
14035 (arguments
14036 `(#:phases
14037 (modify-phases %standard-phases
14038 (add-after 'unpack 'fix-paths
14039 (lambda* (#:key inputs #:allow-other-keys)
14040 (let ((magic (assoc-ref inputs "libmagic")))
14041 (substitute* "grovel.lisp"
14042 (("/usr/include/magic.h")
14043 (string-append magic "/include/magic.h")))
14044 (substitute* "api.lisp"
14045 ((":default \"libmagic\"" all)
14046 (string-append ":default \"" magic "/lib/libmagic\"")))))))))
14047 (home-page "https://common-lisp.net/project/magicffi/")
14048 (synopsis "Common Lisp interface to libmagic based on CFFI")
14049 (description
14050 "MAGICFFI is a Common Lisp CFFI interface to libmagic(3), the file type
14051 determination library using @emph{magic} numbers.")
14052 (license license:bsd-2))))
14053
14054 (define-public ecl-magicffi
14055 (sbcl-package->ecl-package sbcl-magicffi))
14056
14057 (define-public cl-magicffi
14058 (sbcl-package->cl-source-package sbcl-magicffi))
14059
14060 (define-public sbcl-shlex
14061 (let ((commit "c5616dffca0d4d8ddbc1cd6f37a96d88477b2740"))
14062 (package
14063 (name "sbcl-shlex")
14064 (version (git-version "0.0.0" "1" commit))
14065 (source
14066 (origin
14067 (method git-fetch)
14068 (uri (git-reference
14069 (url "https://github.com/ruricolist/cl-shlex")
14070 (commit commit)))
14071 (file-name (git-file-name name version))
14072 (sha256
14073 (base32 "1nas024n4wv319bf40aal96g72bgi9nkapj2chywj2cc6r8hzkfg"))))
14074 (build-system asdf-build-system/sbcl)
14075 (inputs
14076 `(("alexandria" ,sbcl-alexandria)
14077 ("serapeum" ,sbcl-serapeum)
14078 ("ppcre" ,sbcl-cl-ppcre)
14079 ("unicode" ,sbcl-cl-unicode)))
14080 (home-page "https://github.com/ruricolist/cl-shlex")
14081 (synopsis "Common Lisp lexical analyzer for shell-like syntaxes")
14082 (description
14083 "This library contains a lexer for syntaxes that use shell-like rules
14084 for quoting and commenting. It is a port of the @code{shlex} module from Python’s
14085 standard library.")
14086 (license license:expat))))
14087
14088 (define-public ecl-shlex
14089 (sbcl-package->ecl-package sbcl-shlex))
14090
14091 (define-public cl-shlex
14092 (sbcl-package->cl-source-package sbcl-shlex))
14093
14094 (define-public sbcl-cmd
14095 (let ((commit "bc5a3bee8f22917126e4c3d05b33f766e562dbd8"))
14096 (package
14097 (name "sbcl-cmd")
14098 (version (git-version "0.0.1" "3" commit))
14099 (source
14100 (origin
14101 (method git-fetch)
14102 (uri (git-reference
14103 (url "https://github.com/ruricolist/cmd/")
14104 (commit commit)))
14105 (file-name (git-file-name name version))
14106 (sha256
14107 (base32 "1sjlabrknw1kjb2y89vssjhcqh3slgly8wnr3152zgis8lsj2yc7"))))
14108 (build-system asdf-build-system/sbcl)
14109 (inputs
14110 `(("alexandria" ,sbcl-alexandria)
14111 ("coreutils" ,coreutils)
14112 ("procps" ,procps)
14113 ("serapeum" ,sbcl-serapeum)
14114 ("shlex" ,sbcl-shlex)
14115 ("trivia" ,sbcl-trivia)))
14116 (arguments
14117 `(#:phases
14118 (modify-phases %standard-phases
14119 (add-after 'unpack 'fix-paths
14120 (lambda* (#:key inputs #:allow-other-keys)
14121 (let ((bin (string-append (assoc-ref inputs "coreutils") "/bin"))
14122 (ps-bin (string-append (assoc-ref inputs "procps") "/bin")))
14123 (substitute* "cmd.lisp"
14124 (("\\(def \\+env\\+ \"env\"\\)")
14125 (format #f "(def +env+ \"~a/env\")" bin))
14126 (("\\(def \\+kill\\+ \"kill\"\\)")
14127 (format #f "(def +kill+ \"~a/kill\")" bin))
14128 (("\\(def \\+ps\\+ \"ps\"\\)")
14129 (format #f "(def +ps+ \"~a/ps\")" ps-bin))
14130 (("\\(def \\+pwd\\+ \"pwd\"\\)")
14131 (format #f "(def +pwd+ \"~a/pwd\")" bin))
14132 (("\\(def \\+sh\\+ \"/bin/sh\"\\)")
14133 (format #f "(def +sh+ \"~a\")" (which "sh")))
14134 (("\\(def \\+tr\\+ \"tr\"\\)")
14135 (format #f "(def +tr+ \"~a/tr\")" bin)))))))))
14136 (home-page "https://github.com/ruricolist/cmd")
14137 (synopsis "Conveniently run external programs from Common Lisp")
14138 (description
14139 "A utility for running external programs, built on UIOP.
14140 Cmd is designed to be natural to use, protect against shell interpolation and
14141 be usable from multi-threaded programs.")
14142 (license license:expat))))
14143
14144 (define-public ecl-cmd
14145 (sbcl-package->ecl-package sbcl-cmd))
14146
14147 (define-public cl-cmd
14148 (sbcl-package->cl-source-package sbcl-cmd))
14149
14150 (define-public sbcl-ppath
14151 (let ((commit "eb1a8173b4d1d691ea9a7699412123462f58c3ce"))
14152 (package
14153 (name "sbcl-ppath")
14154 (version (git-version "0.1" "1" commit))
14155 (source
14156 (origin
14157 (method git-fetch)
14158 (uri (git-reference
14159 (url "https://github.com/fourier/ppath/")
14160 (commit commit)))
14161 (file-name (git-file-name name commit))
14162 (sha256
14163 (base32 "1c46q9lmzqv14z80d3fwdawgn3pn4922x31fyqvsvbcjm4hd16fb"))))
14164 (build-system asdf-build-system/sbcl)
14165 (inputs
14166 `(("alexandria" ,sbcl-alexandria)
14167 ("cffi" ,sbcl-cffi)
14168 ("osicat" ,sbcl-osicat)
14169 ("ppcre" ,sbcl-cl-ppcre)
14170 ("split-sequence" ,sbcl-split-sequence)
14171 ("trivial-features" ,sbcl-trivial-features)))
14172 (native-inputs
14173 `(("cl-fad" ,sbcl-cl-fad)
14174 ("prove" ,sbcl-prove)))
14175 (home-page "https://github.com/fourier/ppath")
14176 (synopsis "Common Lisp's implementation of the Python's os.path module")
14177 (description
14178 "This library is a path strings manipulation library inspired by
14179 Python's @code{os.path}. All functionality from @code{os.path} is supported on
14180 major operation systems.
14181
14182 The philosophy behind is to use simple strings and \"dumb\" string
14183 manipulation functions to handle paths and filenames. Where possible the
14184 corresponding OS system functions are called.")
14185 (license license:bsd-2))))
14186
14187 (define-public ecl-ppath
14188 (sbcl-package->ecl-package sbcl-ppath))
14189
14190 (define-public cl-ppath
14191 (sbcl-package->cl-source-package sbcl-ppath))
14192
14193 (define-public sbcl-trivial-escapes
14194 (let ((commit "1eca78da2078495d09893be58c28b3aa7b8cc4d1"))
14195 (package
14196 (name "sbcl-trivial-escapes")
14197 (version (git-version "1.2.0" "1" commit))
14198 (source
14199 (origin
14200 (method git-fetch)
14201 (uri (git-reference
14202 (url "https://github.com/williamyaoh/trivial-escapes")
14203 (commit commit)))
14204 (file-name (git-file-name name commit))
14205 (sha256
14206 (base32 "0v6h8lk17iqv1qkxgqjyzn8gi6v0hvq2vmfbb01md3zjvjqxn6lr"))))
14207 (build-system asdf-build-system/sbcl)
14208 (inputs
14209 `(("named-readtables" ,sbcl-named-readtables)))
14210 (native-inputs
14211 `(("fiveam" ,sbcl-fiveam)))
14212 (home-page "https://github.com/williamyaoh/trivial-escapes")
14213 (synopsis "C-style escape directives for Common Lisp")
14214 (description
14215 "This Common Lisp library interprets escape characters the same way that
14216 most other programming language do.
14217 It provides four readtables. The default one lets you write strings like this:
14218 @code{#\"This string has\na newline in it!\"}.")
14219 (license license:public-domain))))
14220
14221 (define-public ecl-trivial-escapes
14222 (sbcl-package->ecl-package sbcl-trivial-escapes))
14223
14224 (define-public cl-trivial-escapes
14225 (sbcl-package->cl-source-package sbcl-trivial-escapes))
14226
14227 (define-public sbcl-cl-indentify
14228 (let ((commit "eb770f434defa4cd41d84bca822428dfd0dbac53"))
14229 (package
14230 (name "sbcl-cl-indentify")
14231 (version (git-version "0.1" "1" commit))
14232 (source
14233 (origin
14234 (method git-fetch)
14235 (uri (git-reference
14236 (url "https://github.com/yitzchak/cl-indentify")
14237 (commit commit)))
14238 (file-name (git-file-name name commit))
14239 (sha256
14240 (base32 "0ha36bhg474vr76vfhr13szc8cfdj1ickg92k1icz791bqaqg67p"))))
14241 (build-system asdf-build-system/sbcl)
14242 (inputs
14243 `(("alexandria" ,sbcl-alexandria)
14244 ("command-line-arguments" ,sbcl-command-line-arguments)
14245 ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
14246 (native-inputs
14247 `(("trivial-escapes" ,sbcl-trivial-escapes)
14248 ("rove" ,sbcl-rove)))
14249 (home-page "https://github.com/yitzchak/cl-indentify")
14250 (synopsis "Code beautifier for Common Lisp")
14251 (description
14252 "A library and command line utility to automatically indent Common Lisp
14253 source files.")
14254 (license license:expat))))
14255
14256 (define-public ecl-cl-indentify
14257 (sbcl-package->ecl-package sbcl-cl-indentify))
14258
14259 (define-public cl-indentify
14260 (sbcl-package->cl-source-package sbcl-cl-indentify))
14261
14262 (define-public sbcl-concrete-syntax-tree
14263 (let ((commit "abd242a59dadc5452aa9dbc1d313c83ec2c11f46"))
14264 (package
14265 (name "sbcl-concrete-syntax-tree")
14266 (version (git-version "0.0.0" "1" commit))
14267 (source
14268 (origin
14269 (method git-fetch)
14270 (uri (git-reference
14271 (url "https://github.com/s-expressionists/Concrete-Syntax-Tree")
14272 (commit commit)))
14273 (file-name (git-file-name name commit))
14274 (sha256
14275 (base32 "1lyrglc3h1if44gxd9cwv90wa90nrdjvb7fry39b1xn8ywdfa7di"))))
14276 (build-system asdf-build-system/sbcl)
14277 (inputs
14278 `(("acclimation" ,sbcl-acclimation)))
14279 (home-page "https://github.com/s-expressionists/Concrete-Syntax-Tree")
14280 (synopsis "Parse Common Lisp code into a concrete syntax tree")
14281 (description
14282 "This library is intended to solve the problem of source tracking for
14283 Common Lisp code.
14284
14285 By \"source tracking\", it is meant that code elements that have a known
14286 origin in the form of a position in a file or in an editor buffer are
14287 associated with some kind of information about this origin.
14288
14289 Since the exact nature of such origin information depends on the Common Lisp
14290 implementation and the purpose of wanting to track that origin, the library
14291 does not impose a particular structure of this information. Instead, it
14292 provides utilities for manipulating source code in the form of what is called
14293 concrete syntax trees (CSTs for short) that preserve this information about
14294 the origin.")
14295 (license license:bsd-2))))
14296
14297 (define-public ecl-concrete-syntax-tree
14298 (sbcl-package->ecl-package sbcl-concrete-syntax-tree))
14299
14300 (define-public cl-concrete-syntax-tree
14301 (sbcl-package->cl-source-package sbcl-concrete-syntax-tree))
14302
14303 (define-public sbcl-eclector
14304 (package
14305 (name "sbcl-eclector")
14306 (version "0.5.0")
14307 (source
14308 (origin
14309 (method git-fetch)
14310 (uri (git-reference
14311 (url "https://github.com/s-expressionists/Eclector")
14312 (commit version)))
14313 (file-name (git-file-name name version))
14314 (sha256
14315 (base32 "0bwkla0jdp5bg0q1zca5wg22b0nbdmglgax345nrhsf8bdrh47wm"))))
14316 (build-system asdf-build-system/sbcl)
14317 (inputs
14318 `(("acclimation" ,sbcl-acclimation)
14319 ("alexandria" ,sbcl-alexandria)
14320 ("closer-mop" ,sbcl-closer-mop)
14321 ("concrete-syntax-tree" ,sbcl-concrete-syntax-tree)))
14322 (native-inputs
14323 `(("fiveam" ,sbcl-fiveam)))
14324 (arguments
14325 '(#:asd-systems '("eclector"
14326 "eclector-concrete-syntax-tree")))
14327 (home-page "https://s-expressionists.github.io/Eclector/")
14328 (synopsis "Highly customizable, portable Common Lisp reader")
14329 (description
14330 "Eclector is a portable Common Lisp reader that is highly customizable,
14331 can recover from errors and can return concrete syntax trees.
14332
14333 In contrast to many other reader implementations, eclector can recover from
14334 most errors in the input supplied to it and continue reading. This capability
14335 is realized as a restart.
14336
14337 It can also produce instances of the concrete syntax tree classes provided by
14338 the concrete syntax tree library.")
14339 (license license:bsd-2)))
14340
14341 (define-public ecl-eclector
14342 (sbcl-package->ecl-package sbcl-eclector))
14343
14344 (define-public cl-eclector
14345 (sbcl-package->cl-source-package sbcl-eclector))
14346
14347 (define-public sbcl-jsown
14348 (let ((commit "744c4407bef58dfa876d9da0b5c0205d869e7977"))
14349 (package
14350 (name "sbcl-jsown")
14351 (version (git-version "1.0.1" "1" commit))
14352 (source
14353 (origin
14354 (method git-fetch)
14355 (uri (git-reference
14356 (url "https://github.com/madnificent/jsown")
14357 (commit commit)))
14358 (file-name (git-file-name name commit))
14359 (sha256
14360 (base32 "0gadvmf1d9bq35s61z76psrsnzwwk12svi66jigf491hv48wigw7"))))
14361 (build-system asdf-build-system/sbcl)
14362 (home-page "https://github.com/madnificent/jsown")
14363 (synopsis "Fast JSON reader / writer library for Common Lisp")
14364 (description
14365 "@code{jsown} is a high performance Common Lisp JSON parser. Its aim
14366 is to allow for the fast parsing of JSON objects in Common Lisp. Recently,
14367 functions and macros have been added to ease the burden of writing and editing
14368 @code{jsown} objects.
14369
14370 @code{jsown} allows you to parse JSON objects quickly to a modifiable Lisp
14371 list and write them back. If you only need partial retrieval of objects,
14372 @code{jsown} allows you to select the keys which you would like to see parsed.
14373 @code{jsown} also has a JSON writer and some helper methods to alter the JSON
14374 objects themselves.")
14375 (license license:expat))))
14376
14377 (define-public ecl-jsown
14378 (sbcl-package->ecl-package sbcl-jsown))
14379
14380 (define-public cl-jsown
14381 (sbcl-package->cl-source-package sbcl-jsown))
14382
14383 (define-public sbcl-system-locale
14384 (let ((commit "4b334bc2fa45651bcaa28ae7d9331095d6bf0a17"))
14385 (package
14386 (name "sbcl-system-locale")
14387 (version (git-version "1.0.0" "1" commit))
14388 (source
14389 (origin
14390 (method git-fetch)
14391 (uri (git-reference
14392 (url "https://github.com/Shinmera/system-locale/")
14393 (commit commit)))
14394 (file-name (git-file-name name commit))
14395 (sha256
14396 (base32 "00p5c053kmgq4ks6l9mxsqz6g3bjcybvkvj0bh3r90qgpkaawm1p"))))
14397 (build-system asdf-build-system/sbcl)
14398 (inputs
14399 `(("documentation-utils" ,sbcl-documentation-utils)))
14400 (home-page "https://shinmera.github.io/system-locale/")
14401 (synopsis "Get the system's locale and language settings in Common Lisp")
14402 (description
14403 "This library retrieves locale information configured on the
14404 system. This is helpful if you want to write applications and libraries that
14405 display messages in the user's native language.")
14406 (license license:zlib))))
14407
14408 (define-public ecl-system-locale
14409 (sbcl-package->ecl-package sbcl-system-locale))
14410
14411 (define-public cl-system-locale
14412 (sbcl-package->cl-source-package sbcl-system-locale))
14413
14414 (define-public sbcl-language-codes
14415 (let ((commit "e7aa0e37cb97a3d37d6bc7316b479d01bff8f42e"))
14416 (package
14417 (name "sbcl-language-codes")
14418 (version (git-version "1.0.0" "1" commit))
14419 (source
14420 (origin
14421 (method git-fetch)
14422 (uri (git-reference
14423 (url "https://github.com/Shinmera/language-codes")
14424 (commit commit)))
14425 (file-name (git-file-name name commit))
14426 (sha256
14427 (base32 "0py176ibmsc01n5r0q1bs1ykqf5jwdbh8kx0j1a814l9y51241v0"))))
14428 (build-system asdf-build-system/sbcl)
14429 (inputs
14430 `(("documentation-utils" ,sbcl-documentation-utils)))
14431 (home-page "https://shinmera.github.io/language-codes/")
14432 (synopsis "Map ISO language codes to language names in Common Lisp")
14433 (description
14434 "This is a small library providing the ISO-639 language code to
14435 language name mapping.")
14436 (license license:zlib))))
14437
14438 (define-public ecl-language-codes
14439 (sbcl-package->ecl-package sbcl-language-codes))
14440
14441 (define-public cl-language-codes
14442 (sbcl-package->cl-source-package sbcl-language-codes))
14443
14444 (define-public sbcl-multilang-documentation
14445 (let ((commit "59e798a07e949e8957a20927f52aca425d84e4a0"))
14446 (package
14447 (name "sbcl-multilang-documentation")
14448 (version (git-version "1.0.0" "1" commit))
14449 (source
14450 (origin
14451 (method git-fetch)
14452 (uri (git-reference
14453 (url "https://github.com/Shinmera/multilang-documentation")
14454 (commit commit)))
14455 (file-name (git-file-name name commit))
14456 (sha256
14457 (base32 "13y5jskx8n2b7kimpfarr8v777w3b7zj5swg1b99nj3hk0843ixw"))))
14458 (build-system asdf-build-system/sbcl)
14459 (inputs
14460 `(("documentation-utils" ,sbcl-documentation-utils)
14461 ("language-codes" ,sbcl-language-codes)
14462 ("system-locale" ,sbcl-system-locale)))
14463 (home-page "https://shinmera.github.io/multilang-documentation/")
14464 (synopsis "Add multiple languages support to Common Lisp documentation")
14465 (description
14466 "This library provides a drop-in replacement function for
14467 cl:documentation that supports multiple docstrings per-language, allowing you
14468 to write documentation that can be internationalised.")
14469 (license license:zlib))))
14470
14471 (define-public ecl-multilang-documentation
14472 (sbcl-package->ecl-package sbcl-multilang-documentation))
14473
14474 (define-public cl-multilang-documentation
14475 (sbcl-package->cl-source-package sbcl-multilang-documentation))
14476
14477 (define-public sbcl-trivial-do
14478 (let ((commit "03a1729f1e71bad3ebcf6cf098a0cce52dfa1163"))
14479 (package
14480 (name "sbcl-trivial-do")
14481 (version (git-version "0.1" "1" commit))
14482 (source
14483 (origin
14484 (method git-fetch)
14485 (uri (git-reference
14486 (url "https://github.com/yitzchak/trivial-do")
14487 (commit commit)))
14488 (file-name (git-file-name name commit))
14489 (sha256
14490 (base32 "1ffva79nkicc7wc8c2ic5nayis3b2rk5sxzj74yjkymkjgbpcrgd"))))
14491 (build-system asdf-build-system/sbcl)
14492 (home-page "https://github.com/yitzchak/trivial-do")
14493 (synopsis "Additional dolist style macros for Common Lisp")
14494 (description
14495 "Additional dolist style macros for Common Lisp, such as
14496 @code{doalist}, @code{dohash}, @code{dolist*}, @code{doplist}, @code{doseq}
14497 and @code{doseq*}.")
14498 (license license:zlib))))
14499
14500 (define-public ecl-trivial-do
14501 (sbcl-package->ecl-package sbcl-trivial-do))
14502
14503 (define-public cl-trivial-do
14504 (sbcl-package->cl-source-package sbcl-trivial-do))
14505
14506 (define-public sbcl-common-lisp-jupyter
14507 (let ((commit "011f60b69a3b8c70eefeafe7acb724cd00dd3e62"))
14508 (package
14509 (name "sbcl-common-lisp-jupyter")
14510 (version (git-version "0.1" "2" commit))
14511 (source
14512 (origin
14513 (method git-fetch)
14514 (uri (git-reference
14515 (url "https://github.com/yitzchak/common-lisp-jupyter")
14516 (commit commit)))
14517 (file-name (git-file-name name commit))
14518 (sha256
14519 (base32 "10jdghlcmp9p6ygrvw7g49i8f9jy71ybzn29n544fzb6g47siqhw"))))
14520 (build-system asdf-build-system/sbcl)
14521 (inputs
14522 `(("alexandria" ,sbcl-alexandria)
14523 ("babel" ,sbcl-babel)
14524 ("bordeaux-threads" ,sbcl-bordeaux-threads)
14525 ("cl-base64" ,sbcl-cl-base64)
14526 ("cl-indentify" ,sbcl-cl-indentify)
14527 ("closer-mop" ,sbcl-closer-mop)
14528 ("eclector" ,sbcl-eclector)
14529 ("ironclad" ,sbcl-ironclad)
14530 ("iterate" ,sbcl-iterate)
14531 ("jsown" ,sbcl-jsown)
14532 ("multilang-documentation" ,sbcl-multilang-documentation)
14533 ("pzmq" ,sbcl-pzmq)
14534 ("puri" ,sbcl-puri)
14535 ("static-vectors" ,sbcl-static-vectors)
14536 ("trivial-do" ,sbcl-trivial-do)
14537 ("trivial-garbage" ,sbcl-trivial-garbage)
14538 ("trivial-gray-streams" ,sbcl-trivial-gray-streams)
14539 ("trivial-mimes" ,sbcl-trivial-mimes)))
14540 (home-page "https://yitzchak.github.io/common-lisp-jupyter/")
14541 (synopsis "Common Lisp kernel for Jupyter")
14542 (description
14543 "This is a Common Lisp kernel for Jupyter along with a library for
14544 building Jupyter kernels, based on Maxima-Jupyter which was based on
14545 @code{cl-jupyter}.")
14546 (license license:zlib))))
14547
14548 (define-public ecl-common-lisp-jupyter
14549 (sbcl-package->ecl-package sbcl-common-lisp-jupyter))
14550
14551 (define-public cl-common-lisp-jupyter
14552 (sbcl-package->cl-source-package sbcl-common-lisp-jupyter))
14553
14554 (define-public sbcl-radiance
14555 (let ((commit "5ffbe1f157edd17a13194495099efd81e052df85")
14556 (revision "1"))
14557 (package
14558 (name "sbcl-radiance")
14559 (version (git-version "2.1.2" revision commit))
14560 (source
14561 (origin
14562 (method git-fetch)
14563 (uri (git-reference
14564 (url "https://github.com/Shirakumo/radiance")
14565 (commit commit)))
14566 (file-name (git-file-name "radiance" version))
14567 (sha256
14568 (base32 "0hbkcnmnlj1cqzbv18zmla2iwbl65kxilz9764hndf8x8as1539c"))))
14569 (build-system asdf-build-system/sbcl)
14570 (arguments
14571 `(#:tests? #f ; TODO: The tests require some configuration.
14572 #:phases
14573 (modify-phases %standard-phases
14574 (add-after 'unpack 'disable-quicklisp
14575 (lambda _
14576 ;; Disable the automatic installation of systems by Quicklisp.
14577 ;; (Maybe there would be a way to package Quicklisp and make it
14578 ;; install things in the user's directory instead of
14579 ;; /gnu/store/...).
14580 (substitute* "interfaces.lisp"
14581 (("\\(unless \\(asdf:find-system configured-implementation NIL\\)"
14582 all)
14583 (string-append "#+quicklisp " all))))))))
14584 (native-inputs
14585 `(("alexandria" ,sbcl-alexandria)
14586 ("dexador" ,sbcl-dexador)
14587 ("parachute" ,sbcl-parachute)
14588 ("verbose" ,sbcl-verbose)))
14589 (inputs
14590 `(("babel" ,sbcl-babel)
14591 ("bordeaux-threads" ,sbcl-bordeaux-threads)
14592 ("cl-ppcre" ,sbcl-cl-ppcre)
14593 ("closer-mop" ,sbcl-closer-mop)
14594 ("documentation-utils" ,sbcl-documentation-utils)
14595 ("deploy" ,sbcl-deploy)
14596 ("form-fiddle" ,sbcl-form-fiddle)
14597 ("lambda-fiddle" ,sbcl-lambda-fiddle)
14598 ("local-time" ,sbcl-local-time)
14599 ("modularize-hooks" ,sbcl-modularize-hooks)
14600 ("modularize-interfaces" ,sbcl-modularize-interfaces)
14601 ("puri" ,sbcl-puri)
14602 ("trivial-indent" ,sbcl-trivial-indent)
14603 ("trivial-mimes" ,sbcl-trivial-mimes)
14604 ("ubiquitous-concurrent" ,sbcl-ubiquitous)))
14605 (home-page "https://shirakumo.github.io/radiance/")
14606 (synopsis "Common Lisp web application environment")
14607 (description
14608 "Radiance is a web application environment, which is sort of like a web
14609 framework, but more general, more flexible. It should let you write personal
14610 websites and generally deployable applications easily and in such a way that
14611 they can be used on practically any setup without having to undergo special
14612 adaptations.")
14613 (license license:zlib))))
14614
14615 (define-public ecl-radiance
14616 (sbcl-package->ecl-package sbcl-radiance))
14617
14618 (define-public cl-radiance
14619 (sbcl-package->cl-source-package sbcl-radiance))
14620
14621 (define-public sbcl-daemon
14622 (let ((commit "d5652f4332c3cee21e9bf83b9237129605004597")
14623 (revision "1"))
14624 (package
14625 (name "sbcl-daemon")
14626 (version (git-version "0.0.4" revision commit))
14627 (source
14628 (origin
14629 (method git-fetch)
14630 (uri (git-reference
14631 (url "https://github.com/snmsts/daemon")
14632 (commit commit)))
14633 (file-name (git-file-name "daemon" version))
14634 (sha256
14635 (base32 "1kdxfnhh9fz34j8qs7pn7mwjz3v33q4v9nh0hqkyzraq5xs2j3f4"))))
14636 (build-system asdf-build-system/sbcl)
14637 (inputs
14638 `(("trivial-features" ,sbcl-trivial-features)))
14639 (home-page "https://github.com/snmsts/daemon")
14640 (synopsis "Daemonize Common Lisp processes")
14641 (description
14642 "DAEMON provides the functionality of daemonizing Common Lisp processes
14643 on UNIX like platforms.")
14644 (license license:expat))))
14645
14646 (define-public ecl-daemon
14647 (sbcl-package->ecl-package sbcl-daemon))
14648
14649 (define-public cl-daemon
14650 (sbcl-package->cl-source-package sbcl-daemon))
14651
14652 (define-public sbcl-file-attributes
14653 (let ((commit "bbde396438f37d676de9775239115410bec4da2d"))
14654 (package
14655 (name "sbcl-file-attributes")
14656 (version (git-version "1.0.0" "2" commit))
14657 (source
14658 (origin
14659 (method git-fetch)
14660 (uri (git-reference
14661 (url "https://github.com/Shinmera/file-attributes/")
14662 (commit commit)))
14663 (file-name (git-file-name name version))
14664 (sha256
14665 (base32 "0n8q818ry2shggjfhp8gjby8v5mla9pg97c5g19pcglpnwim7a74"))))
14666 (build-system asdf-build-system/sbcl)
14667 (inputs
14668 `(("cffi" ,sbcl-cffi)
14669 ("documentation-utils" ,sbcl-documentation-utils)
14670 ("trivial-features" ,sbcl-trivial-features)))
14671 (home-page "https://shinmera.github.io/file-attributes/")
14672 (synopsis "Access to common file attributes in Common Lisp")
14673 (description
14674 "This is a small OS portability library to retrieve and set file
14675 attributes not supported by the Common Lisp standard functions.")
14676 (license license:zlib))))
14677
14678 (define-public ecl-file-attributes
14679 (sbcl-package->ecl-package sbcl-file-attributes))
14680
14681 (define-public cl-file-attributes
14682 (sbcl-package->cl-source-package sbcl-file-attributes))