;;; Copyright © 2016 Federico Beffa <beffa@fbengineering.ch>
;;; Copyright © 2016, 2017 ng0 <ng0@n0.is>
;;; Copyright © 2016, 2017 Andy Patterson <ajpatter@uwaterloo.ca>
-;;; Copyright © 2017, 2019 Ricardo Wurmus <rekado@elephly.net>
+;;; Copyright © 2017, 2019, 2020 Ricardo Wurmus <rekado@elephly.net>
;;; Copyright © 2017, 2018, 2019 Efraim Flashner <efraim@flashner.co.il>
;;; Copyright © 2017, 2019 Tobias Geerinckx-Rice <me@tobias.gr>
;;; Copyright © 2018 Benjamin Slade <slade@jnanam.net>
#:use-module (gnu packages compression)
#:use-module (gnu packages glib)
#:use-module (gnu packages gtk)
+ #:use-module (gnu packages imagemagick)
+ #:use-module (gnu packages libevent)
#:use-module (gnu packages libffi)
#:use-module (gnu packages lisp)
#:use-module (gnu packages maths)
#:use-module (gnu packages python)
#:use-module (gnu packages python-xyz)
#:use-module (gnu packages sqlite)
+ #:use-module (gnu packages tcl)
#:use-module (gnu packages tls)
#:use-module (gnu packages webkit)
#:use-module (gnu packages xdisorg)
(sbcl-package->ecl-package sbcl-fiveam))
(define-public sbcl-bordeaux-threads
- (let ((commit "5dce49fbc829f4d136a734f5ef4f5d599660984f")
- (revision "1"))
- (package
- (name "sbcl-bordeaux-threads")
- (version (git-version "0.8.6" revision commit))
- (source (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/sionescu/bordeaux-threads.git")
- (commit commit)))
- (sha256
- (base32 "1gkh9rz7zw57n3110ikcf4835950wr4hgp8l79id5ai6nd86x7wv"))
- (file-name
- (git-file-name "bordeaux-threads" version))))
- (inputs `(("alexandria" ,sbcl-alexandria)))
- (native-inputs `(("fiveam" ,sbcl-fiveam)))
- (build-system asdf-build-system/sbcl)
- (synopsis "Portable shared-state concurrency library for Common Lisp")
- (description "BORDEAUX-THREADS is a proposed standard for a minimal
+ (package
+ (name "sbcl-bordeaux-threads")
+ (version "0.8.7")
+ (source (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sionescu/bordeaux-threads.git")
+ (commit (string-append "v" version))))
+ (sha256
+ (base32 "1whpfmyxp2fsw6viqj45fqgsifgr534c575bfh5vaqw5m84b6alp"))
+ (file-name
+ (git-file-name "bordeaux-threads" version))))
+ (inputs `(("alexandria" ,sbcl-alexandria)))
+ (native-inputs `(("fiveam" ,sbcl-fiveam)))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Portable shared-state concurrency library for Common Lisp")
+ (description "BORDEAUX-THREADS is a proposed standard for a minimal
MP/Threading interface. It is similar to the CLIM-SYS threading and lock
support.")
- (home-page "https://common-lisp.net/project/bordeaux-threads/")
- (license license:x11))))
+ (home-page "https://common-lisp.net/project/bordeaux-threads/")
+ (license license:x11)))
(define-public cl-bordeaux-threads
(sbcl-package->cl-source-package sbcl-bordeaux-threads))
(define-public sbcl-flexi-streams
(package
(name "sbcl-flexi-streams")
- (version "1.0.16")
+ (version "1.0.18")
(source
(origin
(method git-fetch)
(commit (string-append "v" version))))
(file-name (git-file-name "flexi-streams" version))
(sha256
- (base32 "0gvykjlmja060zqq6nn6aqxlshh6r6ijahmmgf20q0d839rwpgxc"))))
+ (base32 "0bjv7fd2acknidc5dyi3h85pn10krxv5jyxs1xg8jya2rlfv7f1j"))))
(build-system asdf-build-system/sbcl)
(arguments
`(#:phases
(define-public sbcl-cl-ppcre
(package
(name "sbcl-cl-ppcre")
- (version "2.0.11")
+ (version "2.1.1")
(source
(origin
(method git-fetch)
(commit (string-append "v" version))))
(file-name (git-file-name "cl-ppcre" version))
(sha256
- (base32 "0q3iany07vgqm144lw6pj0af2d3vsikpbkwcxr30fci3kzsq4f49"))))
+ (base32 "0dwvr29diqzcg5n6jvbk2rnd90i05l7n828hhw99khmqd0kz7xsi"))))
(build-system asdf-build-system/sbcl)
(native-inputs `(("flexi-streams" ,sbcl-flexi-streams)))
(synopsis "Portable regular expression library for Common Lisp")
(sbcl-package->ecl-package sbcl-cl-ppcre))
(define sbcl-cl-unicode-base
- (let ((revision "1")
- (commit "9fcd06fba1ddc9e66aed2f2d6c32dc9b764f03ea"))
- (package
- (name "sbcl-cl-unicode-base")
- (version (string-append "0.1.5-" revision "." (string-take commit 7)))
- (source (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/edicl/cl-unicode.git")
- (commit commit)))
- (file-name (string-append "cl-unicode-" version "-checkout"))
- (sha256
- (base32
- "1jicprb5b3bv57dy1kg03572gxkcaqdjhak00426s76g0plmx5ki"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-file "cl-unicode.asd"
- #:asd-system-name "cl-unicode/base"))
- (inputs
- `(("cl-ppcre" ,sbcl-cl-ppcre)))
- (home-page "http://weitz.de/cl-unicode/")
- (synopsis "Portable Unicode library for Common Lisp")
- (description "CL-UNICODE is a portable Unicode library Common Lisp, which
+ (package
+ (name "sbcl-cl-unicode-base")
+ (version "0.1.6")
+ (source (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/edicl/cl-unicode.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0ykx2s9lqfl74p1px0ik3l2izd1fc9jd1b4ra68s5x34rvjy0hza"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-file "cl-unicode.asd"
+ #:asd-system-name "cl-unicode/base"))
+ (inputs
+ `(("cl-ppcre" ,sbcl-cl-ppcre)))
+ (home-page "http://weitz.de/cl-unicode/")
+ (synopsis "Portable Unicode library for Common Lisp")
+ (description "CL-UNICODE is a portable Unicode library Common Lisp, which
is compatible with perl. It is pretty fast, thread-safe, and compatible with
ANSI-compliant Common Lisp implementations.")
- (license license:bsd-2))))
+ (license license:bsd-2)))
(define-public sbcl-cl-unicode
(package
(define-public cl-unicode
(sbcl-package->cl-source-package sbcl-cl-unicode))
+(define-public sbcl-zpb-ttf
+ (package
+ (name "sbcl-zpb-ttf")
+ (version "1.0.3")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/xach/zpb-ttf.git")
+ (commit (string-append "release-" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1wh66vjijzqlydnrihynpwp6796917xwrh0i9li93c17kyxa74ih"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/xach/zpb-ttf")
+ (synopsis "TrueType font file access for Common Lisp")
+ (description
+ "ZPB-TTF is a TrueType font file parser that provides an interface for
+reading typographic metrics, glyph outlines, and other information from the
+file.")
+ (license license:bsd-2)))
+
+(define-public ecl-zpb-ttf
+ (sbcl-package->ecl-package sbcl-zpb-ttf))
+
+(define-public cl-zpb-ttf
+ (sbcl-package->cl-source-package sbcl-zpb-ttf))
+
+(define-public sbcl-cl-aa
+ (package
+ (name "sbcl-cl-aa")
+ (version "0.1.5")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "http://projects.tuxee.net/cl-vectors/"
+ "files/cl-vectors-" version ".tar.gz"))
+ (sha256
+ (base32
+ "04lhwi0kq8pkwhgd885pk80m1cp9sfvjjn5zj70s1dnckibhdmqh"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments '(#:asd-file "cl-aa.asd"))
+ (home-page "http://projects.tuxee.net/cl-vectors/")
+ (synopsis "Polygon rasterizer")
+ (description
+ "This is a Common Lisp library implementing the AA polygon rasterization
+algorithm from the @url{http://antigrain.com, Antigrain} project.")
+ (license license:expat)))
+
+(define-public ecl-cl-aa
+ (sbcl-package->ecl-package sbcl-cl-aa))
+
+(define-public cl-aa
+ (sbcl-package->cl-source-package sbcl-cl-aa))
+
+(define-public sbcl-cl-paths
+ (package
+ (inherit sbcl-cl-aa)
+ (name "sbcl-cl-paths")
+ (arguments '(#:asd-file "cl-paths.asd"))
+ (synopsis "Facilities to create and manipulate vectorial paths")
+ (description
+ "This package provides facilities to create and manipulate vectorial
+paths.")))
+
+(define-public ecl-cl-paths
+ (sbcl-package->ecl-package sbcl-cl-paths))
+
+(define-public cl-paths
+ (sbcl-package->cl-source-package sbcl-cl-paths))
+
+(define-public sbcl-cl-paths-ttf
+ (package
+ (inherit sbcl-cl-aa)
+ (name "sbcl-cl-paths-ttf")
+ (arguments '(#:asd-file "cl-paths-ttf.asd"))
+ (inputs
+ `(("cl-paths" ,sbcl-cl-paths)
+ ("zpb-ttf" ,sbcl-zpb-ttf)))
+ (synopsis "Facilities to create and manipulate vectorial paths")
+ (description
+ "This package provides facilities to create and manipulate vectorial
+paths.")))
+
+(define-public ecl-cl-paths-ttf
+ (sbcl-package->ecl-package sbcl-cl-paths-ttf))
+
+(define-public cl-paths-ttf
+ (sbcl-package->cl-source-package sbcl-cl-paths-ttf))
+
+(define-public sbcl-cl-vectors
+ (package
+ (inherit sbcl-cl-aa)
+ (name "sbcl-cl-vectors")
+ (arguments '(#:asd-file "cl-vectors.asd"))
+ (inputs
+ `(("cl-aa" ,sbcl-cl-aa)
+ ("cl-paths" ,sbcl-cl-paths)))
+ (synopsis "Create, transform and render anti-aliased vectorial paths")
+ (description
+ "This is a pure Common Lisp library to create, transform and render
+anti-aliased vectorial paths.")))
+
+(define-public ecl-cl-vectors
+ (sbcl-package->ecl-package sbcl-cl-vectors))
+
+(define-public cl-vectors
+ (sbcl-package->cl-source-package sbcl-cl-vectors))
+
+(define-public sbcl-spatial-trees
+ ;; There have been no releases.
+ (let ((commit "81fdad0a0bf109c80a53cc96eca2e093823400ba")
+ (revision "1"))
+ (package
+ (name "sbcl-spatial-trees")
+ (version (git-version "0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/rpav/spatial-trees.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "11rhc6h501dwcik2igkszz7b9n515cr99m5pjh4r2qfwgiri6ysa"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:tests? #f ; spatial-trees.test requires spatial-trees.nns
+ #:asd-file "spatial-trees.asd"
+ #:test-asd-file "spatial-trees.test.asd"))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (home-page "https://github.com/rpav/spatial-trees")
+ (synopsis "Dynamic index data structures for spatially-extended data")
+ (description
+ "Spatial-trees is a set of dynamic index data structures for
+spatially-extended data.")
+ (license license:bsd-3))))
+
+(define-public ecl-spatial-trees
+ (sbcl-package->ecl-package sbcl-spatial-trees))
+
+(define-public cl-spatial-trees
+ (sbcl-package->cl-source-package sbcl-spatial-trees))
+
+(define-public sbcl-flexichain
+ ;; There are no releases.
+ (let ((commit "13d2a6c505ed0abfcd4c4ec7d7145059b06855d6")
+ (revision "1"))
+ (package
+ (name "sbcl-flexichain")
+ (version "1.5.1")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/robert-strandh/Flexichain.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0pfyvhsfbjd2sjb30grfs52r51a428xglv7bwydvpg2lc117qimg"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/robert-strandh/Flexichain.git")
+ (synopsis "Dynamically add elements to or remove them from sequences")
+ (description
+ "This package provides an implementation of the flexichain protocol,
+allowing client code to dynamically add elements to, and delete elements from
+a sequence (or chain) of such elements.")
+ (license license:lgpl2.1+))))
+
+(define-public ecl-flexichain
+ (sbcl-package->ecl-package sbcl-flexichain))
+
+(define-public cl-flexichain
+ (sbcl-package->cl-source-package sbcl-flexichain))
+
+(define-public sbcl-cl-pdf
+ ;; There are no releases
+ (let ((commit "752e337e6d6fc206f09d091a982e7f8e5c404e4e")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-pdf")
+ (version (git-version "0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/mbattyani/cl-pdf.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1cg3k3m3r11ipb8j008y8ipynj97l3xjlpi2knqc9ndmx4r3kb1r"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("iterate" ,sbcl-iterate)
+ ("zpb-ttf" ,sbcl-zpb-ttf)))
+ (home-page "https://github.com/mbattyani/cl-pdf")
+ (synopsis "Common Lisp library for generating PDF files")
+ (description
+ "CL-PDF is a cross-platform Common Lisp library for generating PDF
+files.")
+ (license license:bsd-2))))
+
+(define-public ecl-cl-pdf
+ (sbcl-package->ecl-package sbcl-cl-pdf))
+
+(define-public cl-pdf
+ (sbcl-package->cl-source-package sbcl-cl-pdf))
+
(define-public sbcl-clx
(package
(name "sbcl-clx")
`(("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
("sbcl-cl-unicode" ,sbcl-cl-unicode)))))
+(define-public ecl-cl-ppcre-unicode
+ (sbcl-package->ecl-package sbcl-cl-ppcre-unicode))
+
;; The slynk that users expect to install includes all of slynk's contrib
;; modules. Therefore, we build the base module and all contribs first; then
;; we expose the union of these as `sbcl-slynk'. The following variable
(define-public sbcl-split-sequence
(package
(name "sbcl-split-sequence")
- (version "1.4.1")
+ (version "2.0.0")
(source
(origin
(method git-fetch)
(commit (string-append "v" version))))
(sha256
(base32
- "0c3zp6b7fmmp93sfhq112ind4zkld49ycw68z409xpnz3gc0wpf0"))
+ "0jcpnx21hkfwqj5fvp7kc6pn1qcz9hk7g2s5x8h0349x1j2irln0"))
(file-name (git-file-name "split-sequence" version))))
(build-system asdf-build-system/sbcl)
- (arguments
- ;; TODO: Tests seem to be broken.
- ;; https://github.com/sharplispers/split-sequence/issues/8
- `(#:tests? #f))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
(synopsis "Member of the Common Lisp Utilities family of programs")
(description
"Splits sequence into a list of subsequences delimited by objects
(define-public sbcl-cl-fad
(package
(name "sbcl-cl-fad")
- (version "0.7.5")
+ (version "0.7.6")
(source
(origin
(method git-fetch)
(commit (string-append "v" version))))
(sha256
(base32
- "1l1qmk9z57q84bz5r04sxsksggsnd7dgkxlybzh9imz6ma7sm52m"))
+ "1gc8i82v6gks7g0lnm54r4prk2mklidv2flm5fvbr0a7rsys0vpa"))
(file-name (string-append "cl-fad" version "-checkout"))))
(build-system asdf-build-system/sbcl)
(inputs
(define-public sbcl-ironclad
(package
(name "sbcl-ironclad")
- (version "0.46")
+ (version "0.48")
(source
(origin
(method git-fetch)
(commit (string-append "v" version))))
(sha256
(base32
- "1s391awi2lsl7m1dbjirgpkm4p9p8wd076pakgvsvpn1rrznisnd"))
+ "1wzczpgvgjc5h8ghz75kxi7iykmqxqchdhgdhkif9j99kyqvbyam"))
(file-name (git-file-name name version))))
(build-system asdf-build-system/sbcl)
(native-inputs
`(("rt" ,sbcl-rt)))
(inputs
`(("bordeaux-threads" ,sbcl-bordeaux-threads)
- ("flexi-streams" ,sbcl-flexi-streams)
- ("nibbles" ,sbcl-nibbles)))
+ ("flexi-streams" ,sbcl-flexi-streams)))
(synopsis "Cryptographic toolkit written in Common Lisp")
(description
"Ironclad is a cryptography library written entirely in Common Lisp.
("cl-fad" ,sbcl-cl-fad)
("ironclad" ,sbcl-ironclad)
("named-readtables" ,sbcl-named-readtables)
- ("pythonic-string-reader" ,sbcl-pythonic-string-reader)
- ("swank" ,cl-slime-swank)))
+ ("pythonic-string-reader" ,sbcl-pythonic-string-reader)))
+ (propagated-inputs
+ ;; Packages having mgl-pax as input complain that it can't find
+ ;; swank if we put it in inputs, so let's put it in propageted-inputs.
+ `(("swank" ,cl-slime-swank)))
(synopsis "Exploratory programming environment and documentation generator")
(description
"PAX provides an extremely poor man's Explorable Programming
(define sbcl-cffi-bootstrap
(package
(name "sbcl-cffi-bootstrap")
- (version "0.19.0")
+ (version "0.21.0")
(source
(origin
(method git-fetch)
(commit (string-append "v" version))))
(file-name (git-file-name "cffi-bootstrap" version))
(sha256
- (base32 "09sfgc6r7ihmbkwfpvkq5fxc7h45cabpvgbvs47i5cvnmv3k72xy"))))
+ (base32 "1qalargz9bhp850qv60ffwpdqi4xirzar4l3g6qcg8yc6xqf2cjk"))))
(build-system asdf-build-system/sbcl)
(inputs
`(("libffi" ,libffi)
(build-system asdf-build-system/sbcl)
(inputs
`(("sbcl-lift" ,sbcl-lift)))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'check 'delete-test-results
+ (lambda* (#:key outputs #:allow-other-keys)
+ (let ((test-results (string-append (assoc-ref outputs "out")
+ "/share/common-lisp/"
+ (%lisp-type) "-source"
+ "/trivial-backtrace"
+ "/test-results")))
+ (when (file-exists? test-results)
+ (delete-file-recursively test-results)))
+ #t)))))
(home-page "https://common-lisp.net/project/trivial-backtrace/")
(synopsis "Portable simple API to work with backtraces in Common Lisp")
(description
(sbcl-package->cl-source-package sbcl-chipz))
(define-public sbcl-drakma
- (let ((version "2.0.4")
- (commit "7647c0ae842ff2058624e53979c7f297760c97a7")
- (revision "1"))
- (package
- (name "sbcl-drakma")
- (version (git-version version revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/edicl/drakma.git")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "1c4i9wakhj5pxfyyykxshdmv3180sbkrx6fcyynikmc0jd0rh84r"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("sbcl-puri" ,sbcl-puri)
- ("sbcl-cl-base64" ,sbcl-cl-base64)
- ("sbcl-chunga" ,sbcl-chunga)
- ("sbcl-flexi-streams" ,sbcl-flexi-streams)
- ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
- ("sbcl-chipz" ,sbcl-chipz)
- ("sbcl-usocket" ,sbcl-usocket)
- ("sbcl-cl+ssl" ,sbcl-cl+ssl)))
- (native-inputs
- `(("sbcl-fiveam" ,sbcl-fiveam)))
- (home-page "https://edicl.github.io/drakma/")
- (synopsis "HTTP client written in Common Lisp")
- (description
- "Drakma is a full-featured HTTP client implemented in Common Lisp. It
+ (package
+ (name "sbcl-drakma")
+ (version "2.0.7")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/edicl/drakma.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1441idnyif9xzx3ln1p3fg36k2v9h4wasjqrzc8y52j61420qpci"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("sbcl-puri" ,sbcl-puri)
+ ("sbcl-cl-base64" ,sbcl-cl-base64)
+ ("sbcl-chunga" ,sbcl-chunga)
+ ("sbcl-flexi-streams" ,sbcl-flexi-streams)
+ ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
+ ("sbcl-chipz" ,sbcl-chipz)
+ ("sbcl-usocket" ,sbcl-usocket)
+ ("sbcl-cl+ssl" ,sbcl-cl+ssl)))
+ (native-inputs
+ `(("sbcl-fiveam" ,sbcl-fiveam)))
+ (home-page "https://edicl.github.io/drakma/")
+ (synopsis "HTTP client written in Common Lisp")
+ (description
+ "Drakma is a full-featured HTTP client implemented in Common Lisp. It
knows how to handle HTTP/1.1 chunking, persistent connections, re-usable
sockets, SSL, continuable uploads, file uploads, cookies, and more.")
- (license license:bsd-2))))
+ (license license:bsd-2)))
(define-public cl-drakma
(sbcl-package->cl-source-package sbcl-drakma))
+(define-public ecl-drakma
+ (sbcl-package->ecl-package sbcl-drakma))
+
(define-public sbcl-hunchentoot
(package
(name "sbcl-hunchentoot")
(sbcl-package->cl-source-package sbcl-fast-http))
(define-public sbcl-static-vectors
- (let ((commit "0681eac1f49370cde03e64b077251e8abf47d702")
- (revision "1"))
- (package
- (name "sbcl-static-vectors")
- (version (git-version "1.8.3" revision commit))
- (source
- (origin
+ (package
+ (name "sbcl-static-vectors")
+ (version "1.8.4")
+ (source
+ (origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/sionescu/static-vectors.git")
- (commit commit)))
+ (commit (string-append "v" version))))
(file-name (git-file-name name version))
(sha256
- (base32 "138nlsq14hv8785ycjm6jw3i6ablhq8vcwys7q09y80arcgrg6r3"))))
- (native-inputs
- `(("sbcl-fiveam" ,sbcl-fiveam)))
- (inputs
- `(("sbcl-cffi-grovel" ,sbcl-cffi-grovel)
- ("sbcl-cffi" ,sbcl-cffi)))
- (build-system asdf-build-system/sbcl)
- (home-page "http://common-lisp.net/projects/iolib/")
- (synopsis "Allocate SIMPLE-ARRAYs in static memory")
- (description
- "With @code{static-vectors}, you can create vectors allocated in static
+ (base32 "0qvf9z6bhwhm8n45fjwkm7j8dcb58szfvndky65cyn4lpdval7m1"))))
+ (native-inputs
+ `(("sbcl-fiveam" ,sbcl-fiveam)))
+ (inputs
+ `(("sbcl-cffi-grovel" ,sbcl-cffi-grovel)
+ ("sbcl-cffi" ,sbcl-cffi)))
+ (build-system asdf-build-system/sbcl)
+ (home-page "http://common-lisp.net/projects/iolib/")
+ (synopsis "Allocate SIMPLE-ARRAYs in static memory")
+ (description
+ "With @code{static-vectors}, you can create vectors allocated in static
memory.")
- (license license:expat))))
+ (license license:expat)))
(define-public cl-static-vectors
(sbcl-package->cl-source-package sbcl-static-vectors))
(package
(name "sbcl-swap-bytes")
(build-system asdf-build-system/sbcl)
- (version "1.1")
+ (version "1.2")
(home-page "https://github.com/sionescu/swap-bytes")
(source
(origin
(file-name (git-file-name name version))
(sha256
(base32
- "1qysbv0jngdfkv53y874qjhcxc4qi8ixaqq6j8bzxh5z0931wv55"))))
+ "1hw1v1lw26rifyznpnj1csphha9jgzwpiic16ni3pvs6hcsni9rz"))))
(inputs
`(("trivial-features" ,sbcl-trivial-features)))
(native-inputs
`(("fiveam" ,sbcl-fiveam)))
- (arguments
- ;; TODO: Tests fail, why?
- `(#:tests? #f))
(synopsis "Efficient endianness conversion for Common Lisp")
(description "This Common Lisp library provides optimized byte-swapping
primitives. The library can change endianness of unsigned integers of length
("metabang-bind" ,sbcl-metabang-bind)
("named-readtables" ,sbcl-named-readtables)))
(arguments
- '(#:test-asd-file "graph.test.asd"))
+ '(#:test-asd-file "graph-test.asd"))
(synopsis "Graph data structure and algorithms for Common Lisp")
(description
"The GRAPH Common Lisp library provides a data structures to represent
("named-readtables" ,sbcl-named-readtables)))
(arguments
(substitute-keyword-arguments (package-arguments sbcl-graph)
- ((#:asd-file _ "") "graph.dot.asd")
+ ((#:asd-file _ "") "graph-dot.asd")
((#:asd-system-name _ #f) "graph-dot")))
(synopsis "Serialize graphs to and from DOT format")))
("yason" ,sbcl-yason)))
(arguments
(substitute-keyword-arguments (package-arguments sbcl-graph)
- ((#:asd-file _ "") "graph.json.asd")
+ ((#:asd-file _ "") "graph-json.asd")
((#:asd-system-name _ #f) "graph-json")))
(synopsis "Serialize graphs to and from JSON format")))
(define-public ecl-cl-ana.gsl-cffi
(sbcl-package->ecl-package sbcl-cl-ana.gsl-cffi))
+
+(define-public sbcl-cl-ana.ntuple-table
+ (package
+ (inherit sbcl-cl-ana-boot0)
+ (name "sbcl-cl-ana.ntuple-table")
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cffi" ,sbcl-cffi)
+ ("cl-ana.gsl-cffi" ,sbcl-cl-ana.gsl-cffi)
+ ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
+ ("cl-ana.table" ,sbcl-cl-ana.table)
+ ("cl-ana.typed-table" ,sbcl-cl-ana.typed-table)
+ ("cl-ana.typespec" ,sbcl-cl-ana.typespec)
+ ("gsll" ,sbcl-gsll)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+ ((#:asd-file _ "") "ntuple-table/cl-ana.ntuple-table.asd")
+ ((#:asd-system-name _ #f) "cl-ana.ntuple-table")))))
+
+(define-public cl-ana.ntuple-table
+ (sbcl-package->cl-source-package sbcl-cl-ana.ntuple-table))
+
+(define-public sbcl-cl-ana.csv-table
+ (package
+ (inherit sbcl-cl-ana-boot0)
+ (name "sbcl-cl-ana.csv-table")
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("antik" ,sbcl-antik)
+ ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
+ ("cl-ana.table" ,sbcl-cl-ana.table)
+ ("cl-csv" ,sbcl-cl-csv)
+ ("iterate" ,sbcl-iterate)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+ ((#:asd-file _ "") "csv-table/cl-ana.csv-table.asd")
+ ((#:asd-system-name _ #f) "cl-ana.csv-table")))))
+
+(define-public cl-ana.csv-table
+ (sbcl-package->cl-source-package sbcl-cl-ana.csv-table))
+
+(define-public sbcl-cl-ana.reusable-table
+ (package
+ (inherit sbcl-cl-ana-boot0)
+ (name "sbcl-cl-ana.reusable-table")
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-ana.table" ,sbcl-cl-ana.table)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+ ((#:asd-file _ "") "reusable-table/cl-ana.reusable-table.asd")
+ ((#:asd-system-name _ #f) "cl-ana.reusable-table")))))
+
+(define-public cl-ana.reusable-table
+ (sbcl-package->cl-source-package sbcl-cl-ana.reusable-table))
+
+(define-public ecl-cl-ana.reusable-table
+ (sbcl-package->ecl-package sbcl-cl-ana.reusable-table))
+
+(define-public sbcl-cl-ana.linear-algebra
+ (package
+ (inherit sbcl-cl-ana-boot0)
+ (name "sbcl-cl-ana.linear-algebra")
+ (inputs
+ `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
+ ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
+ ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
+ ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
+ ("gsll" ,sbcl-gsll)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+ ((#:asd-file _ "") "linear-algebra/cl-ana.linear-algebra.asd")
+ ((#:asd-system-name _ #f) "cl-ana.linear-algebra")))))
+
+(define-public cl-ana.linear-algebra
+ (sbcl-package->cl-source-package sbcl-cl-ana.linear-algebra))
+
+(define-public sbcl-cl-ana.lorentz
+ (package
+ (inherit sbcl-cl-ana-boot0)
+ (name "sbcl-cl-ana.lorentz")
+ (inputs
+ `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
+ ("cl-ana.linear-algebra" ,sbcl-cl-ana.linear-algebra)
+ ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
+ ("iterate" ,sbcl-iterate)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+ ((#:asd-file _ "") "lorentz/cl-ana.lorentz.asd")
+ ((#:asd-system-name _ #f) "cl-ana.lorentz")))))
+
+(define-public cl-ana.lorentz
+ (sbcl-package->cl-source-package sbcl-cl-ana.lorentz))
+
+(define-public sbcl-cl-ana.clos-utils
+ (package
+ (inherit sbcl-cl-ana-boot0)
+ (name "sbcl-cl-ana.clos-utils")
+ (inputs
+ `(("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
+ ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
+ ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
+ ("closer-mop" ,sbcl-closer-mop)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+ ((#:asd-file _ "") "clos-utils/cl-ana.clos-utils.asd")
+ ((#:asd-system-name _ #f) "cl-ana.clos-utils")))))
+
+(define-public cl-ana.clos-utils
+ (sbcl-package->cl-source-package sbcl-cl-ana.clos-utils))
+
+(define-public ecl-cl-ana.clos-utils
+ (sbcl-package->ecl-package sbcl-cl-ana.clos-utils))
+
+(define-public sbcl-cl-ana.hash-table-utils
+ (package
+ (inherit sbcl-cl-ana-boot0)
+ (name "sbcl-cl-ana.hash-table-utils")
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+ ((#:asd-file _ "") "hash-table-utils/cl-ana.hash-table-utils.asd")
+ ((#:asd-system-name _ #f) "cl-ana.hash-table-utils")))))
+
+(define-public cl-ana.hash-table-utils
+ (sbcl-package->cl-source-package sbcl-cl-ana.hash-table-utils))
+
+(define-public ecl-cl-ana.hash-table-utils
+ (sbcl-package->ecl-package sbcl-cl-ana.hash-table-utils))
+
+(define-public sbcl-cl-ana.map
+ (package
+ (inherit sbcl-cl-ana-boot0)
+ (name "sbcl-cl-ana.map")
+ (inputs
+ `(("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+ ((#:asd-file _ "") "map/cl-ana.map.asd")
+ ((#:asd-system-name _ #f) "cl-ana.map")))))
+
+(define-public cl-ana.map
+ (sbcl-package->cl-source-package sbcl-cl-ana.map))
+
+(define-public ecl-cl-ana.map
+ (sbcl-package->ecl-package sbcl-cl-ana.map))
+
+(define-public sbcl-cl-ana.fitting
+ (package
+ (inherit sbcl-cl-ana-boot0)
+ (name "sbcl-cl-ana.fitting")
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
+ ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
+ ("cl-ana.map" ,sbcl-cl-ana.map)
+ ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
+ ("gsll" ,sbcl-gsll)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+ ((#:asd-file _ "") "fitting/cl-ana.fitting.asd")
+ ((#:asd-system-name _ #f) "cl-ana.fitting")))))
+
+(define-public cl-ana.fitting
+ (sbcl-package->cl-source-package sbcl-cl-ana.fitting))
+
+(define-public sbcl-cl-ana.histogram
+ (package
+ (inherit sbcl-cl-ana-boot0)
+ (name "sbcl-cl-ana.histogram")
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("iterate" ,sbcl-iterate)
+ ("cl-ana.binary-tree" ,sbcl-cl-ana.binary-tree)
+ ("cl-ana.clos-utils" ,sbcl-cl-ana.clos-utils)
+ ("cl-ana.fitting" ,sbcl-cl-ana.fitting)
+ ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
+ ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
+ ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
+ ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
+ ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
+ ("cl-ana.map" ,sbcl-cl-ana.map)
+ ("cl-ana.tensor" ,sbcl-cl-ana.tensor)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+ ((#:asd-file _ "") "histogram/cl-ana.histogram.asd")
+ ((#:asd-system-name _ #f) "cl-ana.histogram")))))
+
+(define-public cl-ana.histogram
+ (sbcl-package->cl-source-package sbcl-cl-ana.histogram))
+
+(define-public sbcl-cl-ana.file-utils
+ (package
+ (inherit sbcl-cl-ana-boot0)
+ (name "sbcl-cl-ana.file-utils")
+ (inputs
+ `(("external-program" ,sbcl-external-program)
+ ("split-sequence" ,sbcl-split-sequence)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+ ((#:asd-file _ "") "file-utils/cl-ana.file-utils.asd")
+ ((#:asd-system-name _ #f) "cl-ana.file-utils")))))
+
+(define-public cl-ana.file-utils
+ (sbcl-package->cl-source-package sbcl-cl-ana.file-utils))
+
+(define-public ecl-cl-ana.file-utils
+ (sbcl-package->ecl-package sbcl-cl-ana.file-utils))
+
+(define-public sbcl-cl-ana.statistics
+ (package
+ (inherit sbcl-cl-ana-boot0)
+ (name "sbcl-cl-ana.statistics")
+ (inputs
+ `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
+ ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
+ ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
+ ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
+ ("cl-ana.map" ,sbcl-cl-ana.map)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+ ((#:asd-file _ "") "statistics/cl-ana.statistics.asd")
+ ((#:asd-system-name _ #f) "cl-ana.statistics")))))
+
+(define-public cl-ana.statistics
+ (sbcl-package->cl-source-package sbcl-cl-ana.statistics))
+
+(define-public sbcl-cl-ana.gnuplot-interface
+ (package
+ (inherit sbcl-cl-ana-boot0)
+ (name "sbcl-cl-ana.gnuplot-interface")
+ (inputs
+ `(("external-program" ,sbcl-external-program)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+ ((#:asd-file _ "") "gnuplot-interface/cl-ana.gnuplot-interface.asd")
+ ((#:asd-system-name _ #f) "cl-ana.gnuplot-interface")))))
+
+(define-public cl-ana.gnuplot-interface
+ (sbcl-package->cl-source-package sbcl-cl-ana.gnuplot-interface))
+
+(define-public ecl-cl-ana.gnuplot-interface
+ (sbcl-package->ecl-package sbcl-cl-ana.gnuplot-interface))
+
+(define-public sbcl-cl-ana.plotting
+ (package
+ (inherit sbcl-cl-ana-boot0)
+ (name "sbcl-cl-ana.plotting")
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
+ ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
+ ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
+ ("cl-ana.gnuplot-interface" ,sbcl-cl-ana.gnuplot-interface)
+ ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
+ ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
+ ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
+ ("cl-ana.map" ,sbcl-cl-ana.map)
+ ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
+ ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
+ ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
+ ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
+ ("external-program" ,sbcl-external-program)
+ ("split-sequence" ,sbcl-split-sequence)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+ ((#:asd-file _ "") "plotting/cl-ana.plotting.asd")
+ ((#:asd-system-name _ #f) "cl-ana.plotting")))))
+
+(define-public cl-ana.plotting
+ (sbcl-package->cl-source-package sbcl-cl-ana.plotting))
+
+(define-public sbcl-cl-ana.table-viewing
+ (package
+ (inherit sbcl-cl-ana-boot0)
+ (name "sbcl-cl-ana.table-viewing")
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
+ ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
+ ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
+ ("cl-ana.plotting" ,sbcl-cl-ana.plotting)
+ ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
+ ("cl-ana.table" ,sbcl-cl-ana.table)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+ ((#:asd-file _ "") "table-viewing/cl-ana.table-viewing.asd")
+ ((#:asd-system-name _ #f) "cl-ana.table-viewing")))))
+
+(define-public cl-ana.table-viewing
+ (sbcl-package->cl-source-package sbcl-cl-ana.table-viewing))
+
+(define-public sbcl-cl-ana.serialization
+ (package
+ (inherit sbcl-cl-ana-boot0)
+ (name "sbcl-cl-ana.serialization")
+ (inputs
+ `(("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
+ ("cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
+ ("cl-ana.hdf-table" ,sbcl-cl-ana.hdf-table)
+ ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
+ ("cl-ana.int-char" ,sbcl-cl-ana.int-char)
+ ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
+ ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+ ((#:asd-file _ "") "serialization/cl-ana.serialization.asd")
+ ((#:asd-system-name _ #f) "cl-ana.serialization")))))
+
+(define-public cl-ana.serialization
+ (sbcl-package->cl-source-package sbcl-cl-ana.serialization))
+
+(define-public sbcl-cl-ana.makeres
+ (package
+ (inherit sbcl-cl-ana-boot0)
+ (name "sbcl-cl-ana.makeres")
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
+ ("cl-ana.file-utils" ,sbcl-cl-ana.file-utils)
+ ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
+ ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
+ ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
+ ("cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
+ ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
+ ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
+ ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
+ ("cl-ana.map" ,sbcl-cl-ana.map)
+ ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
+ ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
+ ("cl-ana.plotting" ,sbcl-cl-ana.plotting)
+ ("cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
+ ("cl-ana.serialization" ,sbcl-cl-ana.serialization)
+ ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
+ ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
+ ("cl-ana.table" ,sbcl-cl-ana.table)
+ ("external-program" ,sbcl-external-program)))
+ (native-inputs
+ `(("cl-fad" ,sbcl-cl-fad)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+ ((#:asd-file _ "") "makeres/cl-ana.makeres.asd")
+ ((#:asd-system-name _ #f) "cl-ana.makeres")))))
+
+(define-public cl-ana.makeres
+ (sbcl-package->cl-source-package sbcl-cl-ana.makeres))
+
+(define-public sbcl-cl-ana.makeres-macro
+ (package
+ (inherit sbcl-cl-ana-boot0)
+ (name "sbcl-cl-ana.makeres-macro")
+ (inputs
+ `(("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
+ ("cl-ana.makeres" ,sbcl-cl-ana.makeres)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+ ((#:asd-file _ "") "makeres-macro/cl-ana.makeres-macro.asd")
+ ((#:asd-system-name _ #f) "cl-ana.makeres-macro")))))
+
+(define-public cl-ana.makeres-macro
+ (sbcl-package->cl-source-package sbcl-cl-ana.makeres-macro))
+
+(define-public sbcl-cl-ana.makeres-block
+ (package
+ (inherit sbcl-cl-ana-boot0)
+ (name "sbcl-cl-ana.makeres-block")
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
+ ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
+ ("cl-ana.makeres" ,sbcl-cl-ana.makeres)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+ ((#:asd-file _ "") "makeres-block/cl-ana.makeres-block.asd")
+ ((#:asd-system-name _ #f) "cl-ana.makeres-block")))))
+
+(define-public cl-ana.makeres-block
+ (sbcl-package->cl-source-package sbcl-cl-ana.makeres-block))
+
+(define-public sbcl-cl-ana.makeres-progress
+ (package
+ (inherit sbcl-cl-ana-boot0)
+ (name "sbcl-cl-ana.makeres-progress")
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
+ ("cl-ana.makeres" ,sbcl-cl-ana.makeres)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+ ((#:asd-file _ "") "makeres-progress/cl-ana.makeres-progress.asd")
+ ((#:asd-system-name _ #f) "cl-ana.makeres-progress")))))
+
+(define-public cl-ana.makeres-progress
+ (sbcl-package->cl-source-package sbcl-cl-ana.makeres-progress))
+
+(define-public sbcl-cl-ana.makeres-table
+ (package
+ (inherit sbcl-cl-ana-boot0)
+ (name "sbcl-cl-ana.makeres-table")
+ (inputs
+ `(("cl-ana.csv-table" ,sbcl-cl-ana.csv-table)
+ ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
+ ("cl-ana.hdf-table" ,sbcl-cl-ana.hdf-table)
+ ("cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
+ ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
+ ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
+ ("cl-ana.makeres" ,sbcl-cl-ana.makeres)
+ ("cl-ana.makeres-macro" ,sbcl-cl-ana.makeres-macro)
+ ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
+ ("cl-ana.ntuple-table" ,sbcl-cl-ana.ntuple-table)
+ ("cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
+ ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
+ ("cl-ana.table" ,sbcl-cl-ana.table)))
+ (native-inputs
+ `(("cl-fad" ,sbcl-cl-fad)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+ ((#:asd-file _ "") "makeres-table/cl-ana.makeres-table.asd")
+ ((#:asd-system-name _ #f) "cl-ana.makeres-table")))))
+
+(define-public cl-ana.makeres-table
+ (sbcl-package->cl-source-package sbcl-cl-ana.makeres-table))
+
+(define-public sbcl-cl-ana.makeres-graphviz
+ (package
+ (inherit sbcl-cl-ana-boot0)
+ (name "sbcl-cl-ana.makeres-graphviz")
+ (inputs
+ `(("cl-ana.makeres" ,sbcl-cl-ana.makeres)
+ ("external-program" ,sbcl-external-program)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+ ((#:asd-file _ "") "makeres-graphviz/cl-ana.makeres-graphviz.asd")
+ ((#:asd-system-name _ #f) "cl-ana.makeres-graphviz")))))
+
+(define-public cl-ana.makeres-graphviz
+ (sbcl-package->cl-source-package sbcl-cl-ana.makeres-graphviz))
+
+(define-public sbcl-cl-ana.makeres-branch
+ (package
+ (inherit sbcl-cl-ana-boot0)
+ (name "sbcl-cl-ana.makeres-branch")
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
+ ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
+ ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
+ ("cl-ana.map" ,sbcl-cl-ana.map)
+ ("cl-ana.makeres" ,sbcl-cl-ana.makeres)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+ ((#:asd-file _ "") "makeres-branch/cl-ana.makeres-branch.asd")
+ ((#:asd-system-name _ #f) "cl-ana.makeres-branch")))))
+
+(define-public cl-ana.makeres-branch
+ (sbcl-package->cl-source-package sbcl-cl-ana.makeres-branch))
+
+(define-public sbcl-cl-ana.makeres-utils
+ (package
+ (inherit sbcl-cl-ana-boot0)
+ (name "sbcl-cl-ana.makeres-utils")
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-ana.file-utils" ,sbcl-cl-ana.file-utils)
+ ("cl-ana.fitting" ,sbcl-cl-ana.fitting)
+ ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
+ ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
+ ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
+ ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
+ ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
+ ("cl-ana.makeres" ,sbcl-cl-ana.makeres)
+ ("cl-ana.map" ,sbcl-cl-ana.map)
+ ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
+ ("cl-ana.plotting" ,sbcl-cl-ana.plotting)
+ ("cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
+ ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
+ ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
+ ("cl-ana.table" ,sbcl-cl-ana.table)))
+ (native-inputs
+ `(("cl-fad" ,sbcl-cl-fad)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+ ((#:asd-file _ "") "makeres-utils/cl-ana.makeres-utils.asd")
+ ((#:asd-system-name _ #f) "cl-ana.makeres-utils")))))
+
+(define-public cl-ana.makeres-utils
+ (sbcl-package->cl-source-package sbcl-cl-ana.makeres-utils))
+
+(define-public sbcl-cl-ana.statistical-learning
+ (package
+ (inherit sbcl-cl-ana-boot0)
+ (name "sbcl-cl-ana.statistical-learning")
+ (inputs
+ `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
+ ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
+ ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
+ ("cl-ana.linear-algebra" ,sbcl-cl-ana.linear-algebra)
+ ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
+ ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
+ ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
+ ("cl-ana.map" ,sbcl-cl-ana.map)
+ ("cl-ana.statistics" ,sbcl-cl-ana.statistics)))
+ (native-inputs
+ `(("cl-fad" ,sbcl-cl-fad)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+ ((#:asd-file _ "")
+ "statistical-learning/cl-ana.statistical-learning.asd")
+ ((#:asd-system-name _ #f) "cl-ana.statistical-learning")))))
+
+(define-public cl-ana.statistical-learning
+ (sbcl-package->cl-source-package sbcl-cl-ana.statistical-learning))
+
+(define-public sbcl-cl-ana
+ (package
+ (inherit sbcl-cl-ana-boot0)
+ (name "sbcl-cl-ana")
+ (inputs
+ `(("cl-ana.binary-tree" ,sbcl-cl-ana.binary-tree)
+ ("cl-ana.calculus" ,sbcl-cl-ana.calculus)
+ ("cl-ana.clos-utils" ,sbcl-cl-ana.clos-utils)
+ ("cl-ana.csv-table" ,sbcl-cl-ana.csv-table)
+ ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
+ ("cl-ana.file-utils" ,sbcl-cl-ana.file-utils)
+ ("cl-ana.fitting" ,sbcl-cl-ana.fitting)
+ ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
+ ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
+ ("cl-ana.hdf-table" ,sbcl-cl-ana.hdf-table)
+ ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
+ ("cl-ana.int-char" ,sbcl-cl-ana.int-char)
+ ("cl-ana.linear-algebra" ,sbcl-cl-ana.linear-algebra)
+ ("cl-ana.lorentz" ,sbcl-cl-ana.lorentz)
+ ("cl-ana.map" ,sbcl-cl-ana.map)
+ ("cl-ana.makeres" ,sbcl-cl-ana.makeres)
+ ("cl-ana.makeres-block" ,sbcl-cl-ana.makeres-block)
+ ("cl-ana.makeres-branch" ,sbcl-cl-ana.makeres-branch)
+ ("cl-ana.makeres-graphviz" ,sbcl-cl-ana.makeres-graphviz)
+ ("cl-ana.makeres-macro" ,sbcl-cl-ana.makeres-macro)
+ ("cl-ana.makeres-progress" ,sbcl-cl-ana.makeres-progress)
+ ("cl-ana.makeres-table" ,sbcl-cl-ana.makeres-table)
+ ("cl-ana.makeres-utils" ,sbcl-cl-ana.makeres-utils)
+ ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
+ ("cl-ana.ntuple-table" ,sbcl-cl-ana.ntuple-table)
+ ("cl-ana.package-utils" ,sbcl-cl-ana.package-utils)
+ ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
+ ("cl-ana.plotting" ,sbcl-cl-ana.plotting)
+ ("cl-ana.quantity" ,sbcl-cl-ana.quantity)
+ ("cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
+ ("cl-ana.serialization" ,sbcl-cl-ana.serialization)
+ ("cl-ana.statistics" ,sbcl-cl-ana.statistics)
+ ("cl-ana.statistical-learning" ,sbcl-cl-ana.statistical-learning)
+ ("cl-ana.table" ,sbcl-cl-ana.table)
+ ("cl-ana.table-utils" ,sbcl-cl-ana.table-utils)
+ ("cl-ana.table-viewing" ,sbcl-cl-ana.table-viewing)
+ ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
+ ("libffi" ,libffi)))
+ (native-inputs
+ `(("cl-fad" ,sbcl-cl-fad)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
+ ((#:asd-file _ "") "cl-ana.asd")
+ ((#:asd-system-name _ #f) "cl-ana")))))
+
+(define-public cl-ana
+ (sbcl-package->cl-source-package sbcl-cl-ana))
+
+(define-public sbcl-archive
+ (let ((commit "631271c091ed02994bec3980cb288a2cf32c7cdc")
+ (revision "1"))
+ (package
+ (name "sbcl-archive")
+ (version (git-version "0.9" revision commit))
+ (source (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sharplispers/archive.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0pvsc9fmybx7rxd0kmzq4shi6hszdpwdc1sfy7jwyfxf8n3hnv4p"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("cl-fad" ,sbcl-cl-fad)
+ ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
+ (synopsis "Common Lisp library for tar and cpio archives")
+ (description
+ "This is a Common Lisp library to read and write disk-based file
+archives such as those generated by the tar and cpio programs on Unix.")
+ (home-page "https://github.com/sharplispers/archive")
+ (license license:bsd-3))))
+
+(define-public cl-archive
+ (sbcl-package->cl-source-package sbcl-archive))
+
+(define-public ecl-archive
+ (sbcl-package->ecl-package sbcl-archive))
+
+(define-public sbcl-misc-extensions
+ (let ((commit "101c05112bf2f1e1bbf527396822d2f50ca6327a")
+ (revision "1"))
+ (package
+ (name "sbcl-misc-extensions")
+ (version (git-version "3.3" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://gitlab.common-lisp.net/misc-extensions/devel.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0gz5f4p70qzilnxsnf5lih2n9m4wjcw8hlw4w8mpn9jyhyppyyv0"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Collection of small macros and extensions for Common Lisp")
+ (description
+ "This project is intended as a catchall for small, general-purpose
+extensions to Common Lisp. It contains:
+
+@itemize
+@item @code{new-let}, a macro that combines and generalizes @code{let},
+@code{let*} and @code{multiple-value-bind},
+@item @code{gmap}, an iteration macro that generalizes @code{map}.
+@end itemize\n")
+ (home-page "https://common-lisp.net/project/misc-extensions/")
+ (license license:public-domain))))
+
+(define-public cl-misc-extensions
+ (sbcl-package->cl-source-package sbcl-misc-extensions))
+
+(define-public ecl-misc-extensions
+ (sbcl-package->ecl-package sbcl-misc-extensions))
+
+(define-public sbcl-mt19937
+ (package
+ (name "sbcl-mt19937")
+ (version "1.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://common-lisp.net/project/asdf-packaging/"
+ "mt19937-latest.tar.gz"))
+ (sha256
+ (base32
+ "1iw636b0iw5ygkv02y8i41lh7xj0acglv0hg5agryn0zzi2nf1xv"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Mersenne Twister pseudo-random number generator")
+ (description
+ "MT19937 is a portable Mersenne Twister pseudo-random number generator
+for Common Lisp.")
+ (home-page "https://www.cliki.net/mt19937")
+ (license license:public-domain)))
+
+(define-public cl-mt19937
+ (sbcl-package->cl-source-package sbcl-mt19937))
+
+(define-public ecl-mt19937
+ (sbcl-package->ecl-package sbcl-mt19937))
+
+(define-public sbcl-fset
+ (let ((commit "6d2f9ded8934d2b42f2571a0ba5bda091037d852")
+ (revision "1"))
+ (package
+ (name "sbcl-fset")
+ (version (git-version "1.3.2" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/slburson/fset")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "127acblwrbqicx47h6sgvknz1cqyfn8p4xkhkn1m7hxh8w5gk1zy"))
+ (snippet '(begin
+ ;; Remove obsolete copy of system definition.
+ (delete-file "Code/fset.asd")
+ #t))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("misc-extensions" ,sbcl-misc-extensions)
+ ("mt19937" ,sbcl-mt19937)
+ ("named-readtables" ,sbcl-named-readtables)))
+ (synopsis "Functional set-theoretic collections library")
+ (description
+ "FSet is a functional set-theoretic collections library for Common Lisp.
+Functional means that all update operations return a new collection rather than
+modifying an existing one in place. Set-theoretic means that collections may
+be nested arbitrarily with no additional programmer effort; for instance, sets
+may contain sets, maps may be keyed by sets, etc.")
+ (home-page "https://common-lisp.net/project/fset/Site/index.html")
+ (license license:llgpl))))
+
+(define-public cl-fset
+ (sbcl-package->cl-source-package sbcl-fset))
+
+(define-public sbcl-cl-cont
+ (let ((commit "fc1fa7e6eb64894fdca13e688e6015fad5290d2a")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-cont")
+ (version (git-version "0.3.8" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://gitlab.common-lisp.net/cl-cont/cl-cont.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1zf8zvb0i6jm3hhfks4w74hibm6avgc6f9s1qwgjrn2bcik8lrvz"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("closer-mop" ,sbcl-closer-mop)))
+ (native-inputs
+ `(("rt" ,sbcl-rt)))
+ (synopsis "Delimited continuations for Common Lisp")
+ (description
+ "This is a library that implements delimited continuations by
+transforming Common Lisp code to continuation passing style.")
+ (home-page "https://common-lisp.net/project/cl-cont/")
+ (license license:llgpl))))
+
+(define-public cl-cont
+ (sbcl-package->cl-source-package sbcl-cl-cont))
+
+(define-public ecl-cl-cont
+ (sbcl-package->ecl-package sbcl-cl-cont))
+
+(define-public sbcl-cl-coroutine
+ (let ((commit "de098f8d5debd8b14ef6864b5bdcbbf5ddbcfd72")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-coroutine")
+ (version (git-version "0.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/takagi/cl-coroutine.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1cqdhdjxffgfs116l1swjlsmcbly0xgcgrckvaajd566idj9yj4l"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-cont" ,sbcl-cl-cont)))
+ (native-inputs
+ `(("prove" ,sbcl-prove)))
+ (arguments
+ `(;; TODO: Fix the tests. They fail with:
+ ;; "Component CL-COROUTINE-ASD::CL-COROUTINE-TEST not found"
+ #:tests? #f
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-tests
+ (lambda _
+ (substitute* "cl-coroutine-test.asd"
+ (("cl-test-more")
+ "prove"))
+ #t)))))
+ (synopsis "Coroutine library for Common Lisp")
+ (description
+ "This is a coroutine library for Common Lisp implemented using the
+continuations of the @code{cl-cont} library.")
+ (home-page "https://github.com/takagi/cl-coroutine")
+ (license license:llgpl))))
+
+(define-public cl-coroutine
+ (sbcl-package->cl-source-package sbcl-cl-coroutine))
+
+(define-public ecl-cl-coroutine
+ (sbcl-package->ecl-package sbcl-cl-coroutine))
+
+(define-public sbcl-vom
+ (let ((commit "1aeafeb5b74c53741b79497e0ef4acf85c92ff24")
+ (revision "1"))
+ (package
+ (name "sbcl-vom")
+ (version (git-version "0.1.4" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/orthecreedence/vom.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0536kppj76ax4lrxhv42npkfjsmx45km2g439vf9jmw3apinz9cy"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Tiny logging utility for Common Lisp")
+ (description
+ "Vom is a logging library for Common Lisp. It's goal is to be useful
+and small. It does not provide a lot of features as other loggers do, but
+has a small codebase that's easy to understand and use.")
+ (home-page "https://github.com/orthecreedence/vom")
+ (license license:expat))))
+
+(define-public cl-vom
+ (sbcl-package->cl-source-package sbcl-vom))
+
+(define-public ecl-vom
+ (sbcl-package->ecl-package sbcl-vom))
+
+(define-public sbcl-cl-libuv
+ (let ((commit "32100c023c518038d0670a103eaa4d50dd785d29")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-libuv")
+ (version (git-version "0.1.6" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/orthecreedence/cl-libuv.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1kwix4si8a8hza34ab2k7whrh7z0yrmx39v2wc3qblv9m244jkh1"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cffi" ,sbcl-cffi)
+ ("cffi-grovel" ,sbcl-cffi-grovel)
+ ("libuv" ,libuv)))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "lib.lisp"
+ (("/usr/lib/libuv.so")
+ (string-append (assoc-ref inputs "libuv")
+ "/lib/libuv.so")))
+ #t))
+ (add-after 'fix-paths 'fix-system-definition
+ (lambda _
+ (substitute* "cl-libuv.asd"
+ (("#:cffi #:alexandria")
+ "#:cffi #:cffi-grovel #:alexandria"))
+ #t)))))
+ (synopsis "Common Lisp bindings to libuv")
+ (description
+ "This library provides low-level libuv bindings for Common Lisp.")
+ (home-page "https://github.com/orthecreedence/cl-libuv")
+ (license license:expat))))
+
+(define-public cl-libuv
+ (sbcl-package->cl-source-package sbcl-cl-libuv))
+
+(define-public ecl-cl-libuv
+ (sbcl-package->ecl-package sbcl-cl-libuv))
+
+(define-public sbcl-cl-async-base
+ (let ((commit "f6423e44404a44434d803605e0d2e17199158e28")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-async-base")
+ (version (git-version "0.6.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/orthecreedence/cl-async.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "11xi9dxb8mjgwzrkj88i0xkgk26z9w9ddxzbv6xsvfc1d4x5cf4x"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("cffi" ,sbcl-cffi)
+ ("cl-libuv" ,sbcl-cl-libuv)))
+ (arguments
+ `(#:asd-file "cl-async.asd"))
+ (synopsis "Base system for cl-async")
+ (description
+ "Cl-async is a library for general purpose, non-blocking programming in
+Common Lisp. It uses the libuv library as backend.")
+ (home-page "https://orthecreedence.github.io/cl-async/")
+ (license license:expat))))
+
+(define-public cl-async-base
+ (sbcl-package->cl-source-package sbcl-cl-async-base))
+
+(define-public ecl-cl-async-base
+ (sbcl-package->ecl-package sbcl-cl-async-base))
+
+(define-public sbcl-cl-async-util
+ (package
+ (inherit sbcl-cl-async-base)
+ (name "sbcl-cl-async-util")
+ (inputs
+ `(("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("cffi" ,sbcl-cffi)
+ ("cl-async-base" ,sbcl-cl-async-base)
+ ("cl-libuv" ,sbcl-cl-libuv)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("fast-io" ,sbcl-fast-io)
+ ("vom" ,sbcl-vom)))
+ (synopsis "Internal utilities for cl-async")))
+
+(define-public cl-async-util
+ (sbcl-package->cl-source-package sbcl-cl-async-util))
+
+(define-public ecl-cl-async-util
+ (sbcl-package->ecl-package sbcl-cl-async-util))
+
+(define-public sbcl-cl-async
+ (package
+ (inherit sbcl-cl-async-base)
+ (name "sbcl-cl-async")
+ (inputs
+ `(("babel" ,sbcl-babel)
+ ("cffi" ,sbcl-cffi)
+ ("cl-async-base" ,sbcl-cl-async-base)
+ ("cl-async-util" ,sbcl-cl-async-util)
+ ("cl-libuv" ,sbcl-cl-libuv)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("static-vectors" ,sbcl-static-vectors)
+ ("trivial-features" ,sbcl-trivial-features)
+ ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
+ (synopsis "Asynchronous operations for Common Lisp")))
+
+(define-public cl-async
+ (sbcl-package->cl-source-package sbcl-cl-async))
+
+(define-public ecl-cl-async
+ (sbcl-package->ecl-package sbcl-cl-async))
+
+(define-public sbcl-cl-async-repl
+ (package
+ (inherit sbcl-cl-async-base)
+ (name "sbcl-cl-async-repl")
+ (inputs
+ `(("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("cl-async" ,sbcl-cl-async)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-cl-async-base)
+ ((#:asd-file _ "") "cl-async-repl.asd")))
+ (synopsis "REPL integration for cl-async")))
+
+(define-public cl-async-repl
+ (sbcl-package->cl-source-package sbcl-cl-async-repl))
+
+(define-public ecl-cl-async-repl
+ (sbcl-package->ecl-package sbcl-cl-async-repl))
+
+(define-public sbcl-cl-async-ssl
+ (package
+ (inherit sbcl-cl-async-base)
+ (name "sbcl-cl-async-ssl")
+ (inputs
+ `(("cffi" ,sbcl-cffi)
+ ("cl-async" ,sbcl-cl-async)
+ ("openssl" ,openssl)
+ ("vom" ,sbcl-vom)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-cl-async-base)
+ ((#:asd-file _ "") "cl-async-ssl.asd")
+ ((#:phases phases '%standard-phases)
+ `(modify-phases ,phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/ssl/package.lisp"
+ (("libcrypto\\.so")
+ (string-append (assoc-ref inputs "openssl")
+ "/lib/libcrypto.so"))
+ (("libssl\\.so")
+ (string-append (assoc-ref inputs "openssl")
+ "/lib/libssl.so")))
+ #t))))))
+ (synopsis "SSL wrapper around cl-async socket implementation")))
+
+(define-public cl-async-ssl
+ (sbcl-package->cl-source-package sbcl-cl-async-ssl))
+
+(define-public ecl-cl-async-ssl
+ (sbcl-package->ecl-package sbcl-cl-async-ssl))
+
+(define-public sbcl-blackbird
+ (let ((commit "d361f81c1411dec07f6c2dcb11c78f7aea9aaca8")
+ (revision "1"))
+ (package
+ (name "sbcl-blackbird")
+ (version (git-version "0.5.2" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/orthecreedence/blackbird.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0xfds5yaya64arzr7w1x38karyz11swzbhxx1afldpradj9dh19c"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("vom" ,sbcl-vom)))
+ (native-inputs
+ `(("cl-async" ,sbcl-cl-async)
+ ("fiveam" ,sbcl-fiveam)))
+ (synopsis "Promise implementation for Common Lisp")
+ (description
+ "This is a standalone promise implementation for Common Lisp. It is
+the successor to the now-deprecated cl-async-future project.")
+ (home-page "http://orthecreedence.github.io/blackbird/")
+ (license license:expat))))
+
+(define-public cl-blackbird
+ (sbcl-package->cl-source-package sbcl-blackbird))
+
+(define-public ecl-blackbird
+ (sbcl-package->ecl-package sbcl-blackbird))
+
+(define-public sbcl-cl-async-future
+ (let ((commit "ee36c22a69a9516407458d2ed8b475f1fc473959")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-async-future")
+ (version (git-version "0.4.4.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/orthecreedence/cl-async-future.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0z0sc7qlzzxk99f4l26zp6rai9kv0kj0f599sxai5s44p17zbbvh"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("blackbird" ,sbcl-blackbird)))
+ (native-inputs
+ `(("cl-async" ,sbcl-cl-async)
+ ("eos" ,sbcl-eos)))
+ (synopsis "Futures implementation for Common Lisp")
+ (description
+ "This is futures implementation for Common Lisp. It plugs in nicely
+to cl-async.")
+ (home-page "http://orthecreedence.github.io/cl-async/future")
+ (license license:expat))))
+
+(define-public cl-async-future
+ (sbcl-package->cl-source-package sbcl-cl-async-future))
+
+(define-public ecl-cl-async-future
+ (sbcl-package->ecl-package sbcl-cl-async-future))
+
+(define-public sbcl-green-threads
+ (let ((commit "fff5ebecb441a37e5c511773716aafd84a3c5840")
+ (revision "1"))
+ (package
+ (name "sbcl-green-threads")
+ (version (git-version "0.3" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/thezerobit/green-threads.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1czw7nr0dwfps76h8hjvglk1wdh53yqbfbvv30whwbgqx33iippz"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("cl-async-future" ,sbcl-cl-async-future)
+ ("cl-cont" ,sbcl-cl-cont)))
+ (native-inputs
+ `(("prove" ,sbcl-prove)))
+ (arguments
+ `(;; TODO: Fix the tests. They fail with:
+ ;; "The function BLACKBIRD::PROMISE-VALUES is undefined"
+ #:tests? #f
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-tests
+ (lambda _
+ (substitute* "green-threads-test.asd"
+ (("cl-test-more")
+ "prove"))
+ #t)))))
+ (synopsis "Cooperative multitasking library for Common Lisp")
+ (description
+ "This library allows for cooperative multitasking with help of cl-cont
+for continuations. It tries to mimic the API of bordeaux-threads as much as
+possible.")
+ (home-page "https://github.com/thezerobit/green-threads")
+ (license license:bsd-3))))
+
+(define-public cl-green-threads
+ (sbcl-package->cl-source-package sbcl-green-threads))
+
+(define-public ecl-green-threads
+ (sbcl-package->ecl-package sbcl-green-threads))
+
+(define-public sbcl-cl-base32
+ (let ((commit "8cdee06fab397f7b0a19583b57e7f0c98405be85")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-base32")
+ (version (git-version "0.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/hargettp/cl-base32.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "17jrng8jb05d64ggyd11hp308c2fl5drvf9g175blgrkkl8l4mf8"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("lisp-unit" ,sbcl-lisp-unit)))
+ (synopsis "Common Lisp library for base32 encoding and decoding")
+ (description
+ "This package provides functions for base32 encoding and decoding as
+defined in RFC4648.")
+ (home-page "https://github.com/hargettp/cl-base32")
+ (license license:expat))))
+
+(define-public cl-base32
+ (sbcl-package->cl-source-package sbcl-cl-base32))
+
+(define-public ecl-cl-base32
+ (sbcl-package->ecl-package sbcl-cl-base32))
+
+(define-public sbcl-cl-z85
+ (let ((commit "85b3951a9cfa2603acb6aee15567684f9a108098")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-z85")
+ (version (git-version "1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/glv2/cl-z85.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0r27pidjaxbm7k1rr90nnajwl5xm2kp65g1fv0fva17lzy45z1mp"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("cl-octet-streams" ,sbcl-cl-octet-streams)
+ ("fiveam" ,sbcl-fiveam)))
+ (synopsis "Common Lisp library for Z85 encoding and decoding")
+ (description
+ "This package provides functions to encode or decode byte vectors or
+byte streams using the Z85 format, which is a base-85 encoding used by
+ZeroMQ.")
+ (home-page "https://github.com/glv2/cl-z85")
+ (license license:gpl3+))))
+
+(define-public cl-z85
+ (sbcl-package->cl-source-package sbcl-cl-z85))
+
+(define-public ecl-cl-z85
+ (sbcl-package->ecl-package sbcl-cl-z85))
+
+(define-public sbcl-ltk
+ (package
+ (name "sbcl-ltk")
+ (version "0.992")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/herth/ltk.git")
+ (commit version)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "13l2q4mskzilya9xh5wy2xvy30lwn104bd8wrq6ifds56r82iy3x"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("imagemagick" ,imagemagick)
+ ("tk" ,tk)))
+ (arguments
+ `(#:asd-file "ltk/ltk.asd"
+ #:tests? #f
+ #:phases (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "ltk/ltk.lisp"
+ (("#-freebsd \"wish\"")
+ (string-append "#-freebsd \""
+ (assoc-ref inputs "tk")
+ "/bin/wish\""))
+ (("do-execute \"convert\"")
+ (string-append "do-execute \""
+ (assoc-ref inputs "imagemagick")
+ "/bin/convert\"")))
+ #t)))))
+ (synopsis "Common Lisp bindings for the Tk GUI toolkit")
+ (description
+ "LTK is a Common Lisp binding for the Tk graphics toolkit. It is written
+in pure Common Lisp and does not require any Tk knowledge for its usage.")
+ (home-page "http://www.peter-herth.de/ltk/")
+ (license license:llgpl)))
+
+(define-public cl-ltk
+ (sbcl-package->cl-source-package sbcl-ltk))
+
+(define-public ecl-ltk
+ (sbcl-package->ecl-package sbcl-ltk))
+
+(define-public sbcl-ltk-mw
+ (package
+ (inherit sbcl-ltk)
+ (name "sbcl-ltk-mw")
+ (inputs
+ `(("ltk" ,sbcl-ltk)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-ltk)
+ ((#:asd-file _) "ltk/ltk-mw.asd")
+ ((#:phases _) '%standard-phases)))
+ (synopsis "Extra widgets for LTK")
+ (description
+ "This is a collection of higher-level widgets built on top of LTK.")))
+
+(define-public cl-ltk-mw
+ (sbcl-package->cl-source-package sbcl-ltk-mw))
+
+(define-public ecl-ltk-mw
+ (sbcl-package->ecl-package sbcl-ltk-mw))
+
+(define-public sbcl-ltk-remote
+ (package
+ (inherit sbcl-ltk)
+ (name "sbcl-ltk-remote")
+ (inputs
+ `(("ltk" ,sbcl-ltk)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-ltk)
+ ((#:asd-file _) "ltk/ltk-remote.asd")
+ ((#:phases _) '%standard-phases)))
+ (synopsis "Remote GUI support for LTK")
+ (description
+ "This LTK extension allows the GUI to be displayed on a computer different
+from the one running the Lisp program by using a TCP connection.")))
+
+(define-public cl-ltk-remote
+ (sbcl-package->cl-source-package sbcl-ltk-remote))
+
+(define-public sbcl-cl-lex
+ (let ((commit "f2dbbe25ef553005fb402d9a6203180c3fa1093b")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-lex")
+ (version (git-version "1.1.3" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/djr7C4/cl-lex.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1kg50f76bfpfxcv4dfivq1n9a0xlsra2ajb0vd68lxwgbidgyc2y"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("cl-ppcre" ,sbcl-cl-ppcre)))
+ (synopsis "Common Lisp macros for generating lexical analyzers")
+ (description
+ "This is a Common Lisp library providing a set of macros for generating
+lexical analyzers automatically. The lexers generated using @code{cl-lex} can
+be used with @code{cl-yacc}.")
+ (home-page "https://github.com/djr7C4/cl-lex")
+ (license license:gpl3))))
+
+(define-public cl-lex
+ (sbcl-package->cl-source-package sbcl-cl-lex))
+
+(define-public ecl-cl-lex
+ (sbcl-package->ecl-package sbcl-cl-lex))
+
+(define-public sbcl-clunit2
+ (let ((commit "5e28343734eb9b7aee39306a614af92c1062d50b")
+ (revision "1"))
+ (package
+ (name "sbcl-clunit2")
+ (version (git-version "0.2.4" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://notabug.org/cage/clunit2.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1ngiapfki6nm8a555mzhb5p7ch79i3w665za5bmb5j7q34fy80vw"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Unit testing framework for Common Lisp")
+ (description
+ "CLUnit is a Common Lisp unit testing framework. It is designed to be
+easy to use so that you can quickly start testing.")
+ (home-page "https://notabug.org/cage/clunit2")
+ (license license:expat))))
+
+(define-public cl-clunit2
+ (sbcl-package->cl-source-package sbcl-clunit2))
+
+(define-public ecl-clunit2
+ (sbcl-package->ecl-package sbcl-clunit2))
+
+(define-public sbcl-cl-colors2
+ (let ((commit "795aedee593b095fecde574bd999b520dd03ed24")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-colors2")
+ (version (git-version "0.2.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://notabug.org/cage/cl-colors2.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0hlyf4h5chkjdp9armla5w4kw5acikk159sym7y8c4jbjp9x47ih"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("clunit2" ,sbcl-clunit2)))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-ppcre" ,sbcl-cl-ppcre)))
+ (synopsis "Color library for Common Lisp")
+ (description
+ "This is a very simple color library for Common Lisp, providing:
+
+@itemize
+@item Types for representing colors in HSV and RGB spaces.
+@item Simple conversion functions between the above types (and also
+hexadecimal representation for RGB).
+@item Some predefined colors (currently X11 color names -- of course
+the library does not depend on X11).
+@end itemize\n")
+ (home-page "https://notabug.org/cage/cl-colors2")
+ (license license:boost1.0))))
+
+(define-public cl-colors2
+ (sbcl-package->cl-source-package sbcl-cl-colors2))
+
+(define-public ecl-cl-colors2
+ (sbcl-package->ecl-package sbcl-cl-colors2))
+
+(define-public sbcl-cl-jpeg
+ (let ((commit "ec557038128df6895fbfb743bfe8faf8ec2534af")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-jpeg")
+ (version (git-version "2.8" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sharplispers/cl-jpeg.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1bkkiqz8fqldlj1wbmrccjsvxcwj98h6s4b6gslr3cg2wmdv5xmy"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "JPEG image library for Common Lisp")
+ (description
+ "This is a baseline JPEG codec written in Common Lisp. It can be used
+for reading and writing JPEG image files.")
+ (home-page "https://github.com/sharplispers/cl-jpeg")
+ (license license:bsd-3))))
+
+(define-public cl-jpeg
+ (sbcl-package->cl-source-package sbcl-cl-jpeg))
+
+(define-public ecl-cl-jpeg
+ (sbcl-package->ecl-package sbcl-cl-jpeg))
+
+(define-public sbcl-nodgui
+ (let ((commit "bc59ed9b787dfc9e68ae3bd7f7e8507c5c619212")
+ (revision "1"))
+ (package
+ (name "sbcl-nodgui")
+ (version (git-version "0.0.5" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://notabug.org/cage/nodgui.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0xx0dk54d882i598ydnwmy7mnfk0b7vib3ddsgpqxhjck1rwq8l8"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("cl-colors2" ,sbcl-cl-colors2)
+ ("cl-jpeg" ,sbcl-cl-jpeg)
+ ("cl-lex" ,sbcl-cl-lex)
+ ("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)
+ ("cl-unicode" ,sbcl-cl-unicode)
+ ("cl-yacc" ,sbcl-cl-yacc)
+ ("clunit2" ,sbcl-clunit2)
+ ("named-readtables" ,sbcl-named-readtables)
+ ("parse-number" ,sbcl-parse-number)
+ ("tk" ,tk)))
+ (arguments
+ `(#:phases (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/wish-communication.lisp"
+ (("#-freebsd \"wish\"")
+ (string-append "#-freebsd \""
+ (assoc-ref inputs "tk")
+ "/bin/wish\"")))
+ #t)))))
+ (synopsis "Common Lisp bindings for the Tk GUI toolkit")
+ (description
+ "Nodgui (@emph{No Drama GUI}) is a Common Lisp binding for the Tk GUI
+toolkit. It also provides a few additional widgets more than the standard Tk
+ones.")
+ (home-page "https://www.autistici.org/interzona/nodgui.html")
+ (license license:llgpl))))
+
+(define-public cl-nodgui
+ (sbcl-package->cl-source-package sbcl-nodgui))
+
+(define-public ecl-nodgui
+ (sbcl-package->ecl-package sbcl-nodgui))
+
+(define-public sbcl-salza2
+ (package
+ (name "sbcl-salza2")
+ (version "2.0.9")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/xach/salza2.git")
+ (commit (string-append "release-" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0p38rj4gq7j5k807php7hrz7l2zyyfshv8i9yms7i8lkgg3433ki"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Common Lisp library for zlib, deflate and gzip compression")
+ (description
+ "Salza2 is a Common Lisp library for creating compressed data in the zlib,
+deflate, or gzip data formats, described in RFC 1950, RFC 1951, and RFC 1952,
+respectively.")
+ (home-page "https://www.xach.com/lisp/salza2/")
+ (license license:bsd-2)))
+
+(define-public cl-salza2
+ (sbcl-package->cl-source-package sbcl-salza2))
+
+(define-public ecl-salza2
+ (sbcl-package->ecl-package sbcl-salza2))
+
+(define-public sbcl-png-read
+ (let ((commit "ec29f38a689972b9f1373f13bbbcd6b05deada88")
+ (revision "1"))
+ (package
+ (name "sbcl-png-read")
+ (version (git-version "0.3.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Ramarren/png-read.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0vyczbcwskrygrf1hgrsnk0jil8skmvf1kiaalw5jps4fjrfdkw0"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("babel" ,sbcl-babel)
+ ("chipz" ,sbcl-chipz)
+ ("iterate" ,sbcl-iterate)))
+ (synopsis "PNG decoder for Common Lisp")
+ (description "This is a Common Lisp library for reading PNG images.")
+ (home-page "https://github.com/Ramarren/png-read")
+ (license license:bsd-3))))
+
+(define-public cl-png-read
+ (sbcl-package->cl-source-package sbcl-png-read))
+
+(define-public ecl-png-read
+ (sbcl-package->ecl-package sbcl-png-read))
+
+(define-public sbcl-zpng
+ (package
+ (name "sbcl-zpng")
+ (version "1.2.2")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/xach/zpng.git")
+ (commit (string-append "release-" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0b3ag3jhl3z7kdls3ahdsdxsfhhw5qrizk769984f4wkxhb69rcm"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("salza2" ,sbcl-salza2)))
+ (synopsis "PNG encoder for Common Lisp")
+ (description "This is a Common Lisp library for creating PNG images.")
+ (home-page "https://www.xach.com/lisp/zpng/")
+ (license license:bsd-2)))
+
+(define-public cl-zpng
+ (sbcl-package->cl-source-package sbcl-zpng))
+
+(define-public ecl-zpng
+ (sbcl-package->ecl-package sbcl-zpng))
+
+(define-public sbcl-cl-qrencode
+ (package
+ (name "sbcl-cl-qrencode")
+ (version "0.1.2")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/jnjcc/cl-qrencode.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1l5k131dchbf6cj8a8xqa731790p01p3qa1kdy2wa9dawy3ymkxr"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("lisp-unit" ,sbcl-lisp-unit)))
+ (inputs
+ `(("zpng" ,sbcl-zpng)))
+ (synopsis "QR code encoder for Common Lisp")
+ (description
+ "This Common Lisp library provides function to make QR codes and to save
+them as PNG files.")
+ (home-page "https://github.com/jnjcc/cl-qrencode")
+ (license license:gpl2+)))
+
+(define-public cl-qrencode
+ (sbcl-package->cl-source-package sbcl-cl-qrencode))
+
+(define-public ecl-cl-qrencode
+ (sbcl-package->ecl-package sbcl-cl-qrencode))