;;; Copyright © 2019 Jesse Gildersleve <jessejohngildersleve@protonmail.com>
;;; Copyright © 2019, 2020 Guillaume Le Vaillant <glv@posteo.net>
;;; Copyright © 2019 Brett Gilio <brettg@gnu.org>
+;;; Copyright © 2020 Konrad Hinsen <konrad.hinsen@fastmail.net>
+;;; Copyright © 2020 Dimakis Dimakakos <me@bendersteed.tech>
;;;
;;; This file is part of GNU Guix.
;;;
#:use-module (guix build-system trivial)
#:use-module (gnu packages c)
#:use-module (gnu packages compression)
+ #:use-module (gnu packages databases)
#:use-module (gnu packages glib)
#:use-module (gnu packages gtk)
#:use-module (gnu packages imagemagick)
#:use-module (gnu packages libffi)
#:use-module (gnu packages lisp)
#:use-module (gnu packages maths)
+ #:use-module (gnu packages networking)
#:use-module (gnu packages pkg-config)
#:use-module (gnu packages python)
#:use-module (gnu packages python-xyz)
(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))
ANSI CL by David N. Gray. The proposal did not make it into ANSI CL, but most
popular CL implementations implement it. This package provides an extremely
thin compatibility layer for gray streams.")
- (home-page "http://www.cliki.net/trivial-gray-streams")
+ (home-page "https://www.cliki.net/trivial-gray-streams")
(license license:x11))))
(define-public cl-trivial-gray-streams
(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
(build-system asdf-build-system/sbcl)
(native-inputs
`(("fiasco" ,sbcl-fiasco)))
- (home-page "http://www.cliki.net/portable-clx")
+ (home-page "https://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
`(("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-iterate
(package
(name "sbcl-iterate")
- ;; The latest official release (1.4.3) fails to build so we have to take
- ;; the current darcs tarball from quicklisp.
- (version "20160825")
+ (version "1.5")
(source
(origin
(method url-fetch)
- (uri (string-append "http://beta.quicklisp.org/archive/iterate/"
- "2016-08-25/iterate-"
- version "-darcs.tgz"))
+ (uri (string-append "https://common-lisp.net/project/iterate/releases/"
+ "iterate-" version ".tar.gz"))
(sha256
(base32
- "0kvz16gnxnkdz0fy1x8y5yr28nfm7i2qpvix7mgwccdpjmsb4pgm"))))
+ "1lqsbhrkfl0yif46aymvb7l3nb9wdcmj4jyw485blj32jb4famzn"))))
(build-system asdf-build-system/sbcl)
(native-inputs
`(("rt" ,sbcl-rt)))
(base32 "0ccv7dqyrk55xga78i5vzlic7mdwp28in3g1a8fqhlk6626scsq9"))))
(build-system asdf-build-system/sbcl)
(arguments '(#:tests? #f))
- (home-page "http://cliki.net/trivial-features")
+ (home-page "https://cliki.net/trivial-features")
(synopsis "Ensures consistency of @code{*FEATURES*} in Common Lisp")
(description "Trivial-features ensures that @code{*FEATURES*} is
consistent across multiple Common Lisp implementations.")
(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
(sbcl-package->ecl-package sbcl-cl-fad))
(define-public sbcl-rt
- (package
- (name "sbcl-rt")
- (version "1990.12.19")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "http://beta.quicklisp.org/archive/rt/2010-10-06/rt-"
- "20101006-git" ".tgz"))
- (sha256
- (base32
- "1jncar0xwkqk8yrc2dln389ivvgzs7ijdhhs3zpfyi5d21f0qa1v"))))
- (build-system asdf-build-system/sbcl)
- (synopsis "MIT Regression Tester")
- (description
- "RT provides a framework for writing regression test suites.")
- (home-page "https://github.com/sharplispers/nibbles")
- (license license:unlicense)))
+ (let ((commit "a6a7503a0b47953bc7579c90f02a6dba1f6e4c5a")
+ (revision "1"))
+ (package
+ (name "sbcl-rt")
+ (version (git-version "1990.12.19" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "http://git.kpe.io/rt.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "13si2rrxaagbr0bkvg6sqicxxpyshabx6ad6byc9n2ik5ysna69b"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "MIT Regression Tester")
+ (description
+ "RT provides a framework for writing regression test suites.")
+ (home-page "https://www.cliki.net/rt")
+ (license license:expat))))
(define-public cl-rt
(sbcl-package->cl-source-package sbcl-rt))
("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
(sbcl-package->ecl-package sbcl-cl-string-match))
(define-public sbcl-ptester
- (package
- (name "sbcl-ptester")
- (version "20160929")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "http://beta.quicklisp.org/archive/ptester/"
- (date->string (string->date version "~Y~m~d") "~Y-~m-~d")
- "/ptester-"
- version
- "-git.tgz"))
- (sha256
- (base32
- "04rlq1zljhxc65pm31bah3sq3as24l0sdivz440s79qlnnyh13hz"))))
- (build-system asdf-build-system/sbcl)
- (home-page "http://quickdocs.org/ptester/")
- (synopsis "Portable test harness package")
- (description
- "@command{ptester} is a portable testing framework based on Franz's
+ (let ((commit "fe69fde54f4bce00ce577feb918796c293fc7253")
+ (revision "1"))
+ (package
+ (name "sbcl-ptester")
+ (version (git-version "2.1.3" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "http://git.kpe.io/ptester.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1l0lfl7cdnr2qf4zh38hi4llxg22c49zkm639bdkmvlkzwj3ndwf"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "http://quickdocs.org/ptester/")
+ (synopsis "Portable test harness package")
+ (description
+ "@command{ptester} is a portable testing framework based on Franz's
tester module.")
- (license license:lgpl3+)))
+ (license license:llgpl))))
(define-public cl-ptester
(sbcl-package->cl-source-package sbcl-ptester))
(sbcl-package->ecl-package sbcl-ptester))
(define-public sbcl-puri
- (package
- (name "sbcl-puri")
- (version "20180228")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "http://beta.quicklisp.org/archive/puri/"
- (date->string (string->date version "~Y~m~d") "~Y-~m-~d")
- "/puri-"
- version
- "-git.tgz"))
- (sha256
- (base32
- "1s4r5adrjy5asry45xbcbklxhdjydvf6n55z897nvyw33bigrnbz"))))
- (build-system asdf-build-system/sbcl)
- ;; REVIEW: Webiste down?
- (native-inputs
- `(("ptester" ,sbcl-ptester)))
- (home-page "http://files.kpe.io/puri/")
- (synopsis "Portable URI Library")
- (description
- "This is portable Universal Resource Identifier library for Common Lisp
-programs. It parses URI according to the RFC 2396 specification")
- (license license:lgpl3+)))
+ (let ((commit "ef5afb9e5286c8e952d4344f019c1a636a717b97")
+ (revision "1"))
+ (package
+ (name "sbcl-puri")
+ (version (git-version "1.5.7" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "http://git.kpe.io/puri.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1vm25pdl92laj72p5vyd538kf3cjy2655z6bdc99h20ana2p231s"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("ptester" ,sbcl-ptester)))
+ (home-page "http://quickdocs.org/puri/")
+ (synopsis "Portable URI Library")
+ (description
+ "This is a portable Universal Resource Identifier library for Common
+Lisp programs. It parses URI according to the RFC 2396 specification.")
+ (license license:llgpl))))
(define-public cl-puri
(sbcl-package->cl-source-package sbcl-puri))
(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)
(define-public ecl-portable-threada
(sbcl-package->ecl-package sbcl-portable-threads))
-(define-public sbcl-usocket-boot0
+(define sbcl-usocket-boot0
;; usocket's test rely on usocket-server which depends on usocket itself.
;; We break this cyclic dependency with -boot0 that packages usocket.
- (let ((commit "86e7efbfe50101931edf4b67cdcfa7e221ecfde9"))
- (package
- (name "sbcl-usocket-boot0")
- (version (git-version "0.7.1" "1" commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/usocket/usocket/")
- (commit commit)))
- (file-name (git-file-name "usocket" version))
- (sha256
- (base32
- "1lk6ipakrib7kdgzw44hrgmls9akp5pz4h35yynw0k5zwmmq6374"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("split-sequence" ,sbcl-split-sequence)))
- (arguments
- `(#:tests? #f
- #:asd-system-name "usocket"))
- (home-page "https://common-lisp.net/project/usocket/")
- (synopsis "Universal socket library for Common Lisp (server side)")
- (description
- "This library strives to provide a portable TCP/IP and UDP/IP socket
+ (package
+ (name "sbcl-usocket-boot0")
+ (version "0.8.3")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/usocket/usocket/")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "usocket" version))
+ (sha256
+ (base32
+ "0x746wr2324l6bn7skqzgkzcbj5kd0zp2ck0c8rldrw0rzabg826"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("split-sequence" ,sbcl-split-sequence)))
+ (arguments
+ `(#:tests? #f
+ #:asd-system-name "usocket"))
+ (home-page "https://common-lisp.net/project/usocket/")
+ (synopsis "Universal socket library for Common Lisp (server side)")
+ (description
+ "This library strives to provide a portable TCP/IP and UDP/IP socket
interface for as many Common Lisp implementations as possible, while keeping
the abstraction and portability layer as thin as possible.")
- (license license:expat))))
+ (license license:expat)))
(define-public sbcl-usocket-server
(package
(inherit sbcl-usocket-boot0)
(name "sbcl-usocket-server")
(inputs
- `(("usocket" ,sbcl-usocket-boot0)
- ("portable-threads" ,sbcl-portable-threads)))
+ `(("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("usocket" ,sbcl-usocket-boot0)))
(arguments
'(#:asd-system-name "usocket-server"))
(synopsis "Universal socket library for Common Lisp (server side)")))
(define-public cl-usocket
(sbcl-package->cl-source-package sbcl-usocket))
-(define-public ecl-socket
+(define-public ecl-usocket
(sbcl-package->ecl-package sbcl-usocket))
(define-public sbcl-s-xml
(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 "https://github.com/sionescu/static-vectors")
+ (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))
+(define-public ecl-static-vectors
+ (sbcl-package->ecl-package sbcl-static-vectors))
+
(define-public sbcl-marshal
(let ((commit "eff1b15f2b0af2f26f71ad6a4dd5c4beab9299ec")
(revision "1"))
`(("stefil" ,sbcl-hu.dwim.stefil)))
(inputs
`(("sbcl-cl-fad" ,sbcl-cl-fad)))
- (home-page "http://shinmera.github.io/trivial-mimes/")
+ (home-page "https://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
("sbcl-lack-component" ,sbcl-lack-component)
("sbcl-alexandria" ,sbcl-alexandria)
("sbcl-babel" ,sbcl-babel)))
- (home-page "http://8arrow.org/ningle/")
+ (home-page "https://8arrow.org/ningle/")
(synopsis "Super micro framework for Common Lisp")
(description
"Ningle is a lightweight web application framework for Common Lisp.")
(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
+ (let ((commit "549aebbfb9403a7fe948654126b9c814f443f4f2")
+ (revision "1"))
+ (package
+ (name "sbcl-parse-declarations")
+ (version (git-version "1.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url (string-append
+ "https://gitlab.common-lisp.net/parse-declarations/"
+ "parse-declarations.git"))
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "03g5qks4c59nmxa48pbslxkfh77h8hn8566jddp6m9pl15dzzpxd"))))
+ (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)))
+ ;; MIT License
+ (license license:expat))))
(define-public cl-parse-declarations
(sbcl-package->cl-source-package sbcl-parse-declarations))
(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
(sbcl-package->cl-source-package sbcl-optima))
(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 cl-fare-quasiquote
- (sbcl-package->cl-source-package sbcl-fare-quasiquote))
-
-(define-public sbcl-fare-quasiquote-optima
+ (let ((commit "640d39a0451094071b3e093c97667b3947f43639")
+ (revision "1"))
+ (package
+ (name "sbcl-fare-quasiquote")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "1.0.1" revision commit))
+ (home-page "https://gitlab.common-lisp.net/frideau/fare-quasiquote")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url (string-append "https://gitlab.common-lisp.net/frideau/"
+ "fare-quasiquote.git"))
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1g6q11l50kgija9f55lzqpcwvaq0ljiw8v1j265hnyg6nahjwjvg"))))
+ (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")
+ (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 cl-fare-quasiquote
+ (sbcl-package->cl-source-package sbcl-fare-quasiquote))
+
+(define-public sbcl-fare-quasiquote-optima
(package
(inherit sbcl-fare-quasiquote)
(name "sbcl-fare-quasiquote-optima")
(sbcl-package->cl-source-package sbcl-fare-quasiquote-readtable))
;; TODO: Add support for component-less system in asdf-build-system/sbcl.
+(define-public sbcl-fare-quasiquote-extras
+ (package
+ (inherit sbcl-fare-quasiquote)
+ (name "sbcl-fare-quasiquote-extras")
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("fare-quasiquote-optima" ,sbcl-fare-quasiquote-optima)
+ ("fare-quasiquote-readtable" ,sbcl-fare-quasiquote-readtable)))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (replace 'build
+ (lambda* (#:key outputs #:allow-other-keys)
+ (let* ((out (assoc-ref outputs "out"))
+ (lib (string-append out "/lib/" (%lisp-type))))
+ (mkdir-p lib)
+ (install-file "fare-quasiquote-extras.asd" lib)
+ (make-file-writable
+ (string-append lib "/fare-quasiquote-extras.asd"))
+ #t)))
+ (add-after 'create-asd-file 'fix-asd-file
+ (lambda* (#:key outputs #:allow-other-keys)
+ (let* ((out (assoc-ref outputs "out"))
+ (lib (string-append out "/lib/" (%lisp-type)))
+ (asd (string-append lib "/fare-quasiquote-extras.asd")))
+ (substitute* asd
+ ((":class")
+ "")
+ (("asdf/bundle:prebuilt-system")
+ "")
+ ((":components")
+ "")
+ (("\\(\\(:compiled-file \"fare-quasiquote-extras--system\"\\)\\)")
+ "")))
+ #t)))))
+ (description "This library combines @code{fare-quasiquote-readtable} and
+@code{fare-quasiquote-optima}.")))
+
(define-public cl-fare-quasiquote-extras
(package
(inherit cl-fare-quasiquote)
@code{fare-quasiquote-optima}.")))
(define-public sbcl-trivia.level0
- (let ((commit "902e0c65602bbfe96ae82e679330b3771ddc7603")
+ (let ((commit "574901ac376ae54c9d37169fd5efab9b3b8fcc63")
(revision "1"))
(package
(name "sbcl-trivia.level0")
(file-name (git-file-name name version))
(sha256
(base32
- "11qbab30qqnfy9mx3x9fvgcw1jbvh1qn2cqv3p8xdn2m8981jvhr"))))
+ "0hf53n71xzr9sjwrxis5fivx3drclf4s39h5ck8vh21ndqj9zvdk"))))
(inputs
`(("alexandria" ,sbcl-alexandria)))
(synopsis "Pattern matching in Common Lisp")
(sbcl-package->ecl-package sbcl-lzlib))
(define-public sbcl-chanl
- (let ((commit "2362b57550c2c9238cc882d03553aaa1040b7340")
- (revision "0"))
+ (let ((commit "56e90a126c78b39bb621a01585e8d3b985238e8c")
+ (revision "1"))
(package
(name "sbcl-chanl")
(version (git-version "0.4.1" revision commit))
(file-name (git-file-name name version))
(sha256
(base32
- "0ag3wz7yrqwp0s5069wwda98z3rrqd25spg8sa8rdqghj084w28w"))))
+ "0b1cf6c12qx5cy1fw2z42jgh566rp3l8nv5qf0qqc569s7bgmrh4"))))
(build-system asdf-build-system/sbcl)
(native-inputs
`(("fiveam" ,sbcl-fiveam)))
(sbcl-package->cl-source-package sbcl-chanl))
(define-public ecl-chanl
- (let ((base (sbcl-package->ecl-package sbcl-chanl)))
- (package
- (inherit base)
- (arguments
- (substitute-keyword-arguments (package-arguments base)
- ;; The CHANL.ACTORS package uses the :ARGUMENTS option of
- ;; DEFINE-METHOD-COMBINATION, which is not implemented in ECL yet
- ;; (see https://gitlab.com/embeddable-common-lisp/ecl/issues/305).
- ;; So let's disable it for now, as it allows compiling the library
- ;; and using the rest of it.
- ((#:phases phases '%standard-phases)
- `(modify-phases ,phases
- (add-after 'unpack 'disable-chanl-actors
- (lambda _
- (substitute* "chanl.asd"
- (("\\(:file \"actors\"\\)") ""))
- #t))))
- ;; Disable the tests for now, as the SEND-SEQUENCE test seems to
- ;; never end.
- ((#:tests? _ #f) #f))))))
+ (sbcl-package->ecl-package sbcl-chanl))
(define-public sbcl-cl-store
(let ((commit "c787337a16ea8cf8a06227f35933a4ec774746b3")
("trivial-garbage" ,sbcl-trivial-garbage)
("bordeaux-threads" ,sbcl-bordeaux-threads)
("named-readtables" ,sbcl-named-readtables)
- ("fare-quasiquote-extras" ,cl-fare-quasiquote-extras)
+ ("fare-quasiquote-extras" ,sbcl-fare-quasiquote-extras)
("parse-declarations-1.0" ,sbcl-parse-declarations)
("global-vars" ,sbcl-global-vars)
("trivial-file-size" ,sbcl-trivial-file-size)
("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 cl-documentation-utils
(sbcl-package->cl-source-package sbcl-documentation-utils))
+(define-public ecl-documentation-utils
+ (sbcl-package->ecl-package sbcl-documentation-utils))
+
(define-public sbcl-form-fiddle
(let ((commit "e0c23599dbb8cff3e83e012f3d86d0764188ad18")
(revision "0"))
(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/")
+ (home-page "https://orthecreedence.github.io/blackbird/")
(license license:expat))))
(define-public cl-blackbird
(description
"This is futures implementation for Common Lisp. It plugs in nicely
to cl-async.")
- (home-page "http://orthecreedence.github.io/cl-async/future")
+ (home-page "https://orthecreedence.github.io/cl-async/future")
(license license:expat))))
(define-public cl-async-future
(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))
+
+(define-public sbcl-hdf5-cffi
+ (let ((commit "5b5c88f191e470e4fe96b462334e3ce0806eed5c")
+ (revision "1"))
+ (package
+ (name "sbcl-hdf5-cffi")
+ (version (git-version "1.8.18" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/hdfgroup/hdf5-cffi.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0vda3075423xz83qky998lpac5b04dwfv7bwgh9jq8cs5v0zrxjf"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Common Lisp bindings for the HDF5 library")
+ (description
+ "@code{hdf5-cffi} is a CFFI wrapper for the HDF5 library.")
+ (home-page "https://github.com/hdfgroup/hdf5-cffi")
+ (license (license:non-copyleft
+ (string-append "https://github.com/HDFGroup/hdf5-cffi/raw/"
+ commit
+ "/LICENSE")))
+ (inputs
+ `(("cffi" ,sbcl-cffi)
+ ("cffi-grovel" ,sbcl-cffi-grovel)
+ ("hdf5" ,hdf5-1.10)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (arguments
+ `(#:asd-system-name "hdf5-cffi"
+ #:asd-file "hdf5-cffi.asd"
+ #:test-asd-file "hdf5-cffi.test.asd"
+ ;; Tests depend on hdf5-cffi.examples.asd in addition to hdf5-cffi.asd,
+ ;; I don't know if there is a way to tell asdf-build-system to load
+ ;; an additional system first, so tests are disabled.
+ #:tests? #f
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/library.lisp"
+ (("libhdf5.so")
+ (string-append
+ (assoc-ref inputs "hdf5")
+ "/lib/libhdf5.so")))))
+ (add-after 'unpack 'fix-dependencies
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "hdf5-cffi.asd"
+ ((":depends-on \\(:cffi\\)")
+ ":depends-on (:cffi :cffi-grovel)"))
+ (substitute* "hdf5-cffi.test.asd"
+ ((":depends-on \\(:cffi :hdf5-cffi")
+ ":depends-on (:cffi :cffi-grovel :hdf5-cffi"))))))))))
+
+(define-public cl-hdf5-cffi
+ (sbcl-package->cl-source-package sbcl-hdf5-cffi))
+
+(define-public ecl-hdf5-cffi
+ (sbcl-package->ecl-package sbcl-hdf5-cffi))
+
+(define-public sbcl-cl-randist
+ (package
+ (name "sbcl-cl-randist")
+ (version "0.4.2")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/lvaruzza/cl-randist.git")
+ (commit "f088a54b540a7adefab7c04094a6103f9edda3d0")))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0l8hyd6nbxb7f50vyxz3rbbm7kgr1fnadc40jywy4xj5vi5kpj5g"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Random distributions for Common Lisp")
+ (description
+ "Manual translation from C to Common Lisp of some random number
+generation functions from the GSL library.")
+ (home-page "https://github.com/lvaruzza/cl-randist")
+ (license license:bsd-2)
+ (arguments
+ `(#:asd-system-name "cl-randist"
+ #:asd-file "cl-randist.asd"
+ #:tests? #f))))
+
+(define-public cl-randist
+ (sbcl-package->cl-source-package sbcl-cl-randist))
+
+(define-public ecl-cl-randist
+ (sbcl-package->ecl-package sbcl-cl-randist))
+
+(define-public sbcl-float-features
+ (package
+ (name "sbcl-float-features")
+ (version "1.0.0")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Shinmera/float-features.git")
+ (commit "d3ef60181635b0849aa28cfc238053b7ca4644b0")))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0yj419k7n59x6rh3grwr6frgwwyria2il6f7wxpfazm8cskv4lzr"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Common Lisp IEEE float portability library")
+ (description
+ "Portability library for IEEE float features that are not
+covered by the Common Lisp standard.")
+ (home-page "https://github.com/Shinmera/float-features")
+ (license license:zlib)
+ (inputs
+ `(("documentation-utils" ,sbcl-documentation-utils)))
+ (arguments
+ `(#:asd-system-name "float-features"
+ #:asd-file "float-features.asd"
+ #:tests? #f))))
+
+(define-public cl-float-features
+ (sbcl-package->cl-source-package sbcl-float-features))
+
+(define-public ecl-float-features
+ (sbcl-package->ecl-package sbcl-float-features))
+
+(define-public sbcl-function-cache
+ (package
+ (name "sbcl-function-cache")
+ (version "1.0.3")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/AccelerationNet/function-cache.git")
+ (commit "6a5ada401e57da2c8abf046f582029926e61fce8")))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "000vmd3f5rx5hs9nvphfric0gkzaadns31c6mxaslpv0k7pkrmc6"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Function caching / memoization library for Common Lisp")
+ (description
+ "A common lisp library that provides extensible function result
+caching based on arguments (an expanded form of memoization).")
+ (home-page "https://github.com/AccelerationNet/function-cache")
+ (license
+ (license:non-copyleft
+ "https://github.com/AccelerationNet/function-cache/blob/master/README.md"))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-interpol" ,sbcl-cl-interpol)
+ ("iterate" ,sbcl-iterate)
+ ("symbol-munger" ,sbcl-symbol-munger)
+ ("closer-mop" ,sbcl-closer-mop)))
+ (arguments
+ `(#:asd-system-name "function-cache"
+ #:asd-file "function-cache.asd"
+ #:tests? #f))))
+
+(define-public cl-function-cache
+ (sbcl-package->cl-source-package sbcl-function-cache))
+
+(define-public ecl-function-cache
+ (sbcl-package->ecl-package sbcl-function-cache))
+
+(define-public sbcl-type-r
+ (let ((commit "83c89e38f2f7a7b16f1012777ecaf878cfa6a267")
+ (revision "1"))
+ (package
+ (name "sbcl-type-r")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/guicho271828/type-r.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1arsxc2539rg8vbrdirz4xxj1b06mc6g6rqndz7a02g127qvk2sm"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Parser interface for Common Lisp built-in compound types")
+ (description
+ "Collections of accessor functions and patterns to access
+the elements in compound type specifier, e.g. @code{dimensions} in
+@code{(array element-type dimensions)}")
+ (home-page "https://github.com/guicho271828/type-r")
+ (license license:lgpl3+)
+ (inputs
+ `(("trivia" ,sbcl-trivia)
+ ("alexandria" ,sbcl-alexandria)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (arguments
+ `(#:asd-system-name "type-r"
+ #:asd-file "type-r.asd"
+ #:test-asd-file "type-r.test.asd")))))
+
+(define-public cl-type-r
+ (sbcl-package->cl-source-package sbcl-type-r))
+
+(define-public sbcl-trivialib-type-unify
+ (let ((commit "62492ebf04db567dcf435ae84c50b7b8202ecf99")
+ (revision "1"))
+ (package
+ (name "sbcl-trivialib-type-unify")
+ (version (git-version "0.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/guicho271828/trivialib.type-unify.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1bkyfzbwv75p50zp8n1n9rh2r29pw3vgz91gmn2gzzkyq3khj1vh"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Common Lisp type unification")
+ (description
+ "Unifies a parametrized type specifier against an actual type specifier.
+Importantly, it handles complicated array-subtypes and number-related types
+correctly.")
+ (home-page "https://github.com/guicho271828/trivialib.type-unify")
+ (license license:lgpl3+)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("trivia" ,sbcl-trivia)
+ ("introspect-environment" ,sbcl-introspect-environment)
+ ("type-r" ,sbcl-type-r)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (arguments
+ `(#:asd-system-name "trivialib.type-unify"
+ #:asd-file "trivialib.type-unify.asd"
+ #:test-asd-file "trivialib.type-unify.test.asd")))))
+
+(define-public cl-trivialib-type-unify
+ (sbcl-package->cl-source-package sbcl-trivialib-type-unify))
+
+(define-public sbcl-specialized-function
+ (let ((commit "b96b6afaf8358bf91cc0703e62a5a4ee20d2b7bc")
+ (revision "1"))
+ (package
+ (name "sbcl-specialized-function")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/numcl/specialized-function.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "12j45ff0n26578vmfbhb9mfbdchw4wy023k0m2ppgl9s0z4bhjaj"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Julia-like dispatch for Common Lisp")
+ (description
+ "This library is part of NUMCL. It provides a macro
+@code{SPECIALIZED} that performs a Julia-like dispatch on the arguments,
+lazily compiling a type-specific version of the function from the same
+code. The main target of this macro is speed.")
+ (home-page "https://github.com/numcl/specialized-function")
+ (license license:lgpl3+)
+ (inputs
+ `(("trivia" ,sbcl-trivia)
+ ("alexandria" ,sbcl-alexandria)
+ ("iterate" ,sbcl-iterate)
+ ("lisp-namespace" ,sbcl-lisp-namespace)
+ ("type-r" ,sbcl-type-r)
+ ("trivial-cltl2" ,sbcl-trivial-cltl2)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (arguments
+ `(#:asd-system-name "specialized-function"
+ #:asd-file "specialized-function.asd"
+ #:test-asd-file "specialized-function.test.asd")))))
+
+(define-public cl-specialized-function
+ (sbcl-package->cl-source-package sbcl-specialized-function))
+
+(define-public sbcl-constantfold
+ (let ((commit "0ff1d97a3fbcb89264f6a2af6ce62b73e7b421f4")
+ (revision "1"))
+ (package
+ (name "sbcl-constantfold")
+ (version (git-version "0.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/numcl/constantfold.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "153h0569z6bff1qbad0bdssplwwny75l7ilqwcfqfdvzsxf9jh06"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Support library for numcl")
+ (description
+ "Support library for numcl. Registers a function as an
+additional form that is considered as a candidate for a constant.")
+ (home-page "https://github.com/numcl/constantfold")
+ (license license:lgpl3+)
+ (inputs
+ `(("trivia" ,sbcl-trivia)
+ ("alexandria" ,sbcl-alexandria)
+ ("iterate" ,sbcl-iterate)
+ ("lisp-namespace" ,sbcl-lisp-namespace)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (arguments
+ `(#:asd-system-name "constantfold"
+ #:asd-file "constantfold.asd"
+ #:test-asd-file "constantfold.test.asd")))))
+
+(define-public cl-constantfold
+ (sbcl-package->cl-source-package sbcl-constantfold))
+
+(define-public sbcl-gtype
+ (let ((commit "42275e3606242ae91e9c8dfa30c18ced50a35b66")
+ (revision "1"))
+ (package
+ (name "sbcl-gtype")
+ (version (git-version "0.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/numcl/gtype.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1f56dba998v945jcxhha391557n6md1ql25b7icfwwfivhmlaa9b"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "C++/Julia-like parametric types in Common Lisp")
+ (description
+ "Support library for numcl that provides Julia-like runtime parametric
+type correctness in Common Lisp. It is based on CLtL2 extensions.")
+ (home-page "https://github.com/numcl/gtype")
+ (license license:lgpl3+)
+ (inputs
+ `(("trivialib.type-unify" ,sbcl-trivialib-type-unify)
+ ("trivial-cltl2" ,sbcl-trivial-cltl2)
+ ("trivia" ,sbcl-trivia)
+ ("alexandria" ,sbcl-alexandria)
+ ("iterate" ,sbcl-iterate)
+ ("type-r" ,sbcl-type-r)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (arguments
+ `(#:asd-system-name "gtype"
+ #:asd-file "gtype.asd"
+ #:test-asd-file "gtype.test.asd")))))
+
+(define-public cl-gtype
+ (sbcl-package->cl-source-package sbcl-gtype))
+
+(define-public sbcl-numcl
+ (let ((commit "1cf7dfa59f763a24a501092870e9c5ee745d0c17")
+ (revision "1"))
+ (package
+ (name "sbcl-numcl")
+ (version (git-version "0.1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/numcl/numcl.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0i3jby9hf4ii7blivgyza80g0vmjfhk8537i5i7kqqk0i5sdnym2"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Numpy clone in Common Lisp")
+ (description
+ "This is a Numpy clone in Common Lisp. At the moment the
+library is written in pure Common Lisp, focusing more on correctness
+and usefulness, not speed. Track the progress at
+@url{https://github.com/numcl/numcl/projects/1}.")
+ (home-page "https://github.com/numcl/numcl")
+ (license license:lgpl3+)
+ (inputs
+ `(("trivia" ,sbcl-trivia)
+ ("alexandria" ,sbcl-alexandria)
+ ("iterate" ,sbcl-iterate)
+ ("lisp-namespace" ,sbcl-lisp-namespace)
+ ("type-r" ,sbcl-type-r)
+ ("constantfold" ,sbcl-constantfold)
+ ("cl-randist" ,sbcl-cl-randist)
+ ("float-features" ,sbcl-float-features)
+ ("function-cache" ,sbcl-function-cache)
+ ("specialized-function" ,sbcl-specialized-function)
+ ("gtype" ,sbcl-gtype)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (arguments
+ `(#:asd-system-name "numcl"
+ #:asd-file "numcl.asd"
+ #:test-asd-file "numcl.test.asd")))))
+
+(define-public cl-numcl
+ (sbcl-package->cl-source-package sbcl-numcl))
+
+(define-public sbcl-pzmq
+ (let ((commit "7c7390eedc469d033c72dc497984d1536ee75826")
+ (revision "1"))
+ (package
+ (name "sbcl-pzmq")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/orivej/pzmq.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0gmwzf7h90wa7v4wnk49g0hv2mdalljpwhyigxcb967wzv8lqci9"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("fiveam" ,sbcl-fiveam)
+ ("let-plus" ,sbcl-let-plus)))
+ (inputs
+ `(("cffi" ,sbcl-cffi)
+ ("cffi-grovel" ,sbcl-cffi-grovel)
+ ("zeromq" ,zeromq)))
+ (arguments
+ `(#:phases (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "c-api.lisp"
+ (("\"libzmq")
+ (string-append "\""
+ (assoc-ref inputs "zeromq")
+ "/lib/libzmq")))
+ #t)))))
+ (synopsis "Common Lisp bindings for the ZeroMQ library")
+ (description "This Common Lisp library provides bindings for the ZeroMQ
+lightweight messaging kernel.")
+ (home-page "https://github.com/orivej/pzmq")
+ (license license:unlicense))))
+
+(define-public cl-pzmq
+ (sbcl-package->cl-source-package sbcl-pzmq))
+
+(define-public ecl-pzmq
+ (sbcl-package->ecl-package sbcl-pzmq))
+
+(define-public sbcl-clss
+ (let ((revision "1")
+ (commit "2a8e8615ab55870d4ca01928f3ed3bbeb4e75c8d"))
+ (package
+ (name "sbcl-clss")
+ (version (git-version "0.3.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri
+ (git-reference
+ (url "https://github.com/Shinmera/clss.git")
+ (commit commit)))
+ (sha256
+ (base32 "0la4dbcda78x29szanylccrsljqrn9d1mhh569sqkyp44ni5fv91"))
+ (file-name (git-file-name name version))))
+ (inputs
+ `(("array-utils" ,sbcl-array-utils)
+ ("plump" ,sbcl-plump)))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "DOM tree searching engine based on CSS selectors")
+ (description "CLSS is a DOM traversal engine based on CSS
+selectors. It makes use of the Plump-DOM and is used by lQuery.")
+ (home-page "https://github.com/Shinmera/clss")
+ (license license:zlib))))
+
+(define-public cl-clss
+ (sbcl-package->cl-source-package sbcl-clss))
+
+(define-public ecl-clss
+ (sbcl-package->ecl-package sbcl-clss))
+
+(define-public sbcl-lquery
+ (let ((revision "1")
+ (commit "8048111c6b83956daa632e7a3ffbd8c9c203bd8d"))
+ (package
+ (name "sbcl-lquery")
+ (version (git-version "3.2.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri
+ (git-reference
+ (url "https://github.com/Shinmera/lquery.git")
+ (commit commit)))
+ (sha256
+ (base32 "0520mcpxc2d6fdm8z61arpgd2z38kan7cf06qs373n5r64rakz6w"))
+ (file-name (git-file-name name version))))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (inputs
+ `(("array-utils" ,sbcl-array-utils)
+ ("form-fiddle" ,sbcl-form-fiddle)
+ ("plump" ,sbcl-plump)
+ ("clss" ,sbcl-clss)))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Library to allow jQuery-like HTML/DOM manipulation")
+ (description "@code{lQuery} is a DOM manipulation library written in
+Common Lisp, inspired by and based on the jQuery syntax and
+functions. It uses Plump and CLSS as DOM and selector engines. The
+main idea behind lQuery is to provide a simple interface for crawling
+and modifying HTML sites, as well as to allow for an alternative
+approach to templating.")
+ (home-page "https://github.com/Shinmera/lquery")
+ (license license:zlib))))
+
+(define-public cl-lquery
+ (sbcl-package->cl-source-package sbcl-lquery))
+
+(define-public ecl-lquery
+ (sbcl-package->ecl-package sbcl-lquery))
+
+(define-public sbcl-cl-mysql
+ (let ((commit "ab56c279c1815aec6ca0bfe85164ff7e85cfb6f9")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-mysql")
+ (version (git-version "0.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/hackinghat/cl-mysql.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0dg5ynx2ww94d0qfwrdrm7plkn43h64hs4iiq9mj2s1s4ixnp3lr"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("stefil" ,sbcl-stefil)))
+ (inputs
+ `(("cffi" ,sbcl-cffi)
+ ("mariadb-lib" ,mariadb "lib")))
+ (arguments
+ `(#:tests? #f ; TODO: Tests require a running server
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "system.lisp"
+ (("libmysqlclient_r" all)
+ (string-append (assoc-ref inputs "mariadb-lib")
+ "/lib/"
+ all)))
+ #t)))))
+ (synopsis "Common Lisp wrapper for MySQL")
+ (description
+ "@code{cl-mysql} is a Common Lisp implementation of a MySQL wrapper.")
+ (home-page "http://www.hackinghat.com/index.php/cl-mysql")
+ (license license:expat))))
+
+(define-public cl-mysql
+ (sbcl-package->cl-source-package sbcl-cl-mysql))
+
+(define-public sbcl-simple-date
+ (let ((commit "74469b25bbda990ec9b77e0d0eccdba0cd7e721a")
+ (revision "1"))
+ (package
+ (name "sbcl-simple-date")
+ (version (git-version "1.19" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/marijnh/Postmodern.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0im7ymnyxjhn2w74jfg76k5gpr0gl33n31akx33hl28722ljd0hd"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (synopsis "Basic date and time objects for Common Lisp")
+ (description
+ "@code{simple-date} is a very basic implementation of date and time
+objects, used to support storing and retrieving time-related SQL types.")
+ (home-page "https://marijnhaverbeke.nl/postmodern/")
+ (license license:zlib))))
+
+(define-public cl-simple-date
+ (sbcl-package->cl-source-package sbcl-simple-date))
+
+(define-public ecl-simple-date
+ (sbcl-package->ecl-package sbcl-simple-date))
+
+(define-public sbcl-cl-postgres
+ (package
+ (inherit sbcl-simple-date)
+ (name "sbcl-cl-postgres")
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)
+ ("simple-date" ,sbcl-simple-date)))
+ (inputs
+ `(("md5" ,sbcl-md5)
+ ("split-sequence" ,sbcl-split-sequence)
+ ("usocket" ,sbcl-usocket)))
+ (arguments
+ `(#:tests? #f)) ; TODO: Break simple-date/postgres-glue circular dependency
+ (synopsis "Common Lisp interface for PostgreSQL")
+ (description
+ "@code{cl-postgres} is a low-level library used for interfacing with
+a PostgreSQL server over a socket.")))
+
+(define-public cl-postgres
+ (sbcl-package->cl-source-package sbcl-cl-postgres))
HCoop / jackhill / guix / guix.git / blobdiff