;;; Copyright © 2018 Benjamin Slade <slade@jnanam.net>
;;; Copyright © 2018 Alex Vong <alexvong1995@gmail.com>
;;; Copyright © 2018 Pierre Neidhardt <mail@ambrevar.xyz>
-;;; Copyright © 2018 Pierre Langlois <pierre.langlois@gmx.com>
+;;; Copyright © 2018, 2019 Pierre Langlois <pierre.langlois@gmx.com>
;;; Copyright © 2019 Katherine Cox-Buday <cox.katherine.e@gmail.com>
+;;; Copyright © 2019 Jesse Gildersleve <jessejohngildersleve@protonmail.com>
+;;; Copyright © 2019 Guillaume Le Vaillant <glv@posteo.net>
;;;
;;; This file is part of GNU Guix.
;;;
#:use-module (gnu packages admin)
#:use-module (gnu packages base)
#:use-module (gnu packages bdw-gc)
+ #:use-module (gnu packages bison)
+ #:use-module (gnu packages c)
#:use-module (gnu packages compression)
#:use-module (gnu packages ed)
+ #:use-module (gnu packages flex)
#:use-module (gnu packages fontutils)
#:use-module (gnu packages gcc)
#:use-module (gnu packages gettext)
#:use-module (gnu packages linux)
#:use-module (gnu packages perl)
#:use-module (gnu packages pkg-config)
+ #:use-module (gnu packages python)
+ #:use-module (gnu packages python-xyz)
#:use-module (gnu packages readline)
#:use-module (gnu packages sdl)
#:use-module (gnu packages sqlite)
(version "1.2")
(source
(origin
- (method url-fetch)
- (uri (string-append
- "https://github.com/sionescu/fiveam/archive/v"
- version ".tar.gz"))
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sionescu/fiveam.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "fiveam" version))
(sha256
- (base32 "0f48pcbhqs3wwwzjl5nk57d4hcbib4l9xblxc66b8c2fhvhmhxnv"))
- (file-name (string-append "fiveam-" version ".tar.gz"))))
+ (base32 "1yx9716mk8pq9076q6cjx4c9lyax3amiccy37sh0913k2x8gsm4l"))))
(inputs `(("alexandria" ,sbcl-alexandria)))
(build-system asdf-build-system/sbcl)
(synopsis "Common Lisp testing framework")
(sbcl-package->ecl-package sbcl-fiveam))
(define-public sbcl-bordeaux-threads
- (let ((commit "354abb0ae9f1d9324001e1a8abab3128d7420e0e")
+ (let ((commit "5dce49fbc829f4d136a734f5ef4f5d599660984f")
(revision "1"))
(package
(name "sbcl-bordeaux-threads")
- (version (git-version "0.8.5" revision commit))
+ (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 "1hcfp21l6av1xj6z7r77sp6h4mwf9vvx4s745803sysq2qy2mwnq"))
+ (base32 "1gkh9rz7zw57n3110ikcf4835950wr4hgp8l79id5ai6nd86x7wv"))
(file-name
(git-file-name "bordeaux-threads" version))))
(inputs `(("alexandria" ,sbcl-alexandria)))
(version "1.0.16")
(source
(origin
- (method url-fetch)
- (uri (string-append
- "https://github.com/edicl/flexi-streams/archive/v"
- version ".tar.gz"))
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/edicl/flexi-streams.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "flexi-streams" version))
(sha256
- (base32 "1fb0jrwxr5c3i2lhy7kn30m1n0vggfzwjm1dacx6y5wf9wfsbamw"))
- (file-name (string-append "flexi-streams-" version ".tar.gz"))))
+ (base32 "0gvykjlmja060zqq6nn6aqxlshh6r6ijahmmgf20q0d839rwpgxc"))))
(build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'make-git-checkout-writable
+ (lambda _
+ (for-each make-file-writable (find-files "."))
+ #t)))))
(inputs `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
(synopsis "Implementation of virtual bivalent streams for Common Lisp")
(description "Flexi-streams is an implementation of \"virtual\" bivalent
(version "2.0.11")
(source
(origin
- (method url-fetch)
- (uri (string-append
- "https://github.com/edicl/cl-ppcre/archive/v"
- version ".tar.gz"))
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/edicl/cl-ppcre.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-ppcre" version))
(sha256
- (base32 "1i7daxf0wnydb0pgwiym7qh2wy70n14lxd6dyv28sy0naa8p31gd"))
- (file-name (string-append "cl-ppcre-" version ".tar.gz"))))
+ (base32 "0q3iany07vgqm144lw6pj0af2d3vsikpbkwcxr30fci3kzsq4f49"))))
(build-system asdf-build-system/sbcl)
(native-inputs `(("flexi-streams" ,sbcl-flexi-streams)))
(synopsis "Portable regular expression library for Common Lisp")
(sbcl-package->cl-source-package sbcl-cl-unicode))
(define-public sbcl-clx
- (let ((revision "1")
- (commit "1c62774b03c1cf3fe6e5cb532df8b14b44c96b95"))
- (package
- (name "sbcl-clx")
- (version (string-append "0.0.0-" revision "." (string-take commit 7)))
- (source
- (origin
- (method git-fetch)
- (uri
- (git-reference
- (url "https://github.com/sharplispers/clx.git")
- (commit commit)))
- (sha256
- (base32 "0qffag03ns52kwq9xjns2qg1yr0bf3ba507iwq5cmx5xz0b0rmjm"))
- (file-name (string-append "clx-" version "-checkout"))
- (patches
- (list
- (search-patch "clx-remove-demo.patch")))
- (modules '((guix build utils)))
- (snippet
- '(begin
- ;; These removed files cause the compiled system to crash when
- ;; loading.
- (delete-file-recursively "demo")
- (delete-file "test/trapezoid.lisp")
- (substitute* "clx.asd"
- (("\\(:file \"trapezoid\"\\)") ""))
- #t))))
- (build-system asdf-build-system/sbcl)
- (home-page "http://www.cliki.net/portable-clx")
- (synopsis "X11 client library for Common Lisp")
- (description "CLX is an X11 client library for Common Lisp. The code was
+ (package
+ (name "sbcl-clx")
+ (version "0.7.5")
+ (source
+ (origin
+ (method git-fetch)
+ (uri
+ (git-reference
+ (url "https://github.com/sharplispers/clx.git")
+ (commit version)))
+ (sha256
+ (base32
+ "1vi67z9hpj5rr4xcmfbfwzmlcc0ah7hzhrmfid6lqdkva238v2wf"))
+ (file-name (string-append "clx-" version))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("fiasco" ,sbcl-fiasco)))
+ (home-page "http://www.cliki.net/portable-clx")
+ (synopsis "X11 client library for Common Lisp")
+ (description "CLX is an X11 client library for Common Lisp. The code was
originally taken from a CMUCL distribution, was modified somewhat in order to
make it compile and run under SBCL, then a selection of patches were added
from other CLXes around the net.")
- (license license:x11))))
+ (license license:x11)))
(define-public cl-clx
(sbcl-package->cl-source-package sbcl-clx))
(package
(name "stumpwm")
(version "18.11")
- (source (origin
- (method url-fetch)
- (uri (string-append
- "https://github.com/stumpwm/stumpwm/archive/"
- version ".tar.gz"))
- (sha256
- (base32 "177gxfk4c127i9crghx6fmkipznhgylvzgnjb2pna38g21gg6s39"))
- (file-name (string-append "stumpwm-" version ".tar.gz"))
- (patches
- ;; This patch is included in the post-18.11 git master tree
- ;; and can be removed when we move to the next release.
- (search-patches "stumpwm-fix-broken-read-one-line.patch"))))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/stumpwm/stumpwm.git")
+ (commit version)))
+ (file-name (git-file-name "stumpwm" version))
+ (sha256
+ (base32 "003g1fmh7446ws49866kzny4lrk1wf034dq5fa4m9mq1nzc7cwv7"))
+ (patches
+ ;; This patch is included in the post-18.11 git master tree
+ ;; and can be removed when we move to the next release.
+ (search-patches "stumpwm-fix-broken-read-one-line.patch"))))
(build-system asdf-build-system/sbcl)
(native-inputs `(("fiasco" ,sbcl-fiasco)
("texinfo" ,texinfo)))
(version "0.8")
(source
(origin
- (method url-fetch)
- (uri (string-append
- "https://github.com/trivial-features/trivial-features/archive/v"
- version ".tar.gz"))
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/trivial-features/trivial-features.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "trivial-features" version))
(sha256
- (base32 "0db1awn6jyhcfhyfvpjvfziprmq85cigf19mwbvaprhblydsag3c"))
- (file-name (string-append "trivial-features-" version ".tar.gz"))))
+ (base32 "0ccv7dqyrk55xga78i5vzlic7mdwp28in3g1a8fqhlk6626scsq9"))))
(build-system asdf-build-system/sbcl)
(arguments '(#:tests? #f))
(home-page "http://cliki.net/trivial-features")
(version "0.5.0")
(source
(origin
- (method url-fetch)
- (uri (string-append
- "https://github.com/cl-babel/babel/archive/v"
- version ".tar.gz"))
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/cl-babel/babel.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "babel" version))
(sha256
- (base32 "189kgbmslh36xx0d2i1g6a7mcvjryvjzkdlnhilqy5xs7hkyqirq"))
- (file-name (string-append name "-" version ".tar.gz"))))
+ (base32 "139a8rn2gnhj082n8jg01gc8fyr63hkj57hgrnmb3d1r327yc77f"))))
(build-system asdf-build-system/sbcl)
(native-inputs
`(("tests:cl-hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
(version "0.19.0")
(source
(origin
- (method url-fetch)
- (uri (string-append "https://github.com/cffi/cffi/archive/v"
- version ".tar.gz"))
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/cffi/cffi.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cffi-bootstrap" version))
(sha256
- (base32 "07bc3c1fbfx17wgrvx6bh9byilfzfwv5n597cfdllm0vzwvbmiyk"))
- (file-name (string-append name "-" version ".tar.gz"))))
+ (base32 "09sfgc6r7ihmbkwfpvkq5fxc7h45cabpvgbvs47i5cvnmv3k72xy"))))
(build-system asdf-build-system/sbcl)
(inputs
`(("libffi" ,libffi)
(version "0.21")
(source
(origin
- (method url-fetch)
- (uri (string-append
- "https://github.com/trivial-garbage/trivial-garbage/archive/v"
- version ".tar.gz"))
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/trivial-garbage/trivial-garbage.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "trivial-garbage" version))
(sha256
- (base32 "0b244nlszkrqawsnp568clnx32xmvjmbbagbz7625w9n0yq7396y"))
- (file-name (string-append "trivial-garbage-" version ".tar.gz"))))
+ (base32 "0122jicfg7pca1wxw8zak1n92h5friqy60988ns0ysksj3fphw9n"))))
(build-system asdf-build-system/sbcl)
(native-inputs
`(("rt" ,sbcl-rt)))
(uri (git-reference
(url "https://github.com/gwkkwg/trivial-backtrace.git")
(commit commit)))
+ (file-name (git-file-name "trivial-backtrace" version))
(sha256
(base32 "10p41p43skj6cimdg8skjy7372s8v2xpkg8djjy0l8rm45i654k1"))))
(build-system asdf-build-system/sbcl)
display, how to display it, and what sort of arguments can be used to
customize it. @code{trivial-backtrace} is a simple solution to generating a
backtrace portably.")
- (license license:bsd-style))))
+ (license license:expat))))
(define-public cl-trivial-backtrace
(sbcl-package->cl-source-package sbcl-trivial-backtrace))
(uri (git-reference
(url "https://github.com/jdz/rfc2388.git")
(commit commit)))
+ (file-name (git-file-name "rfc2388" version))
(sha256
(base32 "0phh5n3clhl9ji8jaxrajidn22d3f0aq87mlbfkkxlnx2pnw694k"))))
(build-system asdf-build-system/sbcl)
(uri (git-reference
(url "https://github.com/cl-plus-ssl/cl-plus-ssl.git")
(commit commit)))
+ (file-name (git-file-name "cl+ssl" version))
(sha256
(base32 "1845i1pafmqb6cdlr53yaqy67kjrhkvbx6c37ca15cw70vhdr3z9"))))
(build-system asdf-build-system/sbcl)
(uri (git-reference
(url "http://git.kpe.io/cl-base64.git")
(commit (string-append "v" version))))
+ (file-name (git-file-name "cl-base64" version))
(sha256
(base32 "1dw6j7n6gsd2qa0p0rbsjxj00acxx3i9ca1qkgl0liy8lpnwkypl"))))
(build-system asdf-build-system/sbcl)
(version "1.2.38")
(source
(origin
- (method url-fetch)
- (uri (string-append
- "https://github.com/edicl/hunchentoot/archive/v"
- version ".tar.gz"))
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/edicl/hunchentoot.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "hunchentoot" version))
(sha256
- (base32 "17z8rpd6b5w93jwrdwfwxjha617xnjqw8aq1hw2z76zp1fn8yrmh"))))
+ (base32 "1anpcad7w045m4rsjs1f3xdhjwx5cppq1h0vlb3q7dz81fi3i6yq"))))
(build-system asdf-build-system/sbcl)
(native-inputs
`(("sbcl-cl-who" ,sbcl-cl-who)
(uri (git-reference
(url "https://github.com/m2ym/cl-syntax.git")
(commit "03f0c329bbd55b8622c37161e6278366525e2ccc")))
+ (file-name (git-file-name "cl-syntax" version))
(sha256
(base32 "17ran8xp77asagl31xv8w819wafh6whwfc9p6dgx22ca537gyl4y"))))
(build-system asdf-build-system/sbcl)
(uri (git-reference
(url "https://github.com/fukamachi/myway.git")
(commit commit)))
+ (file-name (git-file-name "myway" version))
(sha256
(base32 "0briia9bk3lbr0frnx39d1qg6i38dm4j6z9w3yga3d40k6df4a90"))))
(build-system asdf-build-system/sbcl)
(define-public cl-local-time
(sbcl-package->cl-source-package sbcl-local-time))
+
+(define-public sbcl-lack-response
+ (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
+ (revision "1"))
+ (package
+ (name "sbcl-lack-response")
+ (version (git-version "0.1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/lack.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-file "lack-response.asd"
+ #:asd-system-name "lack-response"
+ ;; XXX: no tests for lack-response.
+ #:tests? #f))
+ (native-inputs
+ `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+ ("sbcl-prove" ,sbcl-prove)))
+ (inputs
+ `(("sbcl-quri" ,sbcl-quri)
+ ("sbcl-http-body" ,sbcl-http-body)
+ ("sbcl-circular-streams" ,sbcl-circular-streams)
+ ("sbcl-local-time" ,sbcl-local-time)))
+ (home-page "https://github.com/fukamachi/lack")
+ (synopsis "Lack, the core of Clack")
+ (description
+ "Lack is a Common Lisp library which allows web applications to be
+constructed of modular components. It was originally a part of Clack, however
+it's going to be rewritten as an individual project since Clack v2 with
+performance and simplicity in mind.")
+ (license license:llgpl))))
+
+(define-public cl-lack-response
+ (sbcl-package->cl-source-package sbcl-lack-response))
+
+(define-public sbcl-lack-component
+ (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
+ (revision "1"))
+ (package
+ (name "sbcl-lack-component")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/lack.git")
+ (commit commit)))
+ (sha256
+ (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-file "lack-component.asd"
+ #:asd-system-name "lack-component"
+ #:test-asd-file "t-lack-component.asd"
+ ;; XXX: Component :LACK-TEST not found
+ #:tests? #f))
+ (native-inputs
+ `(("prove-asdf" ,sbcl-prove-asdf)))
+ (home-page "https://github.com/fukamachi/lack")
+ (synopsis "Lack, the core of Clack")
+ (description
+ "Lack is a Common Lisp library which allows web applications to be
+constructed of modular components. It was originally a part of Clack, however
+it's going to be rewritten as an individual project since Clack v2 with
+performance and simplicity in mind.")
+ (license license:llgpl))))
+
+(define-public cl-lack-component
+ (sbcl-package->cl-source-package sbcl-lack-component))
+
+(define-public sbcl-lack-util
+ (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
+ (revision "1"))
+ (package
+ (name "sbcl-lack-util")
+ (version (git-version "0.1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/lack.git")
+ (commit commit)))
+ (sha256
+ (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-file "lack-util.asd"
+ #:asd-system-name "lack-util"
+ #:test-asd-file "t-lack-util.asd"
+ ;; XXX: Component :LACK-TEST not found
+ #:tests? #f))
+ (native-inputs
+ `(("prove-asdf" ,sbcl-prove-asdf)))
+ (inputs
+ `(("sbcl-ironclad" ,sbcl-ironclad)))
+ (home-page "https://github.com/fukamachi/lack")
+ (synopsis "Lack, the core of Clack")
+ (description
+ "Lack is a Common Lisp library which allows web applications to be
+constructed of modular components. It was originally a part of Clack, however
+it's going to be rewritten as an individual project since Clack v2 with
+performance and simplicity in mind.")
+ (license license:llgpl))))
+
+(define-public cl-lack-util
+ (sbcl-package->cl-source-package sbcl-lack-util))
+
+(define-public sbcl-lack-middleware-backtrace
+ (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
+ (revision "1"))
+ (package
+ (name "sbcl-lack-middleware-backtrace")
+ (version (git-version "0.1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/lack.git")
+ (commit commit)))
+ (sha256
+ (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-file "lack-middleware-backtrace.asd"
+ #:asd-system-name "lack-middleware-backtrace"
+ #:test-asd-file "t-lack-middleware-backtrace.asd"
+ ;; XXX: Component :LACK not found
+ #:tests? #f))
+ (native-inputs
+ `(("prove-asdf" ,sbcl-prove-asdf)))
+ (home-page "https://github.com/fukamachi/lack")
+ (synopsis "Lack, the core of Clack")
+ (description
+ "Lack is a Common Lisp library which allows web applications to be
+constructed of modular components. It was originally a part of Clack, however
+it's going to be rewritten as an individual project since Clack v2 with
+performance and simplicity in mind.")
+ (license license:llgpl))))
+
+(define-public cl-lack-middleware-backtrace
+ (sbcl-package->cl-source-package sbcl-lack-middleware-backtrace))
+
+(define-public sbcl-trivial-mimes
+ (let ((commit "303f8ac0aa6ca0bc139aa3c34822e623c3723fab")
+ (revision "1"))
+ (package
+ (name "sbcl-trivial-mimes")
+ (version (git-version "1.1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Shinmera/trivial-mimes.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "17jxgl47r695bvsb7wi3n2ws5rp1zzgvw0zii8cy5ggw4b4ayv6m"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:phases
+ (modify-phases %standard-phases
+ (add-after
+ 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (let ((anchor "#p\"/etc/mime.types\""))
+ (substitute* "mime-types.lisp"
+ ((anchor all)
+ (string-append
+ anchor "\n"
+ "(asdf:system-relative-pathname :trivial-mimes \"../../share/common-lisp/sbcl-source/trivial-mimes/mime.types\")")))))))))
+ (native-inputs
+ `(("stefil" ,sbcl-hu.dwim.stefil)))
+ (inputs
+ `(("sbcl-cl-fad" ,sbcl-cl-fad)))
+ (home-page "http://shinmera.github.io/trivial-mimes/")
+ (synopsis "Tiny Common Lisp library to detect mime types in files")
+ (description
+ "This is a teensy library that provides some functions to determine the
+mime-type of a file.")
+ (license license:artistic2.0))))
+
+(define-public cl-trivial-mimes
+ (sbcl-package->cl-source-package sbcl-trivial-mimes))
+
+(define-public sbcl-lack-middleware-static
+ (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
+ (revision "1"))
+ (package
+ (name "sbcl-lack-middleware-static")
+ (version (git-version "0.1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/lack.git")
+ (commit commit)))
+ (sha256
+ (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-file "lack-middleware-static.asd"
+ #:asd-system-name "lack-middleware-static"
+ #:test-asd-file "t-lack-middleware-static.asd"
+ ;; XXX: Component :LACK not found
+ #:tests? #f))
+ (native-inputs
+ `(("prove-asdf" ,sbcl-prove-asdf)))
+ (inputs
+ `(("sbcl-ironclad" ,sbcl-ironclad)
+ ("sbcl-trivial-mimes" ,sbcl-trivial-mimes)
+ ("sbcl-local-time" ,sbcl-local-time)))
+ (home-page "https://github.com/fukamachi/lack")
+ (synopsis "Lack, the core of Clack")
+ (description
+ "Lack is a Common Lisp library which allows web applications to be
+constructed of modular components. It was originally a part of Clack, however
+it's going to be rewritten as an individual project since Clack v2 with
+performance and simplicity in mind.")
+ (license license:llgpl))))
+
+(define-public cl-lack-middleware-static
+ (sbcl-package->cl-source-package sbcl-lack-middleware-static))
+
+(define-public sbcl-lack
+ (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
+ (revision "1"))
+ (package
+ (name "sbcl-lack")
+ (version (git-version "0.1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/lack.git")
+ (commit commit)))
+ (sha256
+ (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:test-asd-file "t-lack.asd"
+ ;; XXX: Component :CLACK not found
+ #:tests? #f))
+ (native-inputs
+ `(("prove-asdf" ,sbcl-prove-asdf)))
+ (inputs
+ `(("sbcl-lack-component" ,sbcl-lack-component)
+ ("sbcl-lack-util" ,sbcl-lack-util)))
+ (home-page "https://github.com/fukamachi/lack")
+ (synopsis "Lack, the core of Clack")
+ (description
+ "Lack is a Common Lisp library which allows web applications to be
+constructed of modular components. It was originally a part of Clack, however
+it's going to be rewritten as an individual project since Clack v2 with
+performance and simplicity in mind.")
+ (license license:llgpl))))
+
+(define-public cl-lack
+ (sbcl-package->cl-source-package sbcl-lack))
+
+(define-public sbcl-ningle
+ (let ((commit "50bd4f09b5a03a7249bd4d78265d6451563b25ad")
+ (revision "1"))
+ (package
+ (name "sbcl-ningle")
+ (version (git-version "0.3.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/ningle.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1bsl8cnxhacb8p92z9n89vhk1ikmij5zavk0m2zvmj7iqm79jzgw"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ ;; TODO: pull in clack-test
+ '(#:tests? #f
+ #:phases
+ (modify-phases %standard-phases
+ (delete 'cleanup-files)
+ (delete 'cleanup)
+ (add-before 'cleanup 'combine-fasls
+ (lambda* (#:key outputs #:allow-other-keys)
+ (let* ((out (assoc-ref outputs "out"))
+ (lib (string-append out "/lib/sbcl"))
+ (ningle-path (string-append lib "/ningle"))
+ (fasl-files (find-files out "\\.fasl$")))
+ (mkdir-p ningle-path)
+ (let ((fasl-path (lambda (name)
+ (string-append ningle-path
+ "/"
+ (basename name)
+ "--system.fasl"))))
+ (for-each (lambda (file)
+ (rename-file file
+ (fasl-path
+ (basename file ".fasl"))))
+ fasl-files))
+ fasl-files)
+ #t)))))
+ (native-inputs
+ `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+ ("sbcl-prove" ,sbcl-prove)))
+ (inputs
+ `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
+ ("sbcl-cl-syntax-annot" ,sbcl-cl-syntax-annot)
+ ("sbcl-myway" ,sbcl-myway)
+ ("sbcl-lack-request" ,sbcl-lack-request)
+ ("sbcl-lack-response" ,sbcl-lack-response)
+ ("sbcl-lack-component" ,sbcl-lack-component)
+ ("sbcl-alexandria" ,sbcl-alexandria)
+ ("sbcl-babel" ,sbcl-babel)))
+ (home-page "http://8arrow.org/ningle/")
+ (synopsis "Super micro framework for Common Lisp")
+ (description
+ "Ningle is a lightweight web application framework for Common Lisp.")
+ (license license:llgpl))))
+
+(define-public cl-ningle
+ (sbcl-package->cl-source-package sbcl-ningle))
+
+(define-public sbcl-clack
+ (let ((commit "e3e032843bb1220ab96263c411aa7f2feb4746e0")
+ (revision "1"))
+ (package
+ (name "sbcl-clack")
+ (version (git-version "2.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/clack.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1ymzs6qyrwhlj6cgqsnpyn6g5cbp7a3s1vgxwna20y2q7y4iacy0"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("sbcl-lack" ,sbcl-lack)
+ ("sbcl-lack-middleware-backtrace" ,sbcl-lack-middleware-backtrace)
+ ("sbcl-bordeaux-threads" ,sbcl-bordeaux-threads)))
+ (home-page "https://github.com/fukamachi/clack")
+ (synopsis "Web Application Environment for Common Lisp")
+ (description
+ "Clack is a web application environment for Common Lisp inspired by
+Python's WSGI and Ruby's Rack.")
+ (license license:llgpl))))
+
+(define-public cl-clack
+ (sbcl-package->cl-source-package sbcl-clack))
+
+(define-public sbcl-log4cl
+ (let ((commit "611e094458504b938d49de904eab141285328c7c")
+ (revision "1"))
+ (package
+ (name "sbcl-log4cl")
+ (build-system asdf-build-system/sbcl)
+ (version "1.1.2")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sharplispers/log4cl")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "08jly0s0g26b56hhpfizxsb4j0yvbh946sd205gr42dkzv8l7dsc"))))
+ ;; FIXME: tests require stefil, sbcl-hu.dwim.stefil wont work
+ (arguments
+ `(#:tests? #f))
+ (inputs `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
+ (synopsis "Common Lisp logging framework, modeled after Log4J")
+ (home-page "https://github.com/7max/log4cl")
+ (description "This is a Common Lisp logging framework that can log at
+various levels and mix text with expressions.")
+ (license license:asl2.0))))
+
+(define-public cl-log4cl
+ (sbcl-package->cl-source-package sbcl-log4cl))
+
+(define-public ecl-log4cl
+ (sbcl-package->ecl-package sbcl-log4cl))
+
+(define-public sbcl-find-port
+ (let ((commit "00c96a25af93a0f8681d34ec548861f2d7485478")
+ (revision "1"))
+ (package
+ (name "sbcl-find-port")
+ (build-system asdf-build-system/sbcl)
+ (version "0.1")
+ (home-page "https://github.com/eudoxia0/find-port")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0d6dzbb45jh0rx90wgs6v020k2xa87mvzas3mvfzvivjvqqlpryq"))))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (inputs
+ `(("sbcl-usocket" ,sbcl-usocket)))
+ (synopsis "Find open ports programmatically in Common Lisp")
+ (description "This is a small Common Lisp library that finds an open
+port within a range.")
+ (license license:expat))))
+
+(define-public cl-find-port
+ (sbcl-package->cl-source-package sbcl-find-port))
+
+(define-public ecl-find-port
+ (sbcl-package->ecl-package sbcl-find-port))
+
+(define-public txr
+ (package
+ (name "txr")
+ (version "216")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "http://www.kylheku.com/cgit/txr/snapshot/txr-"
+ version
+ ".tar.bz2"))
+ (patches (search-patches "txr-shell.patch"))
+ (sha256
+ (base32
+ "07cxdpc9zsqd0c2668g00dqjpd6zc4mfdn74aarr6d2hpzdhh937"))))
+ (build-system gnu-build-system)
+ (arguments
+ '(#:configure-flags '("cc=gcc")
+ #:phases (modify-phases %standard-phases
+ (add-after 'configure 'fix-tests
+ (lambda _
+ (substitute* "tests/017/realpath.tl"
+ (("/usr/bin") "/"))
+ (substitute* "tests/017/realpath.expected"
+ (("/usr/bin") "/"))
+ #t))
+ (replace 'check
+ (lambda _
+ (zero? (system* "make" "tests")))))))
+ (native-inputs
+ `(("bison" ,bison)
+ ("flex" ,flex)))
+ (inputs
+ `(("libffi" ,libffi)))
+ (synopsis "General-purpose, multi-paradigm programming language")
+ (description
+ "TXR is a general-purpose, multi-paradigm programming language. It
+comprises two languages integrated into a single tool: a text scanning and
+extraction language referred to as the TXR Pattern Language (sometimes just
+\"TXR\"), and a general-purpose dialect of Lisp called TXR Lisp. TXR can be
+used for everything from \"one liner\" data transformation tasks at the
+command line, to data scanning and extracting scripts, to full application
+development in a wide-range of areas.")
+ (home-page "https://nongnu.org/txr/")
+ (license license:bsd-2)))
+
+(define-public sbcl-clunit
+ (let ((commit "6f6d72873f0e1207f037470105969384f8380628")
+ (revision "1"))
+ (package
+ (name "sbcl-clunit")
+ (version (git-version "0.2.3" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/tgutu/clunit.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1idf2xnqzlhi8rbrqmzpmb3i1l6pbdzhhajkmhwbp6qjkmxa4h85"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "CLUnit is a Common Lisp unit testing framework")
+ (description
+ "CLUnit is a Common Lisp unit testing framework. It is designed
+to be easy to use so that you can quickly start testing. CLUnit
+provides a rich set of features aimed at improving your unit testing
+experience.")
+ (home-page "http://tgutu.github.io/clunit/")
+ ;; MIT License
+ (license license:expat))))
+
+(define-public cl-clunit
+ (sbcl-package->cl-source-package sbcl-clunit))
+
+(define-public ecl-clunit
+ (sbcl-package->ecl-package sbcl-clunit))
+
+(define-public sbcl-py4cl
+ (let ((commit "4c8a2b0814fd311f978964f825ce012290f60136")
+ (revision "1"))
+ (package
+ (name "sbcl-py4cl")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/bendudson/py4cl.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "15mk7qdqjkj56gdnbyrdyz6r7m1h26ldvn6ch96pmvg5vmr1m45r"))
+ (modules '((guix build utils)))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("sbcl-clunit" ,sbcl-clunit)))
+ (inputs
+ `(("sbcl-trivial-garbage" ,sbcl-trivial-garbage)))
+ (propagated-inputs
+ ;; This package doesn't do anything without python available
+ `(("python" ,python)
+ ;; For multi-dimensional array support
+ ("python-numpy" ,python-numpy)))
+ (arguments
+ '(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'replace-*base-directory*-var
+ (lambda* (#:key outputs #:allow-other-keys)
+ ;; In the ASD, the author makes an attempt to
+ ;; programatically determine the location of the
+ ;; source-code so lisp can call into "py4cl.py". We can
+ ;; hard-code this since we know where this file will
+ ;; reside.
+ (substitute* "src/callpython.lisp"
+ (("py4cl/config:\\*base-directory\\*")
+ (string-append
+ "\""
+ (assoc-ref outputs "out")
+ "/share/common-lisp/sbcl-source/py4cl/"
+ "\""))))))))
+ (synopsis "Call python from Common Lisp")
+ (description
+ "Py4CL is a bridge between Common Lisp and Python, which enables Common
+Lisp to interact with Python code. It uses streams to communicate with a
+separate python process, the approach taken by cl4py. This is different to
+the CFFI approach used by burgled-batteries, but has the same goal.")
+ (home-page "https://github.com/bendudson/py4cl")
+ ;; MIT License
+ (license license:expat))))
+
+(define-public cl-py4cl
+ (sbcl-package->cl-source-package sbcl-py4cl))
+
+(define-public ecl-py4cl
+ (sbcl-package->ecl-package sbcl-py4cl))
+
+(define-public sbcl-parse-declarations
+ (package
+ (name "sbcl-parse-declarations")
+ (version "1.0.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://beta.quicklisp.org/archive/parse-declarations/"
+ "2010-10-06/parse-declarations-20101006-darcs.tgz"))
+ (sha256
+ (base32
+ "0r85b0jfacd28kr65kw9c13dx4i6id1dpmby68zjy63mqbnyawrd"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:asd-file "parse-declarations-1.0.asd"
+ #:asd-system-name "parse-declarations-1.0"))
+ (home-page "https://common-lisp.net/project/parse-declarations/")
+ (synopsis "Parse, filter, and build declarations")
+ (description
+ "Parse-Declarations is a Common Lisp library to help writing
+macros which establish bindings. To be semantically correct, such
+macros must take user declarations into account, as these may affect
+the bindings they establish. Yet the ANSI standard of Common Lisp does
+not provide any operators to work with declarations in a convenient,
+high-level way. This library provides such operators.")
+ ;; MIT License
+ (license license:expat)))
+
+(define-public cl-parse-declarations
+ (sbcl-package->cl-source-package sbcl-parse-declarations))
+
+(define-public ecl-parse-declarations
+ (sbcl-package->ecl-package sbcl-parse-declarations))
+
+(define-public sbcl-cl-quickcheck
+ (let ((commit "807b2792a30c883a2fbecea8e7db355b50ba662f")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-quickcheck")
+ (version (git-version "0.0.4" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/mcandre/cl-quickcheck.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "165lhypq5xkcys6hvzb3jq7ywnmqvzaflda29qk2cbs3ggas4767"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis
+ "Common Lisp port of the QuickCheck unit test framework")
+ (description
+ "Common Lisp port of the QuickCheck unit test framework")
+ (home-page "https://github.com/mcandre/cl-quickcheck")
+ ;; MIT
+ (license license:expat))))
+
+(define-public cl-cl-quickcheck
+ (sbcl-package->cl-source-package sbcl-cl-quickcheck))
+
+(define-public ecl-cl-quickcheck
+ (sbcl-package->ecl-package sbcl-cl-quickcheck))
+
+(define-public sbcl-burgled-batteries3
+ (let ((commit "9c0f6667e1a71ddf77e21793a0bea524710fef6e")
+ (revision "1"))
+ (package
+ (name "sbcl-burgled-batteries3")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/snmsts/burgled-batteries3.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0b726kz2xxcg5l930gz035rsdvhxrzmp05iwfwympnb4z4ammicb"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:tests? #f
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'set-*cpython-include-dir*-var
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "grovel-include-dir.lisp"
+ (("\\(defparameter \\*cpython-include-dir\\* \\(detect-python\\)\\)")
+ (string-append
+ "(defparameter *cpython-include-dir* \""
+ (assoc-ref inputs "python")
+ "/include/python3.7m"
+ "\")")))
+ (substitute* "ffi-interface.lisp"
+ (("\\*cpython-lib\\*")
+ (format #f "'(\"~a/lib/libpython3.so\")"
+ (assoc-ref inputs "python"))))
+ #t)))))
+ (native-inputs
+ `(("python" ,python)
+ ("sbcl-cl-fad" ,sbcl-cl-fad)
+ ("sbcl-lift" ,sbcl-lift)
+ ("sbcl-cl-quickcheck" ,sbcl-cl-quickcheck)))
+ (inputs
+ `(("sbcl-cffi" ,sbcl-cffi)
+ ("sbcl-cffi-grovel" ,sbcl-cffi-grovel)
+ ("sbcl-alexandria" , sbcl-alexandria)
+ ("sbcl-parse-declarations-1.0" ,sbcl-parse-declarations)
+ ("sbcl-trivial-garbage" ,sbcl-trivial-garbage)))
+ (synopsis "Bridge between Python and Lisp (FFI bindings, etc.)")
+ (description
+ "This package provides a shim between Python3 (specifically, the
+CPython implementation of Python) and Common Lisp.")
+ (home-page "https://github.com/snmsts/burgled-batteries3")
+ ;; MIT
+ (license license:expat))))
+
+(define-public cl-burgled-batteries3
+ (sbcl-package->cl-source-package sbcl-burgled-batteries3))
+
+(define-public ecl-burgled-batteries3
+ (sbcl-package->ecl-package sbcl-burgled-batteries3))
+
+(define-public sbcl-metabang-bind
+ (let ((commit "c93b7f7e1c18c954c2283efd6a7fdab36746ab5e")
+ (revision "1"))
+ (package
+ (name "sbcl-metabang-bind")
+ (version (git-version "0.8.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/gwkkwg/metabang-bind.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0hd0kr91795v77akpbcyqiss9p0p7ypa9dznrllincnmgvsxlmf0"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("sbcl-lift" ,sbcl-lift)))
+ (synopsis "Macro that generalizes @code{multiple-value-bind} etc.")
+ (description
+ "Bind extends the idea of of let and destructing to provide a uniform
+syntax for all your accessor needs. It combines @code{let},
+@code{destructuring-bind}, @code{with-slots}, @code{with-accessors}, structure
+editing, property or association-lists, and @code{multiple-value-bind} and a
+whole lot more into a single form.")
+ (home-page "https://common-lisp.net/project/metabang-bind/")
+ ;; MIT License
+ (license license:expat))))
+
+(define-public cl-metabang-bind
+ (sbcl-package->cl-source-package sbcl-metabang-bind))
+
+(define-public ecl-metabang-bind
+ (sbcl-package->ecl-package sbcl-metabang-bind))
+
+(define-public sbcl-fare-utils
+ (let ((commit "66e9c6f1499140bc00ccc22febf2aa528cbb5724")
+ (revision "1"))
+ (package
+ (name "sbcl-fare-utils")
+ (version (git-version "1.0.0.5" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri
+ (git-reference
+ (url
+ "https://gitlab.common-lisp.net/frideau/fare-utils.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "01wsr1aap3jdzhn4hrqjbhsjx6qci9dbd3gh4gayv1p49rbg8aqr"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:test-asd-file "test/fare-utils-test.asd"))
+ (native-inputs
+ `(("sbcl-hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
+ (synopsis "Collection of utilities and data structures")
+ (description
+ "fare-utils is a small collection of utilities. It contains a lot of
+basic everyday functions and macros.")
+ (home-page "https://gitlab.common-lisp.net/frideau/fare-utils")
+ ;; MIT License
+ (license license:expat))))
+
+(define-public cl-fare-utils
+ (sbcl-package->cl-source-package sbcl-fare-utils))
+
+(define-public ecl-fare-utils
+ (sbcl-package->ecl-package sbcl-fare-utils))
+
+(define-public sbcl-trivial-utf-8
+ (let ((commit "4d427cfbb1c452436a0efb71c3205c9da67f718f")
+ (revision "1"))
+ (package
+ (name "sbcl-trivial-utf-8")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri
+ (git-reference
+ (url (string-append "https://gitlab.common-lisp.net/"
+ "trivial-utf-8/trivial-utf-8.git"))
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1jz27gz8gvqdmvp3k9bxschs6d5b3qgk94qp2bj6nv1d0jc3m1l1"))))
+ (arguments
+ ;; Guix incorrectly assumes the "8" is part of the version
+ ;; number and lobs it off.
+ `(#:asd-file "trivial-utf-8.asd"
+ #:asd-system-name "trivial-utf-8"))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "UTF-8 input/output library")
+ (description
+ "The Babel library solves a similar problem while understanding more
+encodings. Trivial UTF-8 was written before Babel existed, but for new
+projects you might be better off going with Babel. The one plus that Trivial
+UTF-8 has is that it doesn't depend on any other libraries.")
+ (home-page "https://common-lisp.net/project/trivial-utf-8/")
+ (license license:bsd-3))))
+
+(define-public cl-trivial-utf-8
+ (sbcl-package->cl-source-package sbcl-trivial-utf-8))
+
+(define-public ecl-trivial-utf-8
+ (sbcl-package->ecl-package sbcl-trivial-utf-8))
+
+(define-public sbcl-idna
+ (package
+ (name "sbcl-idna")
+ (build-system asdf-build-system/sbcl)
+ (version "0.2.2")
+ (home-page "https://github.com/antifuchs/idna")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit version)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "00nbr3mffxhlq14gg9d16pa6691s4qh35inyw76v906s77khm5a2"))))
+ (inputs
+ `(("split-sequence" ,sbcl-split-sequence)))
+ (synopsis "IDNA string encoding and decoding routines for Common Lisp")
+ (description "This Common Lisp library provides string encoding and
+decoding routines for IDNA, the International Domain Names in Applications.")
+ (license license:expat)))
+
+(define-public cl-idna
+ (sbcl-package->cl-source-package sbcl-idna))
+
+(define-public ecl-idna
+ (sbcl-package->ecl-package sbcl-idna))
+
+(define-public sbcl-swap-bytes
+ (package
+ (name "sbcl-swap-bytes")
+ (build-system asdf-build-system/sbcl)
+ (version "1.1")
+ (home-page "https://github.com/sionescu/swap-bytes")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1qysbv0jngdfkv53y874qjhcxc4qi8ixaqq6j8bzxh5z0931wv55"))))
+ (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
+1/2/4/8. Very useful in implementing various network protocols and file
+formats.")
+ (license license:expat)))
+
+(define-public cl-swap-bytes
+ (sbcl-package->cl-source-package sbcl-swap-bytes))
+
+(define-public ecl-swap-bytes
+ (sbcl-package->ecl-package sbcl-swap-bytes))
+
+(define-public sbcl-iolib.asdf
+ ;; Latest release is from June 2017.
+ (let ((commit "81e20614c0d27f9605bf9766214e236fd31b99b4")
+ (revision "1"))
+ (package
+ (name "sbcl-iolib.asdf")
+ (build-system asdf-build-system/sbcl)
+ (version "0.8.3")
+ (home-page "https://github.com/sionescu/iolib")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1j81r0wm7nfbwl991f26s4npcy7kybzybd3m47rbxy31h0cfcmdm"))))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)))
+ (arguments
+ '(#:asd-file "iolib.asdf.asd"))
+ (synopsis "ASDF component classes for IOLib, a Common Lisp I/O library")
+ (description "IOlib is to be a better and more modern I/O library than
+the standard Common Lisp library. It contains a socket library, a DNS
+resolver, an I/O multiplexer(which supports @code{select(2)}, @code{epoll(4)}
+and @code{kqueue(2)}), a pathname library and file-system utilities.")
+ (license license:expat))))
+
+(define-public sbcl-iolib.conf
+ (package
+ (inherit sbcl-iolib.asdf)
+ (name "sbcl-iolib.conf")
+ (inputs
+ `(("iolib.asdf" ,sbcl-iolib.asdf)))
+ (arguments
+ '(#:asd-file "iolib.conf.asd"))
+ (synopsis "Compile-time configuration for IOLib, a Common Lisp I/O library")))
+
+(define-public sbcl-iolib.common-lisp
+ (package
+ (inherit sbcl-iolib.asdf)
+ (name "sbcl-iolib.common-lisp")
+ (inputs
+ `(("iolib.asdf" ,sbcl-iolib.asdf)
+ ("iolib.conf" ,sbcl-iolib.conf)))
+ (arguments
+ '(#:asd-file "iolib.common-lisp.asd"))
+ (synopsis "Slightly modified Common Lisp for IOLib, a Common Lisp I/O library")))
+
+(define-public sbcl-iolib.base
+ (package
+ (inherit sbcl-iolib.asdf)
+ (name "sbcl-iolib.base")
+ (inputs
+ `(("iolib.asdf" ,sbcl-iolib.asdf)
+ ("iolib.conf" ,sbcl-iolib.conf)
+ ("iolib.common-lisp" ,sbcl-iolib.common-lisp)
+ ("split-sequence" ,sbcl-split-sequence)))
+ (arguments
+ '(#:asd-file "iolib.base.asd"))
+ (synopsis "Base package for IOLib, a Common Lisp I/O library")))
+
+(define-public sbcl-iolib.grovel
+ (package
+ (inherit sbcl-iolib.asdf)
+ (name "sbcl-iolib.grovel")
+ (inputs
+ `(("iolib.asdf" ,sbcl-iolib.asdf)
+ ("iolib.conf" ,sbcl-iolib.conf)
+ ("iolib.base", sbcl-iolib.base)
+ ("cffi", sbcl-cffi)))
+ (arguments
+ '(#:asd-file "iolib.grovel.asd"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'install 'install-header
+ (lambda* (#:key outputs #:allow-other-keys)
+ ;; This header is required by sbcl-iolib.
+ (install-file "src/grovel/grovel-common.h"
+ (string-append (assoc-ref outputs "out")
+ "/lib/sbcl"))
+ #t)))))
+ (synopsis "CFFI Groveller for IOLib, a Common Lisp I/O library")))
+
+(define-public sbcl-iolib
+ (package
+ (inherit sbcl-iolib.asdf)
+ (name "sbcl-iolib")
+ (inputs
+ `(("iolib.asdf" ,sbcl-iolib.asdf)
+ ("iolib.conf" ,sbcl-iolib.conf)
+ ("iolib.grovel" ,sbcl-iolib.grovel)
+ ("iolib.base" ,sbcl-iolib.base)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("idna" ,sbcl-idna)
+ ("swap-bytes" ,sbcl-swap-bytes)
+ ("libfixposix" ,libfixposix)
+ ("cffi" ,sbcl-cffi)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (arguments
+ '(#:asd-file "iolib.asd"
+ #:asd-system-name "iolib"
+ #:test-asd-file "iolib.tests.asd"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/syscalls/ffi-functions-unix.lisp"
+ (("\\(:default \"libfixposix\"\\)")
+ (string-append
+ "(:default \""
+ (assoc-ref inputs "libfixposix") "/lib/libfixposix\")")))
+ ;; Socket tests need Internet access, disable them.
+ (substitute* "iolib.tests.asd"
+ (("\\(:file \"sockets\" :depends-on \\(\"pkgdcl\" \"defsuites\"\\)\\)")
+ "")))))))
+ (synopsis "Common Lisp I/O library")))
+
+(define sbcl-iolib+multiplex
+ (package
+ (inherit sbcl-iolib)
+ (name "sbcl-iolib+multiplex")
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-iolib)
+ ((#:asd-system-name _) "iolib/multiplex")))))
+
+(define sbcl-iolib+syscalls
+ (package
+ (inherit sbcl-iolib)
+ (name "sbcl-iolib+syscalls")
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-iolib)
+ ((#:asd-system-name _) "iolib/syscalls")))))
+
+(define sbcl-iolib+streams
+ (package
+ (inherit sbcl-iolib)
+ (name "sbcl-iolib+streams")
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-iolib)
+ ((#:asd-system-name _) "iolib/streams")))))
+
+(define sbcl-iolib+sockets
+ (package
+ (inherit sbcl-iolib)
+ (name "sbcl-iolib+sockets")
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-iolib)
+ ((#:asd-system-name _) "iolib/sockets")))))
+
+(define-public sbcl-ieee-floats
+ (let ((commit "566b51a005e81ff618554b9b2f0b795d3b29398d")
+ (revision "1"))
+ (package
+ (name "sbcl-ieee-floats")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "20170924" revision commit))
+ (home-page "https://github.com/marijnh/ieee-floats/")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1xyj49j9x3lc84cv3dhbf9ja34ywjk1c46dklx425fxw9mkwm83m"))))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (synopsis "IEEE 754 binary representation for floats in Common Lisp")
+ (description "This is a Common Lisp library that allows to convert
+floating point values to IEEE 754 binary representation.")
+ (license license:bsd-3))))
+
+(define sbcl-closure-common
+ (let ((commit "e3c5f5f454b72b01b89115e581c3c52a7e201e5c")
+ (revision "1"))
+ (package
+ (name "sbcl-closure-common")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "20101006" revision commit))
+ (home-page "https://common-lisp.net/project/cxml/")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sharplispers/closure-common")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0k5r2qxn122pxi301ijir3nayi9sg4d7yiy276l36qmzwhp4mg5n"))))
+ (inputs
+ `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)
+ ("babel" ,sbcl-babel)))
+ (synopsis "Support Common Lisp library for CXML")
+ (description "Closure-common is an internal helper library. The name
+Closure is a reference to the web browser it was originally written for.")
+ ;; TODO: License?
+ (license #f))))
+
+(define-public sbcl-cxml+xml
+ (let ((commit "00b22bf4c4cf11c993d5866fae284f95ab18e6bf")
+ (revision "1"))
+ (package
+ (name "sbcl-cxml+xml")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "0.0.0" revision commit))
+ (home-page "https://common-lisp.net/project/cxml/")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sharplispers/cxml")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "13kif7rf3gqdycsk9zq0d7y0g9y81krkl0z87k0p2fkbjfgrph37"))))
+ (inputs
+ `(("closure-common" ,sbcl-closure-common)
+ ("puri" ,sbcl-puri)
+ ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
+ (arguments
+ `(#:asd-file "cxml.asd"
+ #:asd-system-name "cxml/xml"))
+ (synopsis "Common Lisp XML parser")
+ (description "CXML implements a namespace-aware, validating XML 1.0
+parser as well as the DOM Level 2 Core interfaces. Two parser interfaces are
+offered, one SAX-like, the other similar to StAX.")
+ (license license:llgpl))))
+
+(define sbcl-cxml+dom
+ (package
+ (inherit sbcl-cxml+xml)
+ (name "sbcl-cxml+dom")
+ (inputs
+ `(("closure-common" ,sbcl-closure-common)
+ ("puri" ,sbcl-puri)
+ ("cxml+xml" ,sbcl-cxml+xml)))
+ (arguments
+ `(#:asd-file "cxml.asd"
+ #:asd-system-name "cxml/dom"))))
+
+(define sbcl-cxml+klacks
+ (package
+ (inherit sbcl-cxml+xml)
+ (name "sbcl-cxml+klacks")
+ (inputs
+ `(("closure-common" ,sbcl-closure-common)
+ ("puri" ,sbcl-puri)
+ ("cxml+xml" ,sbcl-cxml+xml)))
+ (arguments
+ `(#:asd-file "cxml.asd"
+ #:asd-system-name "cxml/klacks"))))
+
+(define sbcl-cxml+test
+ (package
+ (inherit sbcl-cxml+xml)
+ (name "sbcl-cxml+test")
+ (inputs
+ `(("closure-common" ,sbcl-closure-common)
+ ("puri" ,sbcl-puri)
+ ("cxml+xml" ,sbcl-cxml+xml)))
+ (arguments
+ `(#:asd-file "cxml.asd"
+ #:asd-system-name "cxml/test"))))
+
+(define-public sbcl-cxml
+ (package
+ (inherit sbcl-cxml+xml)
+ (name "sbcl-cxml")
+ (inputs
+ `(("closure-common" ,sbcl-closure-common)
+ ("puri" ,sbcl-puri)
+ ("trivial-gray-streams" ,sbcl-trivial-gray-streams)
+ ("cxml+dom" ,sbcl-cxml+dom)
+ ("cxml+klacks" ,sbcl-cxml+klacks)
+ ("cxml+test" ,sbcl-cxml+test)))
+ (arguments
+ `(#:asd-file "cxml.asd"
+ #:asd-system-name "cxml"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'build 'install-dtd
+ (lambda* (#:key outputs #:allow-other-keys)
+ (install-file "catalog.dtd"
+ (string-append
+ (assoc-ref outputs "out")
+ "/lib/" (%lisp-type)))))
+ (add-after 'create-asd 'remove-component
+ ;; XXX: The original .asd has no components, but our build system
+ ;; creates an entry nonetheless. We need to remove it for the
+ ;; generated .asd to load properly. See trivia.trivial for a
+ ;; similar problem.
+ (lambda* (#:key outputs #:allow-other-keys)
+ (let* ((out (assoc-ref outputs "out"))
+ (asd (string-append out "/lib/sbcl/cxml.asd")))
+ (substitute* asd
+ ((" :components
+")
+ ""))
+ (substitute* asd
+ ((" *\\(\\(:compiled-file \"cxml--system\"\\)\\)")
+ ""))))))))))
+
+(define-public sbcl-cl-reexport
+ (let ((commit "312f3661bbe187b5f28536cd7ec2956e91366c3b")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-reexport")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "0.1" revision commit))
+ (home-page "https://github.com/takagi/cl-reexport")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1cwpn1m3wrl0fl9plznn7p464db646gnfc8zkyk97dyxski2aq0x"))))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)))
+ (arguments
+ ;; TODO: Tests fail because cl-test-more is missing, but I can't find it online.
+ `(#:tests? #f))
+ (synopsis "HTTP cookie manager for Common Lisp")
+ (description "cl-cookie is a Common Lisp library featuring parsing of
+cookie headers, cookie creation, cookie jar creation and more.")
+ (license license:llgpl))))
+
+(define-public sbcl-cl-cookie
+ (let ((commit "cea55aed8b9ad25fafd13defbcb9fe8f41b29546")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-cookie")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "0.9.10" revision commit))
+ (home-page "https://github.com/fukamachi/cl-cookie")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "090g7z75h98zvc1ldx0vh4jn4086dhjm2w30jcwkq553qmyxwl8h"))))
+ (inputs
+ `(("proc-parse" ,sbcl-proc-parse)
+ ("alexandria" ,sbcl-alexandria)
+ ("quri" ,sbcl-quri)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("local-time" ,sbcl-local-time)))
+ (native-inputs
+ `(("prove-asdf" ,sbcl-prove-asdf)
+ ("prove" ,sbcl-prove)))
+ (arguments
+ ;; TODO: Tests fail because cl-cookie depends on cl-cookie-test.
+ `(#:tests? #f))
+ (synopsis "HTTP cookie manager for Common Lisp")
+ (description "cl-cookie is a Common Lisp library featuring parsing of
+cookie headers, cookie creation, cookie jar creation and more.")
+ (license license:bsd-2))))
+
+(define-public sbcl-dexador
+ (let ((commit "a2714d126cc94bc7a9a6e1e3c08de455b3a66378")
+ (revision "1"))
+ (package
+ (name "sbcl-dexador")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "0.9.10" revision commit))
+ (home-page "https://github.com/fukamachi/dexador")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0nbqgn4v3l2z6m1k1bdxfnqpfrk84nxdmz7csz11zzcfs4flkv79"))))
+ (inputs
+ `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)
+ ("babel" ,sbcl-babel)
+ ("usocket" ,sbcl-usocket)
+ ("fast-http" ,sbcl-fast-http)
+ ("quri" ,sbcl-quri)
+ ("fast-io" ,sbcl-fast-io)
+ ("chunga" ,sbcl-chunga)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("cl-cookie" ,sbcl-cl-cookie)
+ ("trivial-mimes" ,sbcl-trivial-mimes)
+ ("chipz" ,sbcl-chipz)
+ ("cl-base64" ,sbcl-cl-base64)
+ ("cl-reexport" ,sbcl-cl-reexport)
+ ("cl+ssl" ,sbcl-cl+ssl)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("alexandria" ,sbcl-alexandria)))
+ (native-inputs
+ `(("prove" ,sbcl-prove)
+ ("prove-asdf" ,sbcl-prove-asdf)
+ ("lack-request" ,sbcl-lack-request)
+ ("clack" ,sbcl-clack)
+ ("babel" ,sbcl-babel)
+ ("alexandria" ,sbcl-alexandria)
+ ("quri" ,sbcl-quri)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("local-time" ,sbcl-local-time)))
+ (arguments
+ ;; TODO: Circular dependency: tests depend on clack-test which depends on dexador.
+ `(#:tests? #f
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-permissions
+ (lambda _ (make-file-writable "t/data/test.gz") #t)))))
+ (synopsis "Yet another HTTP client for Common Lisp")
+ (description "Dexador is yet another HTTP client for Common Lisp with
+neat APIs and connection-pooling. It is meant to supersede Drakma.")
+ (license license:expat))))
+
+(define-public sbcl-lisp-namespace
+ (let ((commit "28107cafe34e4c1c67490fde60c7f92dc610b2e0")
+ (revision "1"))
+ (package
+ (name "sbcl-lisp-namespace")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "0.1" revision commit))
+ (home-page "https://github.com/guicho271828/lisp-namespace")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1jw2wykp06z2afb9nm1lgfzll5cjlj36pnknjx614057zkkxq4iy"))))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (arguments
+ `(#:test-asd-file "lisp-namespace.test.asd"
+ ;; XXX: Component LISP-NAMESPACE-ASD::LISP-NAMESPACE.TEST not found
+ #:tests? #f))
+ (synopsis "LISP-N, or extensible namespaces in Common Lisp")
+ (description "Common Lisp already has major 2 namespaces, function
+namespace and value namespace (or variable namespace), but there are actually
+more — e.g., class namespace.
+This library offers macros to deal with symbols from any namespace.")
+ (license license:llgpl))))
+
+(define-public sbcl-trivial-cltl2
+ (let ((commit "8eec8407df833e8f27df8a388bc10913f16d9e83")
+ (revision "1"))
+ (package
+ (name "sbcl-trivial-cltl2")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "0.1.1" revision commit))
+ (home-page "https://github.com/Zulu-Inuoe/trivial-cltl2")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1dyyxz17vqv8hlfwq287gl8xxbvcnq798ajb7p5jdjz91wqf4bgk"))))
+ (synopsis "Simple CLtL2 compatibility layer for Common Lisp")
+ (description "This library is a portable compatibility layer around
+\"Common Lisp the Language, 2nd
+Edition\" (@url{https://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node102.html})
+and it exports symbols from implementation-specific packages.")
+ (license license:llgpl))))
+
+(define-public sbcl-introspect-environment
+ (let ((commit "fff42f8f8fd0d99db5ad6c5812e53de7d660020b")
+ (revision "1"))
+ (package
+ (name "sbcl-introspect-environment")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "0.1" revision commit))
+ (home-page "https://github.com/Bike/introspect-environment")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1i305n0wfmpac63ni4i3vixnnkl8daw5ncxy0k3dv92krgx6qzhp"))))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (synopsis "Common Lisp environment introspection portability layer")
+ (description "This library is a small interface to portable but
+nonstandard introspection of Common Lisp environments. It is intended to
+allow a bit more compile-time introspection of environments in Common Lisp.
+
+Quite a bit of information is available at the time a macro or compiler-macro
+runs; inlining info, type declarations, that sort of thing. This information
+is all standard - any Common Lisp program can @code{(declare (integer x))} and
+such.
+
+This info ought to be accessible through the standard @code{&environment}
+parameters, but it is not. Several implementations keep the information for
+their own purposes but do not make it available to user programs, because
+there is no standard mechanism to do so.
+
+This library uses implementation-specific hooks to make information available
+to users. This is currently supported on SBCL, CCL, and CMUCL. Other
+implementations have implementations of the functions that do as much as they
+can and/or provide reasonable defaults.")
+ (license license:wtfpl2))))
+
+(define-public sbcl-type-i
+ (let ((commit "dea233f45f94064105ec09f0767de338f67dcbe2")
+ (revision "1"))
+ (package
+ (name "sbcl-type-i")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "0.1" revision commit))
+ (home-page "https://github.com/guicho271828/type-i")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "039g5pbrhh65s0bhr9314gmd2nwc2y5lp2377c5qrc2lxky89qs3"))))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("introspect-environment" ,sbcl-introspect-environment)
+ ("trivia.trivial" ,sbcl-trivia.trivial)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (arguments
+ `(#:test-asd-file "type-i.test.asd"))
+ (synopsis "Type inference utility on unary predicates for Common Lisp")
+ (description "This library tries to provide a way to detect what kind of
+type the given predicate is trying to check. This is different from inferring
+the return type of a function.")
+ (license license:llgpl))))
+
+(define-public sbcl-optima
+ (let ((commit "373b245b928c1a5cce91a6cb5bfe5dd77eb36195")
+ (revision "1"))
+ (package
+ (name "sbcl-optima")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "0.1" revision commit))
+ (home-page "https://github.com/m2ym/optima")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1yw4ymq7ms89342kkvb3aqxgv0w38m9kd8ikdqxxzyybnkjhndal"))))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("closer-mop" ,sbcl-closer-mop)))
+ (native-inputs
+ `(("eos" ,sbcl-eos)))
+ (arguments
+ ;; XXX: Circular dependencies: tests depend on optima.ppcre which depends on optima.
+ `(#:tests? #f
+ #:test-asd-file "optima.test.asd"))
+ (synopsis "Optimized pattern matching library for Common Lisp")
+ (description "Optima is a fast pattern matching library which uses
+optimizing techniques widely used in the functional programming world.")
+ (license license:expat))))
+
+(define-public sbcl-fare-quasiquote
+ (package
+ (name "sbcl-fare-quasiquote")
+ (build-system asdf-build-system/sbcl)
+ (version "20171130")
+ (home-page "http://common-lisp.net/project/fare-quasiquote")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "http://beta.quicklisp.org/archive/fare-quasiquote/"
+ (date->string (string->date version "~Y~m~d") "~Y-~m-~d")
+ "/fare-quasiquote-"
+ version
+ "-git.tgz"))
+ (sha256
+ (base32
+ "00brmh7ndsi0c97nibi8cy10j3l4gmkyrfrr5jr5lzkfb7ngyfqa"))))
+ (inputs
+ `(("fare-utils" ,sbcl-fare-utils)))
+ (arguments
+ ;; XXX: Circular dependencies: Tests depend on subsystems, which depend on the main systems.
+ `(#:tests? #f
+ #:phases
+ (modify-phases %standard-phases
+ ;; XXX: Require 1.0.0 version of fare-utils, and we package some
+ ;; commits after 1.0.0.5, but ASDF fails to read the
+ ;; "-REVISION-COMMIT" part generated by Guix.
+ (add-after 'unpack 'patch-requirement
+ (lambda _
+ (substitute* "fare-quasiquote.asd"
+ (("\\(:version \"fare-utils\" \"1.0.0\"\\)") "\"fare-utils\"")))))))
+ (synopsis "Pattern-matching friendly implementation of quasiquote for Common Lisp")
+ (description "The main purpose of this n+2nd reimplementation of
+quasiquote is enable matching of quasiquoted patterns, using Optima or
+Trivia.")
+ (license license:expat)))
+
+(define-public sbcl-fare-quasiquote-readtable
+ (package
+ (inherit sbcl-fare-quasiquote)
+ (name "sbcl-fare-quasiquote-readtable")
+ (inputs
+ `(("fare-quasiquote" ,sbcl-fare-quasiquote)
+ ("named-readtables" ,sbcl-named-readtables)))
+ (description "The main purpose of this n+2nd reimplementation of
+quasiquote is enable matching of quasiquoted patterns, using Optima or
+Trivia.
+
+This packages uses fare-quasiquote with named-readtable.")))
+
+(define-public sbcl-trivia.level0
+ (let ((commit "902e0c65602bbfe96ae82e679330b3771ddc7603")
+ (revision "1"))
+ (package
+ (name "sbcl-trivia.level0")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "0.0.0" revision commit))
+ (home-page "https://github.com/guicho271828/trivia")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "11qbab30qqnfy9mx3x9fvgcw1jbvh1qn2cqv3p8xdn2m8981jvhr"))))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)))
+ (synopsis "Pattern matching in Common Lisp")
+ (description "Trivia is a pattern matching compiler that is compatible
+with Optima, another pattern matching library for Common Lisp. It is meant to
+be faster and more extensible than Optima.")
+ (license license:llgpl))))
+
+(define-public sbcl-trivia.level1
+ (package
+ (inherit sbcl-trivia.level0)
+ (name "sbcl-trivia.level1")
+ (inputs
+ `(("trivia.level0" ,sbcl-trivia.level0)))
+ (description "Trivia is a pattern matching compiler that is compatible
+with Optima, another pattern matching library for Common Lisp. It is meant to
+be faster and more extensible than Optima.
+
+This system contains the core patterns of Trivia.")))
+
+(define-public sbcl-trivia.level2
+ (package
+ (inherit sbcl-trivia.level0)
+ (name "sbcl-trivia.level2")
+ (inputs
+ `(("trivia.level1" ,sbcl-trivia.level1)
+ ("lisp-namespace" ,sbcl-lisp-namespace)
+ ("trivial-cltl2" ,sbcl-trivial-cltl2)
+ ("closer-mop" ,sbcl-closer-mop)))
+ (description "Trivia is a pattern matching compiler that is compatible
+with Optima, another pattern matching library for Common Lisp. It is meant to
+be faster and more extensible than Optima.
+
+This system contains a non-optimized pattern matcher compatible with Optima,
+with extensible optimizer interface.")))
+
+(define-public sbcl-trivia.trivial
+ (package
+ (inherit sbcl-trivia.level0)
+ (name "sbcl-trivia.trivial")
+ (inputs
+ `(("trivia.level2" ,sbcl-trivia.level2)))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (replace 'create-asd-file
+ (lambda* (#:key outputs inputs #:allow-other-keys)
+ (let* ((out (assoc-ref outputs "out"))
+ (lib (string-append out "/lib/" (%lisp-type)))
+ (level2 (assoc-ref inputs "trivia.level2")))
+ (mkdir-p lib)
+ (install-file "trivia.trivial.asd" lib)
+ ;; XXX: This .asd does not have any component and the build
+ ;; system fails to work in this case. We should update the
+ ;; build system to handle component-less .asd.
+ ;; TODO: How do we append to file in Guile? It seems that
+ ;; (open-file ... "a") gets a "Permission denied".
+ (substitute* (string-append lib "/trivia.trivial.asd")
+ (("\"\\)")
+ (string-append "\")
+
+(progn (asdf/source-registry:ensure-source-registry)
+ (setf (gethash
+ \"trivia.level2\"
+ asdf/source-registry:*source-registry*)
+ #p\""
+ level2
+ "/share/common-lisp/sbcl-bundle-systems/trivia.level2.asd\"))")))))))))
+ (description "Trivia is a pattern matching compiler that is compatible
+with Optima, another pattern matching library for Common Lisp. It is meant to
+be faster and more extensible than Optima.
+
+This system contains the base level system of Trivia with a trivial optimizer.")))
+
+(define-public sbcl-trivia.balland2006
+ (package
+ (inherit sbcl-trivia.level0)
+ (name "sbcl-trivia.balland2006")
+ (inputs
+ `(("trivia.trivial" ,sbcl-trivia.trivial)
+ ("iterate" ,sbcl-iterate)
+ ("type-i" ,sbcl-type-i)
+ ("alexandria" ,sbcl-alexandria)))
+ (arguments
+ ;; Tests are done in trivia itself.
+ `(#:tests? #f))
+ (description "Trivia is a pattern matching compiler that is compatible
+with Optima, another pattern matching library for Common Lisp. It is meant to
+be faster and more extensible than Optima.
+
+This system contains the base level system of Trivia with a trivial optimizer.")))
+
+(define-public sbcl-trivia.ppcre
+ (package
+ (inherit sbcl-trivia.level0)
+ (name "sbcl-trivia.ppcre")
+ (inputs
+ `(("trivia.trivial" ,sbcl-trivia.trivial)
+ ("cl-ppcre" ,sbcl-cl-ppcre)))
+ (description "Trivia is a pattern matching compiler that is compatible
+with Optima, another pattern matching library for Common Lisp. It is meant to
+be faster and more extensible than Optima.
+
+This system contains the PPCRE extention.")))
+
+(define-public sbcl-trivia.quasiquote
+ (package
+ (inherit sbcl-trivia.level0)
+ (name "sbcl-trivia.quasiquote")
+ (inputs
+ `(("trivia.trivial" ,sbcl-trivia.trivial)
+ ("fare-quasiquote" ,sbcl-fare-quasiquote)
+ ("fare-quasiquote-readtable" ,sbcl-fare-quasiquote-readtable)))
+ (description "Trivia is a pattern matching compiler that is compatible
+with Optima, another pattern matching library for Common Lisp. It is meant to
+be faster and more extensible than Optima.
+
+This system contains the fare-quasiquote extension.")))
+
+(define-public sbcl-trivia.cffi
+ (package
+ (inherit sbcl-trivia.level0)
+ (name "sbcl-trivia.cffi")
+ (inputs
+ `(("cffi" ,sbcl-cffi)
+ ("trivia.trivial" ,sbcl-trivia.trivial)))
+ (description "Trivia is a pattern matching compiler that is compatible
+with Optima, another pattern matching library for Common Lisp. It is meant to
+be faster and more extensible than Optima.
+
+This system contains the CFFI foreign slot access extension.")))
+
+(define-public sbcl-trivia
+ (package
+ (inherit sbcl-trivia.level0)
+ (name "sbcl-trivia")
+ (inputs
+ `(("trivia.balland2006" ,sbcl-trivia.balland2006)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)
+ ("trivia.ppcre" ,sbcl-trivia.ppcre)
+ ("trivia.quasiquote" ,sbcl-trivia.quasiquote)
+ ("trivia.cffi" ,sbcl-trivia.cffi)
+ ("optima" ,sbcl-optima)))
+ (arguments
+ `(#:test-asd-file "trivia.test.asd"))
+ (description "Trivia is a pattern matching compiler that is compatible
+with Optima, another pattern matching library for Common Lisp. It is meant to
+be faster and more extensible than Optima.")))